คลังเก็บหมวดหมู่: ไม่มีหมวดหมู่

วิทยาการคำนวณ ม.3

แหล่งเรียนรู้นอกเว็บ

เมนูบทเรียน


วิทยาการคำนวณ ม.2

หน่วยที่ 1 แนวคิดเชิงคำนวณ
บทที่ 1 แนวคิดเชิงคำนวณ

หน่วยที่ 2 การเขียนโปรแกรมเบื้องต้น
บทที่ 2 ทบทวน Scratch
บทที่ 3 ประยุกต์ใช้ Scratch สร้างงาน
บทที่ 4 ตัวดำเนินการบูลีน
บทที่ 5 การวนซ้ำด้วยคำสั่ง while
บทที่ 6 เงื่อนไขทางเลือก if-elif-else
บทที่ 7 ฟังก์ชัน

หน่วยที่ 3 ระบบคอมพิวเตอร์
บทที่ 8 หลักการทำงานของคอมพิวเตอร์
บทที่ 9 ซอฟต์แวร์ประยุกต์

หน่วยที่ 4 เทคโนโลยีการสื่อสาร
บทที่ 10 เทคโนโลยีการสื่อสาร
บทที่ 11 การใช้เทคโนโลยีสารสนเทศอย่างมีความรับผิดชอบ

หุ่นยนต์ควบคุมผ่านอินเตอร์เน็ต ESP32 DevKitC V4

จาก โปรเจค หุ่นยนต์ควบคุมด้วยเว็บบราวเซอร์ นั้น เราจะสามารถสั่งควบคุมหุ่นยนต์  จาก เว็บบราวเซอร์ ผ่านทาง ระบบอินทราเน็ต ที่ใช้ WiFi  หรือ วง แลน หรือใช้ เร้าเตอร์ เดียวกัน เท่านั้น

แต่ถ้าจะให้ หุ่นยนต์ สามารถ ควบคุมผ่านอินเตอร์เน็ต ได้ ต้องใช้ แอพ Blynk ในการควบคุม โดยแอพ จะติดต่อ ไอพี ของ เว็บเซิร์ฟเวอร์ ESP32 ได้โดยอัตโนมัติ และ แอพ ยังสามารถควบคุมได้ผ่านอินเตอร์เน็ต  เพียงเราเชื่อมต่อ หุ่นยนต์ ESP32 ของเรา เข้ากับ WiFi ส่วนมือถือ แอพ Blynk ที่ใช้ควบคุม จะใช้ WiFi หรือ อินเตอร์เน็ตของมือถือ ก็สามารถใช้ควบคุมได้เช่นกัน

Blynk Application เป็นโปรแกรมบนมือถือที่ทำให้เราสร้างหน้าต่างควบคุมหรือแสดงผลเชื่อมต่อกับพวกไมโครคอนโทรเลอร์(Ardunio, ESP32 , Raspberry Pi) ได้ง่ายๆ และยังสามารถควบคุมผ่าน ทุกที่ ที่สามารถเชื่อมต่ออินเตอร์เน็ต  ได้อีกด้วย

โหมด STA

STA ย่อมาจาก Station เป็นโหมดที่จะใช้ DevKitC ESP32 ไปเชื่อมต่อกับอุปกรณ์ปล่อยสัญญาณอื่น ๆ เช่น เร้าเตอร์ โทรศัพท์มือถือที่เปิดฮอตสปอต การใช้งานในโหมดนี้นิยมใช้กับงานที่ต้องการเชื่อมต่ออินเตอร์เน็ต

ในงานด้าน IoT Smart Home และ Smart Farm มักใช้งานในโหมดนี้เพื่อส่งข้อมูลจากเซ็นเซอร์ขึ้นไปบนระบบคลาวด์และใช้โหมดนี้เพื่อเชื่อมต่อกับระบบคลาวด์รับคำสั่งมีสั่งอุปกรณ์ต่าง ๆ ให้ทำงานผ่านอินเตอร์เน็ต


หุ่นยนต์ควบคุมผ่านอินเตอร์เน็ต

หากต้องการใช้งานอินเตอร์เน็ต หรือต้องการให้อุปกรณ์หลาย ๆ ตัวสามารถเข้ามาสื่อสารได้ จำเป็นต้องใช้งานในโหมด STA เพื่อให้ Access Point เป็นอุปกรณ์ตัวกลางในการสื่อสาร



โดยในโปรเจคนี้เราจะสร้างเว็บเซิร์ฟเวอร์ จาก DevKitC ESP32 และ และ สั่งควบคุมหุ่นยนต์ จากมือถือที่ติดตั้ง แอพ Blynk ผ่านทาง ระบบอินเตอร์เน็ต (ทุกที่ ที่สามารถเชื่อมต่อกับ ระบบอินเตอร์เน็ตได้)


### อุปกรณ์ที่ใช้ ###


1. 4WD Smart Robot Car Chassis Kits

2. DevKitC V4 ESP32 Development Board ESP-WROOM-32D

3. Micro USB Cable Wire 1m

4. Breadboard 8.5CM x 5.5CM 400 holes  //  จำนวน 2 ชิ้น

5. Motor Driver Module L298N

6. สกรูหัวกลม+น็อตตัวเมีย ขนาด 3มม ยาว 12มม

7. Jumper 20cm Male to Male

8. Jumper 20cm Female to Male

9. เพาเวอร์สวิตซ์สำหรับเปิดปิด

10. รางถ่าน 18650 แบบ 2 ก้อน

11. ถ่านชาร์จ 18650 Panasonic NCR18650B 3.7v 3400mAh  // จำนวน 2 ก้อน




โดยการทำโปรเจคมีขั้นตอนดังนี้


1.ติดตั้ง Arduino core for ESP32

ลิงค์การติดตั้ง Arduino core for ESP32

https://robotsiam.blogspot.com/2017/09/arduino-core-for-esp32.html


2.ประกอบหุ่นยนต์ DevKitC ESP32



ลิงค์การประกอบหุ่นยนต์ DevKitC ESP32


http://esp32robot.blogspot.com/2019/09/devkitc-esp32-v4-car.html



3.ทดสอบการเคลื่อนที่ของหุ่นยนต์ 



ลิงค์ทดสอบการเคลื่อนที่ของหุ่นยนต์


http://esp32robot.blogspot.com/2019/09/devkitc-esp32-v4-test.html



4. สร้างแอพ Blynk สำหรับควบคุมหุ่นยนต์ ESP32

ลิงค์การสร้างแอพ Blynk สำหรับควบคุมหุ่นยนต์  ESP32 ผ่าน WiFi 

https://robotsiam.blogspot.com/2017/10/blynk-ttgo-esp32.html5. การติดตั้ง ไลบรารี่ Blynk   ดาวน์โหลด ไลบรารี่ Blynk     https://github.com/blynkkk/blynk-library
 

 คลิกที่ Clone or download

   คลิกที่ Download ZIP

เปิด โปรแกรม Arduino IDE     

  ไปที่ Skecth -> Include Library -> Add .ZIP Library…

 ไปที่ ไลบรารี blynk-library-master.zip ที่เรา ดาวน์โหลด มา -> Open

ตรวจสอบที่ Skecth -> Include Library  จะพบ ไลบรารี Blynk เพิ่มเข้ามาใน Arduino IDE ของเรา

  แสดงว่า ไลบรารี่ Blynk ได้เพิ่มเข้าไป ที่ โปรแกรม Arduino IDE แล้ว

 6.เขียนโค้ดควบคุมหุ่นยนต์ 


เชื่อมต่อสาย Micro USB ระหว่าง คอมพิวเตอร์ กับ DevKitC ESP32

เปิด โปรแกรม Arduino IDE ขึ้นมา เขียนโปรแกรม หรือ  Sketch  ตามโค้ดด้านล่างนี้

ก่อน Upload โปรแกรม มีค่าเฉพาะที่ต้องแก้ไข อยู่ 3 ค่าด้วยกันคือ

6.1.  char auth[] = “blynk_key“; เป็นค่าที่เราได้รับจาก  ที่ Blynk ส่ง อีเมล ให้เรา ในขั้นตอน สร้างแอพ Blynk สำหรับควบคุมหุ่นยนต์ ESP32  

ในตัวอย่างนี้แก้เป็น char auth[] = “bf9431e24b89442ead921bb8ca5de49c”;

6.2. char ssid[] = “wifi_SSID“; แก้เป็น ชื่อ WiFi ที่ต้องการเชื่อมต่อ  
6.3. char pass[] = “wifi_password“;
แก้เป็น รหัสผ่าน ของWiFiที่ต้องการเชื่อมต่อ

แล้วจึง Upload โค้ดที่แก้ไขแล้ว ไปยัง บอร์ด DevKitC ESP32

/*

   Blynk app controlled Robot with DevKitC ESP32.
    For more details visit:
    https://esp32robot.blogspot.com/2019/09/devkitc-esp32-v4-blynk.html

*/

#define BLYNK_PRINT Serial    // Comment this out to disable prints and save space
#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>

//pins to drive motors
int MotorLeft[2] = {12, 13};
int MotorRight[2] = {33, 32};

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = “blynk_key“;

// Your WiFi credentials.
// Set password to “” for open networks.
char ssid[] = “wifi_SSID“;
char pass[] = “wifi_password“;


void setup()
{
  Serial.begin(115200);
  Blynk.begin(auth, ssid, pass);
  MotorInit();
  //Serial.print(“*Explore Robo Mode Computer: Controlled*\n\r”);
  //Serial.println(“Commands:\n W->Forward \n S->Backwards \n A->Left \n D->Right”);
}

void loop()
{

  Blynk.run();

}

//Intialize the motor
void MotorInit()
{
  int i;
  for (i = 0 ; i < 2; i++)
  {
    pinMode(MotorLeft[i], OUTPUT);
    pinMode(MotorRight[i], OUTPUT);
  }
}
//Robot Driving Functions
void Robot_Forward()
{
  digitalWrite(MotorLeft[0], 0);
  digitalWrite(MotorLeft[1], 1);
  digitalWrite(MotorRight[0], 1);
  digitalWrite(MotorRight[1], 0);
}
void Robot_Backward()
{
  digitalWrite(MotorLeft[0], 1);
  digitalWrite(MotorLeft[1], 0);
  digitalWrite(MotorRight[0], 0);
  digitalWrite(MotorRight[1], 1);
}
void Robot_Left()
{
  digitalWrite(MotorLeft[0], 0);
  digitalWrite(MotorLeft[1], 0);
  digitalWrite(MotorRight[0], 1);
  digitalWrite(MotorRight[1], 0);
}
void Robot_Right()
{
  digitalWrite(MotorLeft[0], 0);
  digitalWrite(MotorLeft[1], 1);
  digitalWrite(MotorRight[0], 0);
  digitalWrite(MotorRight[1], 0);
}
void Robot_Stop()
{
  digitalWrite(MotorLeft[0], 0);
  digitalWrite(MotorLeft[1], 0);
  digitalWrite(MotorRight[0], 0);
  digitalWrite(MotorRight[1], 0);
}



BLYNK_WRITE(V1)
{
  int value = param.asInt(); // Get value as integer
  // Serial.println(“Going Forward”);
  if (value)
  {
    Robot_Forward();

  }
}

BLYNK_WRITE(V2)
{
  int value = param.asInt(); // Get value as integer
  //Serial.println(“Moving Left”);
  if (value)
  {

    Robot_Left();
    delay(200);
    Robot_Stop();
  }
}


BLYNK_WRITE(V3)
{
  int value = param.asInt(); // Get value as integer
  // Serial.println(“Going back”);
  if (value)
  {
    Robot_Backward();

  }
}


BLYNK_WRITE(V4)
{
  int value = param.asInt(); // Get value as integer
  //Serial.println(“Moving Right”);
  if (value)
  {
    Robot_Right();
    delay(200);
    Robot_Stop();

  }
}

BLYNK_WRITE(V5)
{
  int value = param.asInt(); // Get value as integer
  // Serial.println(“Braking!!”);
  if (value)
  {
    Robot_Stop();
  }
}

โค้ดที่แก้ไขแล้ว

ไปที่ Tools -> Board เลือก “ESP32 Dev Module”

ไปที่ Tools -> Port แล้วเลือกพอร์ตที่ปรากฏ (กรณีใช้เครื่องคอมพิวเตอร์ที่มี COM Port ให้เลือกตัวอื่นที่ไม่ใช่ COM1)

ในตัวอย่างเลือกเป็น “COM12”

ไปที่ Tools -> Upload Speed : เลือกเป็น “115200”

กดปุ่ม  

 เพื่ออัพโหลด

หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า Done uploading. ที่แถบด้านล่าง


7.ทดสอบการทำงาน 

ใสถ่าน แบบ 18650 แรงดันไฟเฉลี่ย 3.7V  (3400 mAh)  จำนวน 2 ก้อน

เปิดแอพ ควบคุมหุ่นยนต์ Blynk  -> ESP32_Robot (ที่สร้างไว้ ในขั้นตอนที่ 4)

เลือกเครื่องหมายสามเหลี่ยม ขวามือ

ทดสอบควบคุม หุ่นยนต์ DevKitC ESP32

แล้ว… ทดสอบการทำงาน
วีดีโอผลลัพธ์ หุ่นยนต์ควบคุมผ่านอินเตอร์เน็ต DevKitC ESP32

หุ่นยนต์หลบหลีกสิ่งกีดขวาง ESP32 V4 ส่งค่าผ่าน Bluetooth

4 เดือนที่ผ่านมา โดย เจ้าของร้าน


เซ็นเซอร์วัดระยะทาง


สำหรับเซ็นเซอร์วัดระยะทาง สามารถนำไปใช้ในการวัดขนาดสิ่งของ ตรวจจับสิ่งกีดขวางได้ โดยในด้าน Smart Farm มักนำไปใช้วัดระดับน้ำในถังน้ำ หรือนำไปใช้วัดระดับน้ำในบ่อน้ำ เพื่อให้แจ้งเตือน หรือเติมนำอัตโนมัติ สำหรับเซ็นเซอร์วัดระยะห่างจะมีทั้งแบบใช้แสง และใช้คลื่นเสียง

BLE

BLE ย่อมาจาก Bluetooth Low Energy หรืออาจแปลเป็นไทยได้ว่า บลูทูธพลังงานต่ำ ตามหลักแล้วอุปกรณ์ BLE จะใช้พลังงานน้อยมาก ๆ บางอุปกรณ์เครมว่าสามารถอยู่ได้ต่อเนื่องนาน 1 ปี โดยใช้พลังงานจากถ่านกระดุมเพียงก้อนเดียว

หุ่นยนต์หลบหลีกสิ่งกีดขวาง ส่งค่าผ่าน Bluetooth 

โดยในโปรเจคนี้เราจะสร้างหุ่นยนต์หลบหลีกสิ่งกีดขวาง ส่งค่าผ่าน Bluetooth โดยให้หุ่นยนต์ตัดสินใจโดยอัตโนมัติ ด้วยการวัดระยะทาง จาก สิ่งกีดขวาง และ เมื่อมีสิ่งกีดขวางอยู่ในระยะที่กำหนดไว้ ในตัวอย่างคือ น้อยกว่า 20 เซ็นติเมตร ให้หุ่นยนต์ ถอยหลัง แล้ว เลี้ยวซ้าย หลบสิ่งกีดขวางนั้นเสมอ โดยในขณะที่ทำงานจะให้ส่งค่าระยะทางที่วัดได้ ส่งค่าผ่านทาง Bluetooth มายัง สมาร์ทโฟน ของเราด้วย


### อุปกรณ์ที่ใช้ ###


1 . 4WD Smart Robot Car Chassis Kits

2. DevKitC V4 ESP32 Development Board ESP-WROOM-32D

3. Micro USB Cable Wire 1m

4. Breadboard 8.5CM x 5.5CM 400 holes  //  จำนวน 2 ชิ้น

5. Motor Driver Module L298N

6. สกรูหัวกลม+น็อตตัวเมีย ขนาด 3มม ยาว 12มม

7. Jumper 20cm Male to Male

8. Jumper 20cm Female to Male

9. เพาเวอร์สวิตซ์สำหรับเปิดปิด

10. รางถ่าน 18650 แบบ 2 ก้อน

11. ถ่านชาร์จ 18650 Panasonic NCR18650B 3.7v 3400mAh  // จำนวน 2 ก้อน

12. HY-SRF05 SRF05 Ultrasonic Distance Sensor Module

13. Mounting Bracket for HC-SR04 แบบสั้น




โดยการทำโปรเจคมีขั้นตอนดังนี้


1.ติดตั้ง Arduino core for ESP32

ลิงค์การติดตั้ง Arduino core for ESP32

https://robotsiam.blogspot.com/2017/09/arduino-core-for-esp32.html


2.ประกอบหุ่นยนต์ DevKitC ESP32



ลิงค์การประกอบหุ่นยนต์ DevKitC ESP32


http://esp32robot.blogspot.com/2019/09/devkitc-esp32-v4-car.html



3.ทดสอบการเคลื่อนที่ของหุ่นยนต์ 



ลิงค์ทดสอบการเคลื่อนที่ของหุ่นยนต์


http://esp32robot.blogspot.com/2019/09/devkitc-esp32-v4-test.html


4.ประกอบเซ็นเซอร์วัดระยะทาง HY-SRF05 

HY-SRF05 SRF05 Ultrasonic Distance Sensor Module โมดูลวัดระยะด้วยคลื่นอัลตร้าโซนิค ใช้การสื่อสารกับไมโครคอนโทรลเลอร์ผ่านการทริกสัญญาณ สามารถวัดระยะห่างได้ตั้งแต่ 2 เซ็นติเมตร ไปจนถึง 4 เมตร ใช้แรงดันไฟฟ้า 5V การวัดระยะทางโดยใช้ โมดูล Ultrasonic มีความแม่นยำในการวัดระยะทาง การทำงานเป็นแบบคลื่นสะท้อนกลับแล้วนำมาคำนวน จึงเหมาะสำหรับมาใช้ในการหลบหลีกสิ่งกีดขวาง ตรวจจับวัตถุที่อยู่ในรัศมีที่ต้องการ

ประกอบ SRF05 เข้ากับ  Mounting Bracket แล้วยึดเข้ากับหุ่นยนต์ดังรูป

เชื่อมต่อ SRF05 เข้ากับ ESP32


Trig <-> 15 (ESP32) 
Echo <-> 2 (ESP32) 
Vcc <->  5V (Motor Driver)
GND <-> GND (ไฟ- ของ Breadboard)

เชื่อมต่อสายจาก SRF05

เข้ากับ ESP32

Trig <-> 15
Echo <-> 2

  Vcc ของ SRF05 จะใช้ไฟ 5 โวลต์ ดังนั้น ต้องเชื่อมต่อ Vcc ไปที่ ไฟ 5 โวลต์ ที่ออกมาจาก Motor Driver (ใช้สาย ผู้-เมีย 2 เส้น เชื่อมต่อกัน)
Vcc <->  5V (สายสีแดงเส้นที่ 3 จากซ้ายมือ)

GND <-> GND (ไฟ- ของ Breadboard)

ภาพรวมการต่อ หุ่นยนต์หลบหลีกสิ่งกีดขวาง

เชื่อมต่อสาย Micro USB ระหว่าง คอมพิวเตอร์ กับ DevKitC ESP32

เปิด โปรแกรม Arduino IDE ขึ้นมา เขียนโปรแกรม หรือ  Sketch  ตามโค้ดด้านล่างนี้


const unsigned int TRIG_PIN=15;
const unsigned int ECHO_PIN=2;   const unsigned int BAUD_RATE=115200;     void setup() {     pinMode(TRIG_PIN, OUTPUT);     pinMode(ECHO_PIN, INPUT);     Serial.begin(BAUD_RATE);   }     void loop() {     digitalWrite(TRIG_PIN, LOW);     delayMicroseconds(2);     digitalWrite(TRIG_PIN, HIGH);     delayMicroseconds(10);     digitalWrite(TRIG_PIN, LOW);           const unsigned long duration= pulseIn(ECHO_PIN, HIGH);    int distance= duration/29/2;    if(duration==0){      Serial.println(“Warning: no pulse from sensor”);      }      else{         Serial.print(“distance to nearest object:”);         Serial.println(distance);         Serial.println(” cm”);     }    delay(100);    }

ไปที่ Tools -> Board เลือก “ESP32 Dev Module”

ไปที่ Tools -> Port แล้วเลือกพอร์ตที่ปรากฏ (กรณีใช้เครื่องคอมพิวเตอร์ที่มี COM Port ให้เลือกตัวอื่นที่ไม่ใช่ COM1)

ในตัวอย่างเลือกเป็น “COM12”

ไปที่ Tools -> Upload Speed : เลือกเป็น “115200”

กดปุ่ม  

 เพื่ออัพโหลด

หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า Done uploading. ที่แถบด้านล่าง

ปิดสวิตช์ไฟ จากรางถ่านเข้าสู่หุ่นยนต์

แล้วไปที่ Tools -> Serial Monitor

เลือก Both NL & CR และ เลือก 115200 baud

Serial Monitor จะแสดง ระยะทางที่ห่าง จาก สิ่งกีดขวาง มีหน่วยเป็น cm (เซนติเมตร)

แสดงว่า การเชื่อมต่อ SRF05 ของเรานั้นถูกต้อง และ พร้อมใช้งานแล้ว

ทดลอง ส่งค่า ระยะทางที่ห่าง จาก สิ่งกีดขวาง ผ่านทาง Bluetooth ไปยัง สมาร์ทโฟน

โดยอัพโหลด โค้ดด้านล่างนี้ ไปยัง ESP32

#include “SimpleBLE.h”

const unsigned int TRIG_PIN = 15;

const unsigned int ECHO_PIN = 2;

//long x;
int x ;
SimpleBLE ble;
String BLEname = “ESP000”;

void setup() {

  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(115200);
  Serial.setDebugOutput(true);

}
void loop() {

  digitalWrite(TRIG_PIN, LOW);

  delayMicroseconds(2);

  digitalWrite(TRIG_PIN, HIGH);

  delayMicroseconds(10);

  digitalWrite(TRIG_PIN, LOW);

  const unsigned long duration = pulseIn(ECHO_PIN, HIGH);

  int distance = duration / 29 / 2;


  x = (distance);

  Serial.println(x);
  if (x > 100) {
    BLEname = “ESP” + String(x);
  } else {
    if (x > 10) {
      BLEname = “ESP0” + String(x);
    } else {
      BLEname = “ESP00” + String(x);
    }
  }

  Serial.println(BLEname);
  ble.begin(BLEname);
  delay(100);

}



เปิดการเชื่อมต่อ บลูทูธ จะพบ อุปกรณ์ที่พร้อมใช้งาน ในตัวอย่าง เช่น ESP093 รอจนเชื่อมต่อเสร็จ

ดาวน์โหลดแอป Sparks ESP Companion.apk

ไปที่

https://github.com/LiveSparks/ESP32-basic-BLE/tree/master/app

แล้วติดตั้ง ลงใน สมาร์ทโฟน แอนดรอย ของเรา ตามขั้นตอนปรกติ ทั่วไป

เมื่อติดตั้งเสร็จให้เปิดแอปขึ้นมา

คลิกที่ Start Scanning

แอปจะแสดง ค่า ระยะทางที่ห่าง จาก สิ่งกีดขวาง เปลี่ยนค่าไปตามระยะทาง มีหน่วยเป็น cm (เซนติเมตร) แสดงว่า แอป Sparks ESP นั้นพร้อมใช้งานแล้ว


5.เขียนโค้ด
หุ่นยนต์หลบหลีกสิ่งกีดขวาง ส่งค่าผ่าน Bluetooth


อัพโหลด โค้ดด้านล่างนี้ ไปยัง ESP32




/*

    Obstacle Robot with DevKitC ESP32.
    For more details visit:
    https://esp32robot.blogspot.com/2019/09/bluetooth-esp32-v4.html

*/

#include “SimpleBLE.h”

const unsigned int TRIG_PIN = 15;

const unsigned int ECHO_PIN = 2;

// Motor A pins

int pinA2 = 12;
int pinA1 = 13;


//Motor B pins

int pinB2 = 32;
int pinB1 = 33;

//long x;
int x ;
SimpleBLE ble;
String BLEname = “ESP000”;

void setup() {

  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  Serial.begin(115200);
  Serial.setDebugOutput(true);

  pinMode(pinA1, OUTPUT);
  pinMode(pinA2, OUTPUT);
  pinMode(pinB1, OUTPUT);
  pinMode(pinB2, OUTPUT);
}
void loop() {

  digitalWrite(TRIG_PIN, LOW);

  delayMicroseconds(2);

  digitalWrite(TRIG_PIN, HIGH);

  delayMicroseconds(10);

  digitalWrite(TRIG_PIN, LOW);

  const unsigned long duration = pulseIn(ECHO_PIN, HIGH);

  int distance = duration / 29 / 2;


  x = (distance);

  Serial.println(x);
  if (x > 100) {
    BLEname = “ESP” + String(x);
  } else {
    if (x > 10) {
      BLEname = “ESP0” + String(x);
    } else {
      BLEname = “ESP00” + String(x);
    }
  }

  Serial.println(BLEname);
  ble.begin(BLEname);

  if (distance < 20) {

    backward(400);
    coast(200);
    turnLeft(1000);

  }
  else {

    forward(1);

  }

  delay(100);

}

//ฟังก์ชั่นหลักในการควบคุมมอเตอร์



void forward(int time)
{
  motorAForward();
  motorBForward();
  delay(time);
}

void backward(int time)
{
  motorABackward();
  motorBBackward();
  delay(time);
}


void turnLeft(int time) {   digitalWrite(pinA1, LOW);   digitalWrite(pinA2, LOW);   digitalWrite(pinB1, HIGH);   digitalWrite(pinB2, LOW);   delay(time); }   void turnRight(int time) {   digitalWrite(pinA1, HIGH);   digitalWrite(pinA2, LOW);   digitalWrite(pinB1, LOW);   digitalWrite(pinB2, LOW);   delay(time); }  
void coast(int time)
{
  motorACoast();
  motorBCoast();
  delay(time);
}

void brake(int time)
{
  motorABrake();
  motorBBrake();
  delay(time);
}


//ฟังก์ชั่นรองในการควบคุมมอเตอร์


//motor A controls
void motorAForward()
{
  digitalWrite(pinA1, HIGH);
  digitalWrite(pinA2, LOW);
}

void motorABackward()
{
  digitalWrite(pinA1, LOW);
  digitalWrite(pinA2, HIGH);
}

//motor B controls
void motorBForward()
{
  digitalWrite(pinB1, HIGH);
  digitalWrite(pinB2, LOW);
}

void motorBBackward()
{
  digitalWrite(pinB1, LOW);
  digitalWrite(pinB2, HIGH);
}

//coasting and braking
void motorACoast()
{
  digitalWrite(pinA1, LOW);
  digitalWrite(pinA2, LOW);
}

void motorABrake()
{
  digitalWrite(pinA1, HIGH);
  digitalWrite(pinA2, HIGH);
}

void motorBCoast()
{
  digitalWrite(pinB1, LOW);
  digitalWrite(pinB2, LOW);
}

void motorBBrake()
{
  digitalWrite(pinB1, HIGH);
  digitalWrite(pinB2, HIGH);
}



วีดีโอผลลัพธ์ หุ่นยนต์หลบหลีกสิ่งกีดขวาง ส่งค่าผ่าน Bluetooth

โปรเจค IoT ESP32 วัดความชื้นในดิน แจ้งเตือนผ่าน LINE Notify

ESP32 วัดความชื้นในดิน แจ้งเตือนด้วย LINE Notify

โดยโปรเจคนี้ สามารถนำประยุกต์ไปใช้ ในสมาร์ทฟาร์มได้ โดยหลักการทำงาน คือ เมื่อเซ็นเซอร์วัดความชื้นในดิน ตรวจสอบค่าข้อมูลความชื้นในดินของพืชที่ปลูกไว้ ถ้ามีค่าเท่ากับหรือมากกว่าค่าที่ตั้งไว้ในตัวอย่าง คือ 700 ให้ ESP32 ยังไม่ต้องส่งค่าแจ้งเตือน แต่ถ้ามีค่าน้อยกว่า 700 แสดงว่าพืชต้องการน้ำแล้ว  ให้ ESP32 ส่งข้อมูลแจ้งเตือน ไปยัง Line Notify เจ้าของพืชนั้น ไม่ว่าจะโดยการใช้คอมพิวเตอร์ แท็บเล็ต หรือ สมาร์ทโฟน ที่ติดตั้ง แอพพลิเคชั่น LINE ไว้ และเจ้าของพืชจึงเข้าไปดูแลรดน้ำให้พืชนั้นต่อไป หรือ พัฒนาต่อ โดยให้ไปสั่งงาน โซลินอยด์วาล์ว เปิดน้ำเพื่อรดน้ำให้กับพืชโดยอัตโนมัติก็ได้เช่นกัน

LINE Notify คืออะไร ?

LINE เป็นแอพพลิเคชั่นแชทยอดนิยมในประเทศไทย ปัจจุบันเราได้เห็นการใช้งาน LINE ในรูปแบบต่าง ๆ มากขึ้น ทั้งการขายสินค้า การชำระเงิน การพูดคุยกันในหน่วยงาน ในโปรเจคนี้จึงมุ่งเป้าหมายไปที่การใช้แอพพลิเคชั่น LINE เป็นส่วนหนึ่งของระบบ IoT โดยใช้ ESP32 เป็นแกนหลัก

ส่วนของ API หรือส่วนสำหรับนักพัฒนาได้มีการเปิดส่วนของ LINE Notify ขึ้นมาให้ใช้งานเพื่อให้นักพัฒนาได้ส่งการแจ้งเตือน ข้อความต่าง ๆ ผ่าน LINE ได้ง่ายขึ้น

สำหรับตัว LINE Notify นั้น ออกแบบมาเพื่อใช้สำหรับการแจ้งเตือนต่าง ๆ โดยเฉพาะ สามารถส่งข้อความเพื่อแจ้งเตือนไปยังกลุ่ม หรือบุคคลก็ได้ ทั้งนี้ LINE Notify จะมีข้อจำกัดการใช้งานอยู่ที่ จะสามารถใช้งานได้กับบุคคลเดียวเท่านั้น หรือกลุ่มเดียวเท่านั้น การติดต่อกับ LINE จะใช้โปรโตคอล HTTPS ในการติดต่อ และใช้สิ่งที่เรียกว่า Token เป็นรหัสผ่านเข้าไปขอส่งข้อความเข้า LINE

สรุปคือ LINE Notify คือหนึ่งในบริการดีๆ ที่ฟรีไม่เสียตังค์ของ LINE เพื่อส่งการแจ้งเตือน ส่งข้อความไปยัง LINE Notify ถ้าอธิบายง่ายๆ ก็คือ LINE Notify ก็คือเพื่อนของท่านคนหนึ่ง ก่อนที่จะสื่อสารกับเขาได้ต้องเพิ่มเพื่อนก่อน เพื่อนคนนี้จะส่งข้อความมาหาเราเหมือนคนอื่นปกติ จะลากเข้ากลุ่มก็ได้ แต่พิเศษตรงที่ว่า ข้อความที่เพื่อนคนนี้ส่งมา ก็คือการแจ้งเตือนที่เราส่งไปให้นั่นเอง

### อุปกรณ์ที่ใช้ ###


1.  TTGO ESP32 WiFi Bluetooth 18650 Battery Holder Seat

2. Micro USB Cable Wire 1m for NodeMCU

3. Keyestudio Soil Humidity Sensor (เซ็นเซอร์วัดความชื้นในดิน)

4. Jumper (F2F) cable wire 30cm Female to Female

5. ถ่านชาร์จ 18650 Panasonic NCR18650B 3.7v 3400mAh



โดยการทำโปรเจคมีขั้นตอนดังนี้


1. สมัครขอใช้บริการ LINE Notify

(ในตัวอย่างใช้คอมพิวเตอร์ PC เพื่อความสดวกในการทำงาน)


1.1 ลงทะเบียนขอรหัส token ที่ https://notify-bot.line.me/my/


1.2 เข้าสู่ระบบด้วยบัญชีของ LINE ให้เรียบร้อย

1.2 คลิกที่ Generate token

1.3  ให้ตั้งชื่อให้ token ที่ต้องการ ในตัวอย่างตั้งชื่อว่า ESP32 จากนั้นให้เลือก LINE Notify ของเราเอง แล้วคลิกที่ปุ่ม Generate token

1.4 ระบบจะสร้าง token มาให้


1.5 ให้คัดลอกเก็บไว้ เพราะถ้าลืมจะไม่สามารถดูได้อีก ต้องลบและขอใหม่เท่านั้น

1.6  คลิก Close ปิดหน้าต่างลงไป

1.7 เสร็จขั้นตอนการขอ token แล้ว (เราจะใช้ token นี้ ในขั้นตอนการเขียนโค้ดต่อไป)

1.8 ใช้สมาร์ทโฟน ไปที่ LINE Notify จะมีข้อความแสดงว่าได้ออก Token เรียบร้อยแล้ว ถึงขั้นตอนนี้เราก็เริ่มใช้บริการ LINE Notify ได้แล้ว

2.ติดตั้ง แพลตฟอร์ม ESP32 สำหรับ Arduino IDE


ลิงค์การติดตั้ง แพลตฟอร์ม ESP32



https://robotsiam.blogspot.com/2017/09/arduino-core-for-esp32.html




3.ทดสอบการทํางาน เซ็นเซอร์วัดความชื้น



3.1 เชื่อมต่อ  ESP32  กับ เซ็นเซอร์วัดความชื้นในดิน


4. อัพโหลดโปรแกรม


4.1 เชื่อมต่อสาย USB ระหว่าง คอมพิวเตอร์ กับ ESP32

4.2 ตรวจสอบการติดตั้งไดร์เวอร์ ของ ชิปแปลง USB to UART เบอร์ CP2102 โดย คลิกขวา Computet -> Properties -> Device Manager

ที่ Ports (COM & LPT) จะพบ ไดร์เวอร์ ของชิป CP2102

ในตัวอย่างเป็น Silicon Labs CP210x USB to UART Bridge (COM21)


4.3 เปิดโปรแกรม Arduino (IDE) และ ก็อปปี้ โค้ดด้านล่างนี้ ไปวางไว้ในส่วนเขียนโปรแกรม



void setup(){

Serial.begin(115200);

pinMode(34, INPUT);

}

void loop(){

Serial.print("Moisture Sensor Value:");

Serial.println(analogRead(34));

delay(100);
}


4.5 ไปที่ Tools -> Board เลือก ESP32 Dev Module

4.6 ไปที่ Tools -> Port แล้วเลือกพอร์ตที่ปรากฏ (กรณีใช้เครื่องคอมพิวเตอร์ที่มี COM Port ให้เลือกตัวอื่นที่ไม่ใช่ COM1)

ในตัวอย่างเลือกเป็น “COM21”

4.7 กดปุ่ม  

 เพื่ออัพโหลด

4.8 หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า Done uploading. ที่แถบด้านล่าง

4.9 เปิดหน้าต่าง Serial Monitor  โดยไปที่ Tools > Serial Monitor

4.10 มุมขวาล่าง ของ Serial Monitor เลือก 115200 baud  คือ ตั้งค่าความเร็วในการรับ-ส่งข้อมูล  คือ 115200

4.11 ทดสอบนำ เซ็นเซอร์ ไปวัดความชื้นในดิน หรือ แก้วที่มีน้ำ

4.12 จะแสดงค่าที่เพิ่มมากขึ้น ตัวอย่างเช่น จาก 0 เพิ่มขึ้นเป็น 1855 แสดงว่าเซ็นเซอร์ของเราพร้อมทำงานแล้ว

5. อัพโหลดโค้ด แจ้งเตือนผ่าน LINE Notify


5.1 เปิดโปรแกรม Arduino (IDE) และ ก็อปปี้ โค้ดด้านล่างนี้ ไปวางไว้ในส่วนเขียนโปรแกรม

#include <WiFi.h>
#include <WiFiClientSecure.h>

//########## CONFIGURATION : MODIFY HERE ##########
char ssid[] = "YourNetworkName"; // เครือข่าย Wi-Fi ที่ต้องการเชื่อมต่อ
char pass[] = "YourPassword"; // รหัสผ่านเครือข่าย

//รหัสเชื่อมต่อ Line token
#define TokenLine "token"

// ข้อความ ที่จะแสดงใน Line
String txt1 = "ความชื้นเท่ากับ "; //ข้อความ 1 ที่จะแสดงใน Line
String txt2 = " รดน้ำได้แล้ว !"; //ข้อความ 2 ที่จะแสดงใน Line

//กำหนดขาที่เชื่อมต่อกับเซ็นเซอร์
int sensorPin = 34;


void setup() {

//กำหนดให้ขาดิจิตอล sensorPin รับข้อมูลจากเซ็นเซอร์
pinMode(sensorPin, INPUT);

//ตั้งค่าคอนโซล
Serial.begin(115200);

//เริ่มการเชื่อมต่อกับวายฟายแม่ข่าย
WiFi.begin(ssid, pass);

//แสดง "WiFi Connecting" ในคอนโซล
Serial.print("WiFi Connecting");

//ตรวจเช็คสถานะการเขื่อมต่อวายฟาย
//ถ้าไม่สำเร็จให้แสดง "." ในคอนโซลจนกว่าจะเขื่อมต่อได้
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
//แสดงสถานะการวายฟายเชื่อมต่อแล้ว
Serial.println();
Serial.print("connected: ");
Serial.println(WiFi.localIP());
}

void loop() {

int Humidity = analogRead(sensorPin);

if (Humidity < 700) {
Serial.print("Moisture Sensor Value:");
Serial.println(Humidity);
NotifyLine(txt1 + Humidity + txt2);
}
else if (Humidity >= 700) {
Serial.print("Moisture Sensor Value:");
Serial.println(Humidity);
}


delay(2000);

}

void NotifyLine(String t) {
WiFiClientSecure client;
if (!client.connect("notify-api.line.me", 443)) {
Serial.println("Connection failed");

return;
}
String req = "";
req += "POST /api/notify HTTP/1.1\r\n";
req += "Host: notify-api.line.me\r\n";
req += "Authorization: Bearer " + String(TokenLine) + "\r\n";
req += "Cache-Control: no-cache\r\n";
req += "User-Agent: ESP32\r\n";
req += "Content-Type: application/x-www-form-urlencoded\r\n";
req += "Content-Length: " + String(String("message=" + t).length()) + "\r\n";
req += "\r\n";
req += "message=" + t;
Serial.println(req);
client.print(req);
delay(20);
Serial.println("-------------");
while (client.connected()) {
String line = client.readStringUntil('\n');
if (line == "\r") {
break;
}
} //while
} //loop


5.2 ก่อนการอัพโหลดต้องแก้ไขโค้ด ตรงตัวอักษรสีแดงให้ถูกต้องตาม เครือข่าย WiFi ที่เลือกใช้งาน โดย


char ssid[] = “YourNetworkName“;  // เครือข่าย Wi-Fi ที่ต้องการเชื่อมต่อ

char pass[] = “YourPassword“; // รหัสผ่านเครือข่าย


และ token จากอีเมล ที่ระบบสร้าง มาให้ ตามหัวข้อ 1.4

#define TokenLine “token” // รหัสเชื่อมต่อ LINE token


ตรวจความถูกต้องแบบละเอียด เช่น…ตัวพิมพ์เล็ก , ตัวพิมพ์ใหญ่ อักขระต่างๆ ให้ถูกต้อง

5.3 หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า Done uploading. ที่แถบด้านล่าง

6. ทดสอบการทํางาน


6.1 ใส่ถ่าน 18650 เข้าไปที่รางถ่าน โดยตรวจสอบขั้ว + และ ขั้ว – ให้ถูกต้อง

*** ระวัง ถ้าใส่ ผิดขั้วจะทำให้อุปกรณ์ชำรุด ***


6.2 นำเซ็นเซอร์วัดความชื้นในดิน ไปตรวจสอบค่าข้อมูลความชื้นในดินของพืชที่ปลูกไว้ 


6.3 ถ้ามีค่าเท่ากับหรือมากกว่าค่าที่ตั้งไว้ในตัวอย่าง คือ 700 ให้ ESP32 ยังไม่ต้องส่งค่าแจ้งเตือน แต่ถ้ามีค่าน้อยกว่า 700 แสดงว่าพืชต้องการน้ำแล้ว  ให้ ESP32 ส่งข้อมูลแจ้งเตือน ไปยัง Line Notify    

credit : https://medium.com/@visitwnk วิสิทธิ์ เวียงนาค

โปรเจค ESP32-CAM กล้องดักถ่ายภาพอัตโนมัติ ด้วย PIR Motion

โปรเจค ESP32-CAM กล้องดักถ่ายภาพอัตโนมัติ ด้วย PIR Motion โดยโปรเจคนี้ สามารถประยุกต์เป็นกล้องดักถ่ายภาพเมื่อมีผู้บุกรุก หรือเป็นกล้องดักถ่ายภาพสัตว์ มีชื่อเรียกหลายชื่อได้แก่ Trail Cam, Scout Cam, Camera Trap โดยผู้ใช้งานโดยซ่อนไว้ใกล้บริเวณทางที่สัตว์เดินผ่าน หรือแหล่งน้ำและดินโป่งที่สัตว์ใช้ประจำเมื่อมีสัตว์เดินผ่านมาบริเวณที่ตัวเซ็นเซอร์จับการเคลื่อนไหวได้กล้องจะถ่ายภาพเองโดยอัตโนมัติ โดยจะเก็บไฟล์รูปภาพไว้ที่ SD Card

หลักการทำงานของโปรเจค โดยเมื่อเริ่มทำงานเราจะให้ ESP32 อยู่โหมดการใช้งานแบบ Deep Sleep เพื่อเป็นการประหยัดพลังงาน แล้ว ปลุกให้ตื่นด้วยเซ็นเซอร์ PIR Motion เมื่อตรวจจับความเคลื่อนไหวได้ แล้วจึงสั่งให้กล้องจะถ่ายภาพ โดยเก็บไฟล์รูปภาพไว้ที่ SD Card จากนั้น ESP32 จะกลับเข้าสู่โหมดการใช้งานแบบ Deep Sleep เพื่อรอ การปลุกให้ตื่น ในครั้งต่อๆไป

### อุปกรณ์ที่ใช้ ###

1. ESP32-CAM ESP32 Development Board with Camera Module

2. CP2102 USB 2.0 to UART TTL 5PIN Connector Module

3. Jumper (M2M) 10cm Male to Male

4. Micro SD Card Class 10 16GB + Card Adapter

5. Keyestudio PIR Motion Sensor Module

6. 2N3904 NPN General Purpose Transistor

7. รีซิสเตอร์ 10K Ohm

8. รีซิสเตอร์ 1K Ohm

9. Jumper (F2M) 20cm Female to Male

การทำงานมีขั้นตอนดังนี้

1. ทดสอบการใช้งาน ESP32-CAM

จากบทความ การใช้งาน ESP32-CAM กล้อง OV2640 เป็น Video Stream ภาพเคลื่อนไหว

http://esp32robot.blogspot.com/2019/07/esp32-cam-ov2640-video-stream.html


2. ฟอร์แมต Micro SD Card


Micro SD Card , Class 10 ความจุ 16GB + Card Adapter




ให้เสียบ Micro SD Card เข้าไปใน Card Adapter


Card Adapter ที่มี Micro SD Card อยู่ด้านใน


แล้วจึงเสียบ Card Adapter ที่บรรจุ Micro SD Card ใส่ในช่องซ็อกเก็ตของคอมพิวเตอร์ PC (ดันจนกระทั่งมีเสียงคลิก)


ไปที่ My Computer แล้วคลิกขวาที่ไดร์ของ Micro SD Card เลือกรูปแบบตามที่แสดงในภาพด้านล่าง    


3. ทดสอบบันทึกรูปภาพลง SD Card

เสียบ Micro SD Card เข้าไปใน Slot Card  

เปิดโปรแกรม Arduino (IDE) และ ก็อปปี้ โค้ดด้านล่างนี้ ไปวางไว้ในส่วนเขียนโปรแกรม

/*********
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp32-cam-take-photo-save-microsd-card

IMPORTANT!!!
- Select Board "ESP32 Wrover Module"
- Select the Partion Scheme "Huge APP (3MB No OTA)
- GPIO 0 must be connected to GND to upload a sketch
- After connecting GPIO 0 to GND, press the ESP32-CAM on-board RESET button to put your board in flashing mode

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*********/

#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "fd_forward.h"
#include "fr_forward.h"
#include "FS.h" // SD Card ESP32
#include "SD_MMC.h" // SD Card ESP32
#include "soc/soc.h" // Disable brownour problems
#include "soc/rtc_cntl_reg.h" // Disable brownour problems
#include "dl_lib.h"
#include "driver/rtc_io.h"
#include <EEPROM.h> // read and write from flash memory

// define the number of bytes you want to access
#define EEPROM_SIZE 1

// Pin definition for CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27

#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22

int pictureNumber = 0;

void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector

Serial.begin(115200);
//Serial.setDebugOutput(true);
//Serial.println();

camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;

if(psramFound()){
config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
config.jpeg_quality = 10;
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}

// Init Camera
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}

//Serial.println("Starting SD Card");
if(!SD_MMC.begin()){
Serial.println("SD Card Mount Failed");
return;
}

uint8_t cardType = SD_MMC.cardType();
if(cardType == CARD_NONE){
Serial.println("No SD Card attached");
return;
}

camera_fb_t * fb = NULL;

// Take Picture with Camera
fb = esp_camera_fb_get();
if(!fb) {
Serial.println("Camera capture failed");
return;
}
// initialize EEPROM with predefined size
EEPROM.begin(EEPROM_SIZE);
pictureNumber = EEPROM.read(0) + 1;

// Path where new picture will be saved in SD Card
String path = "/picture" + String(pictureNumber) +".jpg";

fs::FS &fs = SD_MMC;
Serial.printf("Picture file name: %s\n", path.c_str());

File file = fs.open(path.c_str(), FILE_WRITE);
if(!file){
Serial.println("Failed to open file in writing mode");
}
else {
file.write(fb->buf, fb->len); // payload (image), payload length
Serial.printf("Saved file to path: %s\n", path.c_str());
EEPROM.write(0, pictureNumber);
EEPROM.commit();
}
file.close();
esp_camera_fb_return(fb);

// Turns off the ESP32-CAM white on-board LED (flash) connected to GPIO 4
pinMode(4, OUTPUT);
digitalWrite(4, LOW);
rtc_gpio_hold_en(GPIO_NUM_4);

delay(2000);
Serial.println("Going to sleep now");
delay(2000);
esp_deep_sleep_start();
Serial.println("This will never be printed");
}

void loop() {

}

View raw code*** เมื่อต้องการ อัพโหลดโค้ดทุกครั้งให้เชื่อมต่อสาย ระหว่าง IO0 <-> GND ***

 เชื่อมต่อ CP2102 USB เข้ากับคอมพิวเตอร์

ไปที่ Tools -> Board เลือก ESP32 Wrover Module

ไปที่ Tools -> Partition Scheme แล้วเลือก Huge APP(3MB No OTA)  

ไปที่ Tools -> Port แล้วเลือกพอร์ตที่ปรากฏ (กรณีใช้เครื่องคอมพิวเตอร์ที่มี COM Port ให้เลือกตัวอื่นที่ไม่ใช่ COM1)
ในตัวอย่างเลือกเป็น “COM12”  

  กดปุ่ม  

 เพื่ออัพโหลด

หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า Done uploading. ที่แถบด้านล่าง  

### ถ้ามีปัญหาในการอัพโหลดไม่ได้ ให้กดปุ่ม RST ค้างไว้ในขณะอัพโหลด ###

ถอด Jumper ที่เชื่อมต่อระหว่าง IO0 <-> GND ออก


กดปุ่ม RST 1 ครั้ง  ต่อ 1 รูปภาพ

ESP32-CAM จะถ่ายภาพ โดยจะเก็บไฟล์รูปภาพไว้ที่ SD Card

เมื่อถอด SD Card ไปดูที่คอมพิวเตอร์ จะพบไฟล์รูปภาพ ที่ ESP32-CAM ถ่ายภาพเอาไว้

credit : https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-card/


4. อัพโหลดโค้ดของโปรเจค

 เปิดโปรแกรม Arduino (IDE) อัพโหลดโค้ดด้านล่างนี้  ไปยัง ESP32-CAM

/*********
Rui Santos
Complete project details at https://RandomNerdTutorials.com/esp32-cam-pir-motion-detector-photo-capture/

IMPORTANT!!!
- Select Board "AI Thinker ESP32-CAM"
- GPIO 0 must be connected to GND to upload a sketch
- After connecting GPIO 0 to GND, press the ESP32-CAM on-board RESET button to put your board in flashing mode

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
*********/

#include "esp_camera.h"
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "fd_forward.h"
#include "fr_forward.h"
#include "FS.h" // SD Card ESP32
#include "SD_MMC.h" // SD Card ESP32
#include "soc/soc.h" // Disable brownour problems
#include "soc/rtc_cntl_reg.h" // Disable brownour problems
#include "dl_lib.h"
#include "driver/rtc_io.h"
#include <EEPROM.h> // read and write from flash memory
// define the number of bytes you want to access
#define EEPROM_SIZE 1

RTC_DATA_ATTR int bootCount = 0;

// Pin definition for CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27
#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22

int pictureNumber = 0;

#define uS_TO_S_FACTOR 1000000

void setup() {
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
Serial.begin(115200);

Serial.setDebugOutput(true);

camera_config_t config;
config.ledc_channel = LEDC_CHANNEL_0;
config.ledc_timer = LEDC_TIMER_0;
config.pin_d0 = Y2_GPIO_NUM;
config.pin_d1 = Y3_GPIO_NUM;
config.pin_d2 = Y4_GPIO_NUM;
config.pin_d3 = Y5_GPIO_NUM;
config.pin_d4 = Y6_GPIO_NUM;
config.pin_d5 = Y7_GPIO_NUM;
config.pin_d6 = Y8_GPIO_NUM;
config.pin_d7 = Y9_GPIO_NUM;
config.pin_xclk = XCLK_GPIO_NUM;
config.pin_pclk = PCLK_GPIO_NUM;
config.pin_vsync = VSYNC_GPIO_NUM;
config.pin_href = HREF_GPIO_NUM;
config.pin_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_scl = SIOC_GPIO_NUM;
config.pin_pwdn = PWDN_GPIO_NUM;
config.pin_reset = RESET_GPIO_NUM;
config.xclk_freq_hz = 20000000;
config.pixel_format = PIXFORMAT_JPEG;

pinMode(4, INPUT);
digitalWrite(4, LOW);
rtc_gpio_hold_dis(GPIO_NUM_4);

if(psramFound()){
config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
config.jpeg_quality = 10;
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}

// Init Camera
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
Serial.printf("Camera init failed with error 0x%x", err);
return;
}

Serial.println("Starting SD Card");

delay(500);
if(!SD_MMC.begin()){
Serial.println("SD Card Mount Failed");
//return;
}

uint8_t cardType = SD_MMC.cardType();
if(cardType == CARD_NONE){
Serial.println("No SD Card attached");
return;
}

camera_fb_t * fb = NULL;

// Take Picture with Camera
fb = esp_camera_fb_get();
if(!fb) {
Serial.println("Camera capture failed");
return;
}
// initialize EEPROM with predefined size
EEPROM.begin(EEPROM_SIZE);
pictureNumber = EEPROM.read(0) + 1;

// Path where new picture will be saved in SD Card
String path = "/picture" + String(pictureNumber) +".jpg";

fs::FS &fs = SD_MMC;
Serial.printf("Picture file name: %s\n", path.c_str());

File file = fs.open(path.c_str(), FILE_WRITE);
if(!file){
Serial.println("Failed to open file in writing mode");
}
else {
file.write(fb->buf, fb->len); // payload (image), payload length
Serial.printf("Saved file to path: %s\n", path.c_str());
EEPROM.write(0, pictureNumber);
EEPROM.commit();
}
file.close();
esp_camera_fb_return(fb);

delay(1000);

// Turns off the ESP32-CAM white on-board LED (flash) connected to GPIO 4
pinMode(4, OUTPUT);
digitalWrite(4, LOW);
rtc_gpio_hold_en(GPIO_NUM_4);

esp_sleep_enable_ext0_wakeup(GPIO_NUM_13, 0);

Serial.println("Going to sleep now");
delay(1000);
esp_deep_sleep_start();
Serial.println("This will never be printed");
}

void loop() {

}

View raw code5. เชื่อมต่ออุปกรณ์เพิ่มเติม


วงจรทำงานของโปรเจค




6. ทดสอบการทำงานของโปรเจค

credit : https://randomnerdtutorials.com/esp32-cam-pir-motion-detector-photo-capture/

มินิโปรเจค Arduino เปิดปิดไฟ 220V และ หรี่ไฟบ้านด้วยเสียง

เป้าหมายและหลักการทำงานของโปรเจค

ต้องการควบคุม เปิดปิดไฟด้วยเสียง รวมทั้งหรี่ไฟด้วยเสียง เพื่อเป็นการประหยัดพลังงาน และความสะดวกในการควบคุม ซึ่งจะทำให้หลอดไฟกินไฟน้อยลง นอกจากนั้นยังช่วยทำให้ยืดอายุหลอดไฟได้ยาวนานขึ้น เพราะไม่ต้องทำงานเต็มกำลังความสว่าง 100% ตลอดเวลา โดยสามารถเลือกความสว่างและเลิกใช้งานได้ตามความเหมาะสม ด้วยเสียง ดังนี้

1. เสียงปรบมือ 1 ครั้ง ให้หลอดไฟติด 100 % แต่ถ้าหลอดไฟติดอยู่ให้ดับ
2. เสียงปรบมือ 2 ครั้ง ให้หรี่ไฟหรือความสว่างลดลงเหลือ 60 %
3. เสียงปรบมือ 3 ครั้ง ให้หรี่ไฟหรือความสว่างลดลงลงเหลือ 30 %

อุปกรณ์ที่ใช้ในโปรเจค


1. Arduino UNO R3
2. Sensor Shield V 5.0

3.  Voice Sound Detection Sensor Module

4. Jumper (F2F) 20cm Female to Female

5. 1 Channel AC Light Lamp Dimmer Module

อุปกรณ์ไฟฟ้าอื่นๆ เช่น หลอดไฟ , ปลั๊กไฟ , ขั้วหลอดไฟ , สายไฟ หาซื้อได้ตามร้านขายอุปกรณ์ไฟฟ้าทั่วๆไป

*** การใช้งานแบบไม่ต้องการเชื่อมต่อสาย USB กับ คอมพิวเตอร์ ให้ใช้ Adapter DC 9V 1A Power Supply เป็นแหล่งจ่ายไฟ เสียบเข้ากับ DC Power Jack ของ  บอร์ด Arduino ***

(เพื่อความปลอดภัย : ผู้ทำโปรเจค ควรมี ความรู้ด้านไฟฟ้าเป็นอย่างดี)

ขั้นตอนการทำโปรเจค

1.  ทดสอบการทำงาน Dimmer Module
ประกอบ Sensor Shield เข้ากับ Arduino UNO

ประกอบ Sensor Shield V 5.0

เชื่อมต่อ Sensor Shield กับ Dimmer Module  

เชื่อมต่อ Dimmer Module กับ  อุปกรณ์ไฟฟ้าอื่นๆ

( หลอดไฟควรมีคุณสมบัติหรีไฟได้ เช่น หลอดไส้ร้อนแบบธรรมดา 60 – 100 วัตต์ )

ติดตั้งไลบรารี RBDdimmer โดยดาวน์โหลดไลบรารี RBDdimmer ตามลิงค์ด้านล่าง

https://github.com/RobotDynOfficial/RBDDimmer

ไปที่ Clone or download -> Download ZIP

เปิดโปรแกรม Arduino IDE

ไปที่ Skecth -> Include Library -> Add .ZIP Library…

ไปที่ ไลบรารี RBDDimmer-master.zip ที่เรา ดาวน์โหลด มา -> Open

ตรวจสอบที่ Skecth -> Include Library  จะพบ ไลบรารี RBDdimmer  เพิ่มเข้ามาใน Arduino IDE ของเรา

  เชื่อมต่อสาย USB ระหว่าง คอมพิวเตอร์ กับ บอร์ด Arduino

เปิดโปรแกรม Arduino IDE เขียนโค้ดดังนี้

#include <RBDdimmer.h>

dimmerLamp dimmer4(4); //initialase port for dimmer: name(PinNumber);


void setup() {

Serial.begin(9600);

dimmer4.begin(NORMAL_MODE, ON); //dimmer initialisation: name.begin(MODE, STATE)

Serial.println("--- Simple dimmer example ---");

//dimmer4.setState(ON); // setState(ON/OFF);

}

void loop() {

// put your main code here, to run repeatedly:

dimmer4.setPower(90); // setPower(0-100%);

delay(5000);

dimmer4.setPower(30); // setPower(0-100%);

delay(5000);

}


ไปที่ Tools > Board เลือกเป็น Arduino/Genuino UNO
 

ไปที่ Tools > Port แล้วเลือกพอร์ตที่ปรากฏ (กรณีใช้เครื่องคอมพิวเตอร์ที่มี COM Port มากกว่าหนึ่ง  ให้เลือกตัวอื่นที่ไม่ใช่ COM1)

ในตัวอย่างเลือกเป็น “COM8”

(ถ้ายังว่าง หรือ เป็น COM1 ให้ตรวจสอบการติดตั้งไดร์เวอร์ การต่อสาย USB ของ Arduino UNO)
 

(ถ้าไม่พบให้ทำการติดตั้งไดร์เวอร์ก่อน) 
การติดตั้งโปรแกรม Arduino (IDE) และ การติดตั้งไดร์เวอร์

กดปุ่ม 

 เพื่ออัพโหลด



หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า Done uploading. ที่แถบด้านล่าง


เสียบปลั๊กไฟ 220V AC หลอดไฟจะสว่าง 90%

และ 30% สลับไปมา

แสดงว่า การเชื่อมต่อ Dimmer Module ของเรานั้นถูกต้อง และ พร้อมใช้งานแล้ว

2.  ทดสอบเซ็นเซอร์เสียง Sound Detection Sensor เชื่อมต่อ Sensor Shield กับ Sound Detection Sensor

เปิดโปรแกรม Arduino IDE อัพโหลดโค้ดดังนี้

int sound_sensor = 5;

int clap = 0;
long detection_range_start = 0;
long detection_range = 0;


void setup() {
Serial.begin(9600);
pinMode(sound_sensor, INPUT);
}

void loop() {
int status_sensor = digitalRead(sound_sensor);
if (status_sensor == 0)
{
if (clap == 0)
{
detection_range_start = detection_range = millis();
clap++;
}
else if (clap > 0 && millis() - detection_range >= 40)
{
detection_range = millis();
clap++;
}

}

ทดสอบการทำงาน

ให้เอาไขควงหมุน ปรับค่าการรับสัญญาณเสียง โดยให้หมุนตัว R ปรับค่าได้ แบบ trimpot สีฟ้า

ให้ไฟ LED สีเขียว ด้านซ้ายมือติดดวงเดียว

เมื่อปรบมือให้  LED สีเขียวด้านขวามือ กระพริบ ตาม การปรบมือของเรา

เปิดหน้าต่าง Serial Monitor  โดยไปที่ Tools > Serial Monitor

มุมขวาล่าง ของ Serial Monitor เลือกเป็น 9600 baud  คือ ตั้งค่าความเร็วในการรับ-ส่งข้อมูล  คือ 9600 ตามที่เราเขียนโค้ดไว้

ทดสอบให้ได้ผลลัพธ์ดังนี้

1. เสียงปรบมือ 1 ครั้ง ให้  Serial Monitor แสดง clap = 1
2. เสียงปรบมือ 2 ครั้ง ให้  Serial Monitor แสดง clap = 2
3. เสียงปรบมือ 3 ครั้ง ให้  Serial Monitor แสดง clap = 3

  ถ้ายังไม่ได้ให้ ปรับค่าการรับสัญญาณเสียง โดยให้หมุนตัว R ปรับค่าได้ แบบ trimpot สีฟ้า

3.  ทดสอบ โปรเจค เปิดปิดไฟ 220V และ หรี่ไฟบ้านด้วยเสียง

เปิดโปรแกรม Arduino IDE อัพโหลดโค้ดดังนี้

#include <RBDdimmer.h>

dimmerLamp dimmer4(4);

int sound_sensor = 5;

int clap = 0;
long detection_range_start = 0;
long detection_range = 0;
boolean status_lights = false;


void setup() {
Serial.begin(9600);
pinMode(sound_sensor, INPUT);
dimmer4.begin(NORMAL_MODE, ON);
dimmer4.setState(OFF);
}

void loop() {
int status_sensor = digitalRead(sound_sensor);
if (status_sensor == 0)
{
if (clap == 0)
{
detection_range_start = detection_range = millis();
clap++;
}
else if (clap > 0 && millis() - detection_range >= 40)
{
detection_range = millis();
clap++;
}
}
if (millis() - detection_range_start >= 600)
{

if (!status_lights && clap == 1)
{

Serial.println("clap = 1 , Lamp = ON");
dimmer4.setState(ON);
dimmer4.setPower(100);
status_lights = true;
}

else if (status_lights && clap == 1)
{

Serial.println("clap = 1 , Lamp = OFF");
dimmer4.setState(OFF);
status_lights = false;
}

else if (status_lights && clap == 2)
{
Serial.println("clap = 2 , Lamp = 60%");
dimmer4.setPower(60);
}

else if (status_lights && clap == 3)
{
Serial.println("clap = 3 , Lamp = 30%");
dimmer4.setPower(30);
}
clap = 0;

}

}

จะได้ผลลัพธ์ตามคลิปด้านบน

โปรเจค หุ่นยนต์เดินตามเส้น 2 เซ็นเซอร์ Arduino

โปรเจค หุ่นยนต์เดินตามเส้น 2 เซ็นเซอร์ Arduino หุ่นยนต์และมนุษย์มีหลักการทำงานที่เหมือนกัน คือ หน่วยรับข้อมูลเข้า (Input Unit) หน่วยประมวลผล (Process Unit) และหน่วยแสดงผล (Output Unit) ดังนั้นการที่หุ่นยนต์จะเคลื่อนที่ไปให้ตรงเป้าหมาย หุ่นยนต์จะต้องมีอุปกรณ์ที่จะตรวจสอบตำแหน่งและส่งข้อมูลที่ได้ไปยังหน่วยประมวลผล เพื่อให้มอเตอร์ทำการแสดงผลโดยการไปยังเป้าหมายต่อไป อุปกรณ์พื้นฐานที่ใช้ในการตรวจสอบตำแหน่งนั้น คือ โมดูลเซ็นเซอร์แสงสำหรับตรวจจับวัตถุกีดขวาง


อุปกรณ์ที่ต้องใช้ก็คือ


     1. 2WD Smart Robot Car Chassis Kits

     2. Arduino UNO R3 – Made in italy

     3. IR Infrared Obstacle Avoidance Sensor Module จำนวน 2 ชิ้น 

     4. Motor Drive Module L298N

     5. สาย Jumper Female to Male ยาว 20cm.

     6. สาย Jumper Male to Male ยาว 20cm.

     7. รางถ่านแบบ 18650 ใส่ถ่าน 2 ก้อน

     8. แบตเตอรี่ลิเธียม 18650 จำนวน 2 ก้อน

     9. เสารองแผ่นพีซีบีโลหะแบบเหลี่ยม 6 mm.

    10. สกรูหัวกลมน็อตตัวเมีย ขนาด 3มม ยาว12 มม.

    11. Mounting Bracket for HC-SR04 Ultrasonic Module แบบสั้น

    12. แผ่นอะคริลิค


การทำงานของ หุ่นยนต์เดินตามเส้น Arduino



เรียนรู้ การใช้งาน IR Infrared Obstacle Avoidance Sensor Module เพิ่มเติมที่

https://robotsiam.blogspot.com/2016/10/ir-infrared-obstacle-avoidance-sensor.html


เซ็นเซอร์แบบนี้จะมีช่วงในการทำงาน หรือ ระยะในการตรวจจับจะได้ใกล้กว่าแบบ Opposed mode ซึ่งในสภาวะการทำงานปกติ พื้นเเป็นสีขาว ตัวรับ Receiver จะสามารถรับสัญญาณแสงจากตัวส่ง  Emitter ได้ตลอดเวลา เนื่องจากลำแสง สะท้อนกลับมาได้ จะแสดงค่า เป็น 0


และ เมื่อพื้นเป็นสีดำ แสงสะท้อนกลับมาไม่ได้   จึงทำให้ตัวรับ Receiver ไม่สามารถรับลำแสงที่จะสะท้อนกลับมาได้ จะแสดงค่า เป็น 1

เซ็นเซอร์ตรวจสอบการสะท้อนแสงกลับมา ได้หรือไม่ แล้วส่งสัญญาณไปยัง Arduino Uno R3 แล้ว Arduino Uno R3 จึงไปสั่งให้มอเตอร์ทำงาน โดย Motor Drive Module L298N ให้เป็นไปตามการส่งค่ามาของเซ็นเซอร์

โปรเจค หุ่นยนต์เดินตามเส้น 2 เซ็นเซอร์ Arduino  นี้ เราจะใช้ 2 เซ็นเซอร์อินฟราเรด คือด้านซ้ายและด้านขวา  โดย เมื่อเซ็นเซอร์ ทั้งด้านซ้ายและด้านขวา ตรวจสอบแล้วเป็นพื้นสีขาว ลำแสง สามารถสะท้อนกลับมาได้ทั้งคู่  ( 0 , 0 ) ให้หุ่นยนต์เคลื่อนที่ไปข้างหน้า

หากเซ็นเซอร์ซ้ายมาพบพื้นสีดำ  และ เซ็นเซอร์ขวาพบพื้นสีขาว ( 1 , 0 ) ให้หุ่นยนต์เลี้ยวไปทางด้านซ้าย


หากเซ็นเซอร์ขวามาพบพื้นสีดำ  และ เซ็นเซอร์ซ้ายพบพื้นสีขาว ( 0 , 1 ) ให้หุ่นยนต์เลี้ยวไปทางด้านขวา

หากเซ็นเซอร์ทั้งสองมาอยู่บนเส้นสีดำทั้งคู่ ( 1 , 1 ) ให้หุ่นยนต์หยุด

โดยสรุป มี 4 เงื่อนไขที่ หุ่นยนต์เดินตามเส้น Arduino รับค่าจากเซ็นเซอร์ซ้ายและขวา
คือ (0 ,0) | (0 ,1) | (1 , 0) | (1 ,1 ) แสดงตามตารางด้านล่าง


อินพุต เอาต์พุต การเคลื่อนที่ของหุ่นยนต์
เซ็นเซอร์ซ้าย เซ็นเซอร์ขวา มอเตอร์ซ้าย มอเตอร์ขวา
LS RS LM1 LM2 RM1 RM2
0 0 0 0 0 0 เดินหน้า
0 1 1 0 0 0 เลี้ยวขวา
1 0 0 0 1 0 เลี้ยวซ้าย
1 1 1 0 1 0 หยุด

เราจะสร้าง หุ่นยนต์เดินตามเส้น Arduino และ เขียนโปรแกรมตามเงื่อนไขที่แสดงในตารางด้านบน

เริ่มต้นด้วยการ ประกอบ Smart Robot Car Chassis Kit

ต่อวงจร Arduino  UNO กับ L298N  Motor Driver ตามรูปการต่อวงวงจร

นำไฟจากแบตเตอรี่ลิเธียม 18650 ไปต่อตรงกับ L298N  Motor Driver (ไม่ต่อกับ พอร์ต Power Supply ของ บอร์ด Arduino  UNO R3 ) และ นำไฟ +5 โวลต์ ที่ออกจาก L298N  Motor Driver ต่อออกไปที่  5V ของ Arduino  UNO R3 ตามรูปการต่อวงวงจร

*** VCC ของ Arduino UNO R3 คือ 5V ***

ต่อวงจร Arduino  UNO กับ Sensor ทั้ง 2 ตัว

เข้า ขา D2 และ D3 ตามรูป

Sensor <-> UNO

VCC (ซ้าย,ขวา) <-> 5V
GND (ซ้าย,ขวา) <-> GND
OUT (ซ้าย)       <-> D2
OUT (ขวา)       <-> D3

ตรง 5V ของ Arduino จะมี 3 สายใช้ร่วมกัน ให้เชื่อมต่อ บัตกรี รวมกันก่อนแล้วจึงต่อเข้าไปที่ 5V

ตัดแผ่นอะคริลิค ขนาด 3 x 10 เซ็นติเมตร 
ประกอบ เซ็นเซอร์ซ้ายและขวา

ยึดเข้ากับ Mounting Bracket for HC-SR04 Ultrasonic Module แบบสั้น

ยึดเข้ากับ ตัวหุ่นยนต์


การปรับแต่ง เซ็นเซอร์ให้ตรวจจับเส้น


เมื่อต่อวงจร หุ่นยนต์เดินตามเส้น เสร็จแล้ว ให้ต่อสาย USB จากคอมพิวเตอร์ เข้ากับ Arduino  UNO R3 ปรับ ระยะการตรวจจับของเซ็นเซอร์ โดยใช้ไขควง ปรับ ที่ VR (สี่เหลี่ยมสีฟ้า-ขาว) โดยใช้มือเคลื่อนที่หุ่นยนต์ผ่านเส้นสีดำและพื้นสีขาว

ให้ปรับเซ็นเซอร์ทั้ง 2 ตัว ดังนี้ ถ้าอยู่บนพื้นสีขาว ให้ไฟ LED ติด 2 ดวง และ ถ้าเข้าไปในบนเทปสีดำ ให้ ไฟ LED ติด 1 ดวง
 

ถาพรวมเมื่อต่อเสร็จแล้ว

อัพโหลดโปรแกรม

เปิดโปรแกรม Arduino (IDE) และ Upload โค้ดนี้ ไปยัง บอร์ด Arduino UNO R3


 /*——-definning Inputs——*/
int LS = 2;     // left sensor
int RS  = 3;      // right sensor

/*——-definning Outputs——*/
int LM1 = 4;      // left motor
int LM2 =  5;       // left motor
int RM1 =  6;       // right motor
int RM2 =  7;       // right motor

/*——-PWM ควบคุมความเร็วมอเตอร์—–*/
int PWM1 = 10;    // PWM left motor
int PWM2 = 11;    // PWM right motor
int SPEED = 90;  // Speed PWM สามารถปรับความเร็วได้ถึง 255

void setup()
{
  pinMode(LS, INPUT);
  pinMode(RS, INPUT);
  pinMode(LM1, OUTPUT);
  pinMode(LM2, OUTPUT);
  pinMode(RM1, OUTPUT);
  pinMode(RM2, OUTPUT);
  pinMode(PWM1, OUTPUT);
  pinMode(PWM2, OUTPUT);
}

void loop()
{

  if (!(digitalRead(LS)) && !(digitalRead(RS)))    // Move Forward
  {
    analogWrite(PWM1, SPEED);
    digitalWrite(LM1, HIGH);
    digitalWrite(LM2, LOW);
    analogWrite(PWM2, SPEED);
    digitalWrite(RM1, HIGH);
    digitalWrite(RM2, LOW);
  }


  if (!(digitalRead(LS)) && digitalRead(RS))    // Turn right
  {
    digitalWrite(LM1, LOW);
    digitalWrite(LM2, LOW);
    analogWrite(PWM2, SPEED);
    digitalWrite(RM1, HIGH);
    digitalWrite(RM2, LOW);
  }

  if (digitalRead(LS) && !(digitalRead(RS)))    // turn left
  {
    analogWrite(PWM1, SPEED);
    digitalWrite(LM1, HIGH);
    digitalWrite(LM2, LOW);
    digitalWrite(RM1, LOW);
    digitalWrite(RM2, LOW);
  }

 if (digitalRead(LS) && digitalRead(RS))    // stop
  {
    digitalWrite(LM1, LOW);
    digitalWrite(LM2, LOW);
    digitalWrite(RM1, LOW);
    digitalWrite(RM2, LOW);
  }

}




ก่อนอัพโหลดให้ตรวจสอบ

1.ตรวจสอบการติดตั้งไดรเวอร์ ของ Arduino UNO

ไปที่หน้าจอคอมพิวเตอร์  คลิกขวาที่ Computet -> Properties

คลิกที่ Device Manager

ไปที่ Ports (COM & LPT) จะพบ ไดร์เวอร์ ของ Arduino UNO ในตัวอย่างเป็น “COM3”


(ถ้าไม่พบให้ทำการติดตั้ง
ไดร์เวอร์ก่อน) 
การติดตั้งโปรแกรม Arduino (IDE) และ การติดตั้งไดร์เวอร์


2. ตรวจสอบการเลือก Board


ให้เลือก Board : เป็น Arduino/Genuino UNO


3. ตรวจสอบ ต้องมี Port :  
ในตัวอย่างเป็น COM3

(ถ้ายังว่าง หรือ เป็น COM1 ให้ตรวจสอบการติดตั้งไดร์เวอร์ การต่อสาย USB ของ Arduino UNO)

ถ้าทุกอย่างถูกต้อง ให้คลิกเครื่องหมายตรงไป เพื่ออัพโหลด

4. รอกระทั่ง จนขึ้น Done uploading. 


แสดงว่า สามารถอัพโหลดโปรแกรมเข้า Arduino UNO สําเร็จแล้ว

วีดีโอผลลัพธ์การทำงานของ หุ่นยนต์เดินตามเส้น 2 เซ็นเซอร์ Arduino

[บทความโดย robotsiam

โปรแกรมแรก กับ บอร์ด micro:bit

micro:bit สามารถพัฒนาได้ง่ายๆ ด้วยการ เขียนโปรแกรม แบบ บล๊อกคำสั่ง (Block) โดยไม่จำเป็นต้องติดตั้งโปรแกรมลงบนเครื่องคอมพิวเตอร์ สามารถพัฒนาผ่านเว็บบราวเซอร์ (Web Browser) ได้เลย Block หรือ JavaScript นี้ มีชื่อเรียกว่า “MakeCode” ซึ่งเป็นส่วนที่เอาไว้พัฒนาโปรแกรมให้กับ micro:bit ที่พัฒนาได้ทั้งแบบ Block และ JavaScript

ในโลกของการเขียนโปรแกรม “Hello World” คือ คำที่นิยมใช้เวลาเริ่มเขียนโปรแกรมแรก (มักเป็นโปรแกรมง่ายๆ เพื่อทดสอบการทำงาน ว่าสามารถทำงานได้จริง) ในโลกของอิเล็กทรอนิกส์ก็เช่นกัน “Hello World” ก็คือ การทำ “ไฟกระพริบ”  ด้วยตัวอย่างโปรแกรมแรก กับ micro:bit โดยการเขียนโปรแกรม ให้ไฟกระพริบ เป็นหัวใจหงาย และ หัวใจคว่ำ สลับกันไปมา

### อุปกรณ์ที่ใช้ ###


1. micro:bit Main Board

2. Micro USB Cable




### ขั้นตอนการทํางาน ###



1. เชื่อมต่อสาย Micro USB ระหว่าง คอมพิวเตอร์ กับ บอร์ด micro:bit

2. ตรวจสอบการติดตั้งไดร์เวอร์ ของ บอร์ด micro:bit


2.1 ที่หน้าจอคอมพิวเตอร์ คลิกขวาที่ Computet -> Properties

2.2 คลิกที่ Device Manager


2.3 ที่ Ports (COM & LPT) จะพบ บอร์ด micro:bit ที่ยังไม่ได้ติดตั้ง ไดร์เวอร์

3. ติดตั้งไดร์เวอร์  ให้กับ บอร์ด micro:bit


3.1 ดาวน์โหลดไดร์เวอร์ ของบอร์ด micro:bit


3.2 คลิกที่ download

3.3 ไปที่ โฟลเดอร์ Downloads คลิกที่ไฟล์ mbed_usb_2020_x64_1212

3.4 คลิก Next

3.5 คลิก Install

3.6  รอ…

3.7 คลิก Install

3.8  รอ…

3.9  คลิก Finish

4. ตรวจสอบการติดตั้งไดร์เวอร์ ของ บอร์ด micro:bit อีกครั้ง


4.1 ที่หน้าจอคอมพิวเตอร์ คลิกขวาที่ Computet -> Properties

4.2 คลิกที่ Device Manager


4.3 ที่ Ports (COM & LPT) จะพบ บอร์ด micro:bit ที่ติดตั้ง ไดร์เวอร์ แล้ว

ในตัวอย่างเป็น  mbed Serial Port  (COM19)

5. เริ่มเขียนโปรแกรม micro:bit โปรแกรมแรก


5.1  ไปที่  https://makecode.microbit.org/


5.2 คลิกที่ New Project

5.3 คลิกที่ Basic

5.4 ลากบล๊อกคำสั่ง show leds มาวางไว้ในบล๊อกคำสั่ง forever


5.5 ในบล๊อกคำสั่ง show leds ให้คลิกที่จุดที่ต้องให้ LED สว่าง ซึ่งในที่นี้เราจะทำเป็นรูปหัวใจ (หงาย)

5.6 ลากบล๊อกคำสั่ง Basic > pause (ms) มาวางต่อจาก show leds และแก้ไขค่าตัวแปรให้เป็น “1000” มิลลิวินาที (หรือ 1 วินาทีนั่นเอง)

5.7  ลากบล๊อกคำสั่ง Basic > show leds มาวางไว้ในบล๊อกคำสั่ง forever แล้วคลิกที่จุดที่ต้องให้ LED สว่าง ทำเป็นรูปหัวใจ (คว่ำ)

5.8 ลากบล๊อกคำสั่ง Basic > pause (ms) มาวางต่อจาก show leds และแก้ไขค่าตัวแปรให้เป็น “1000” มิลลิวินาที (หรือ 1 วินาทีนั่นเอง)

5.9 ตั้งชื่อโปรเจค เป็นชื่ออะไรก็ได้ ในที่นี่ตั้งชื่อว่า LED1 คลิก Download เพื่อดาวโหลดไฟล์

ซึ่งเราจะได้ไฟล์นามสกุล .hex มาไว้ที่เครื่องเรา ในตัวอย่างนี้จะได้ชื่อไฟล์เป็น microbit-LED1.hex  แล้ว ปิดหน้าต่างลงไป

5.10 ไปที่ โฟลเดอร์ Downloads คลิกขวาที่ไฟล์ microbit-LED1.hex -> Sent to -> MICROBIT (เพื่ออัพโหลดไฟล์ไปที่ไดร์ฟ MICROBIT)

6. ผลลัพล์การทำงาน ที่บอร์ด micro:bit จะแสดง เป็นหัวใจหงาย และ หัวใจคว่ำ สลับกันไปมา


ดาวน์โหลดโค้ด :
https://drive.google.com/file/d/1KvLP-_flIBB7_YNrLI2BscBmJjTcRqom/view