วันพุธที่ 25 มกราคม พ.ศ. 2560



ที่พวกเราเรียกว่า LCD นั้น มาจากคำว่า Liquid Crystal Display ครับ หลักการทำงานของมันอาศัย-ของเหลวพิเศษที่มีคุณสมบัติการบิดแกนโพราไรซ์ของแสงครับ  ถ้าจ่ายแรงดันไฟฟ้าเข้าไประหว่างสารเหลวนี้  โมเลกุลของมันจะบิดตัวและทำให้แสงไม่สามารถผ่านกระจกออกมาได้  ถ้าไม่มีการจ่ายแรงดันไฟฟ้าแสงจะทะลุผ่านออกมาได้

รูปด้านล่างอธิบายความได้เป็นอย่างดีครับ  การทำงานของมันเกิดจากกระจกโพลาไรซ์ 2 แผ่น ที่มีแกนตั้งฉากกัน   ดังนั้นถ้าไม่ทำอะไรเลยแสงจะไม่สามารถลอดผ่านออกมาได้  เหมือนเอาแว่นตาโพลาไรซ์สองอันมาบิดทำมุมตั้งฉากกัน แสงจะไม่ลอดผ่าน  ทีนี้มีคนไปพบว่ามีของเหลวชนิดนึงที่ปกติแล้วจะสามารถ "บิดแกนโพลาไรซ์ของแสง" ได้ ก็เลยเกิดความคิดเอามาทำจอ LCD

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

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

แรกๆที่ทำออกมาก็ไม่ซับซ้อนครับ ใช้ทำเครื่องคิดเลขบ้าง นาฬิกาบ้าง  ต่อมาก็เอามาทำจอ LCD Matrix  จากนั้นเริ่มมีการผสมสี RGB และทำให้จอมีความละเอียดมากขึ้น  (Pixel ต่อ พื้นที่่)  ก็เลยกลายเป็นทีวีจอ  LCD  สีที่เราเห็นครับ

ในบทความนี้ผมจะพูดถึงเฉพาะ LCD ชนิดที่เป็น matrix ซึ่งใช้แสดงตัวอักษรมาตรฐานนะครับ  จึงอยู่ว่าจอ LCD matrix สามารถแสงเป็นภาพ หรือ ตัวอักษรตามแต่ผู้ใช้จะควบคุม  แต่บทความนี้เอาแบบสั้นๆ คนทั่วไปใช้ละกันครับ  เลยเขียนเฉพาะการควบคุมให้แสดงตัวอักษรมาตรฐาน

หลักการทำงานก็จบไป  มาถึงรายละเอียดของตัว LCD กันบ้างว่ามีอะไรกันบ้าง มีกี่ Pin   ตารางด้านล่างนี้เป็นรายละเอียดของ PIN ของ LCD แบบที่นิยมใช้กันมากๆ คือ 16 x 2 (หมายถึง 16 ตัวอักษร 2 บรรทัดนะครับ)  ถ้าดูที่แต่ละตัวอักษรจะเห็นว่ามันเป็น matrix  5x8 ซึ่งแสดงถึงความละเอียดของตัวอักษรนะครับ

ทีนี้ Pin ของ LCD ก็จะมี 16 Pin ตามรายละเอียดในตารางครับ
Pin Description:

16 PIN ที่ว่าก็จะมีตั้งแต่ไฟเลี้ยง กราวด์ Data การควบคุมแสง การควบคุมการแสดงครับ  

สำหรับการให้ข้อมูลการแสดงบนหน้าจอ หรือ การติดต่อควบคุมการทำงานของ LCD ก็จะทำโดยผ่าน IC ของบริษัท Hitachi เบอร์ HD44780   เจ้านี้เขาทำเจ้าแรกๆ จนกลายเป็นมาตรฐานของโลกไปแล้วครับ

HD44780 สามารถคุยด้วยได้ 2 แบบหลักคือ แบบ 4 Bit  (DB4 - DB7) และ แบบ 8 Bit (DB0 - DB7)  ทั้งสองแบบนี้ก็ต่างกันตรงที่ใช้จำนวน pin จาก Arduino 4 pin กับ 8 pin ครับ    ก็แน่นอนครับ เราคงไม่อยากใช้ Port เปลือง ดังนั้นส่วนมากคนก็จะนิยมใช้แบบ 4 Pin กันครับ  แต่ก็มีความเร็วในการส่งข้อมูลช้ากว่าแบบ 8 pin ครับ   แต่ความเร็วที่ว่าก็ไม่ได้เป็นอุปสรรคเลยครับ 4 bit ก็เร็วมากจนสายตาของเราแยกไม่ออกแล้วครับ    สรุปก็คือว่าผมแนะนำการต่อแบบ 4 bit ละกันนะครับ ตามภาพด้านบนก็ได้ครับ  แล้วแบบ 8 bit มีไว้ทำไมละ  คำตอบก็คือ ในยุคแรกๆ ไมโครคอนโทรลเลอร์เขาออกมาเป็นแบบ 8 bit แล้วเพื่อให้เขียนโปรแกรมไม่ซับซ้อนมากนัก ก็เลยใช้ 8 bit ให้เหมือนกัน register ในไมโครคอนโทรลเลอร์ซะครับ

สำหรับ Arduino แล้ว เราจะใช้ LCD แบบบ้านๆ ที่มีขายตามบ้านหม้อ (ถ้าดูภาพแรกก็คือ LCD อันล่าง) หรือจะใช้เป็นแบบ LCD Shield  ก็มีหลักการทำงานเดียวกัน  ใช้ library เดียวกันครับ  ถ้าใช้แบบ LCD เดี่ยวๆ ก็ต้องมาต่อขากันเองนิดหน่อย แต่ถ้าใช้ LCD Shield ก็จับยัดได้เลยครับ แถมมีปุ่มกดมาให้ด้วยครับ  ก็แล้วแต่งานที่ต้องเอาไปประยุกต์ใช้ครับ
และก็ตามสไตล์ของ Arduino ครับคือการมี library ที่่ทำให้ใช้งานได้สะดวกมากๆ  ใครที่เคยใช้ ไมโครคอนโทรลเลอร์ตัวอื่นมาก่อนจะรู้สึกถึงความแตกต่างชัดเจนครับ   Library ของ LCD ก็คือ    มีคำสั่งที่สำคัญดังนี้ครับ

LiquidCrystal()  ก็ใช้ในการประกาศ Pin ที่เราจะส่งข้อมูลไปที่จอ LCD ครับ เช่น LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  ก็หมายถึง RS ที่ Pin 8   Enable ที่ Pin 9 และ DB4 - DB 7 ที่ขา 4, 5, 6, 7  ตามลำดับครับ   ถ้าดูรายละเอียดในคำสั่งนี้ เราจะสามารถใช้การส่งข้อมูลแบบ 8 บิตได้ด้วยครับ

begin() ใช้ในการกำหนดลักษณะการแสดงของจอ เช่น  lcd.begin(16, 2);  คือการแสดงภาพ 16 ตัวอักษร 2 แถวครับ

print() ใช้ในการเขียนข้อความ เช่น  lcd.print("Hello !!!");

setCursor() ใช้ในการกำหนดตำแหน่งของ Cursor เช่น  lcd.setCursor(13, 1); คือให้เคอร์เซอร์ไปที่ ตัวอักษรที่ 13 และแถวที่ 1  (อย่าลืมนะครับ มันจะเริ่มนับจาก 0 ตามสไตล์ภาษา C)

cursor() ก็คือการแสดงตัว Cursor บนหน้าจอครับ เช่น lcd.cursor();
noCursor() ก็คือการซ่อน Cursor

 ที่เหลือ รบกวนไปที่ Arduino.cc นะครับ

สำคัญคือการต่อนะครับ ต้องต่อตามที่เขียนไว้ในคำสั่ง LiquidCrystal()   นะครับ Arduino จะได้สั่งงานไปถูกขา

ทีนี้เอาแบบง่ายๆ คือ Hello Arduitronics ครับ  ผมสาธิตโดยการใช้  LCD Shield  นะครับ ทีนี้ตัว  LCD Shield นี้มันก็มีการต่อขาไว้ที่ตัว LCD แบบตายตัวแล้ว เปลี่ยนไม่ได้ซะด้วย ก็ใช้ตามนี้เลยนะครับ
liquidCrystal lcd(8, 9, 4, 5, 6, 7);

ถ้าต่อเองก็เลือกเอาตามอัธยาสัยได้เลยครับ
-------------------------------------------------------------------------------------------------
/*
  LiquidCrystal Library - "Hello !!!!  Arduitronics"
 Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
 library works with all LCD displays that are compatible with the
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.
 This sketch prints "Hello !!!!  Arduitronics" to the LCD
 and shows the time.
  The circuit:
 * LCD RS pin to digital pin 8
 * LCD Enable pin to digital pin 9
 * LCD D4 pin to digital pin 4
 * LCD D5 pin to digital pin 5
 * LCD D6 pin to digital pin 6
 * LCD D7 pin to digital pin 7
 * LCD R/W pin to ground
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe
 Modified by Arduitronics
 This example code is in the public domain.
 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */
// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("Hello !!!");
  lcd.setCursor(0, 1);
  lcd.print("Arduitronics");
}
void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(13, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);
}
-------------------------------------------------------------------------------------------------

ถ้าต่อถูกต้องก็ตามภาพด้านล่างนี้เลยครับ




อ้างอิง



https://www.arduitronics.com/article/28/%E0%B8%81%E0%B8%B2%E0%B8%A3%E0%B9%83%E0%B8%8A%E0%B9%89%E0%B8%87%E0%B8%B2%E0%B8%99-lcd-%E0%B8%81%E0%B8%B1%E0%B8%9A-arduino

วันจันทร์ที่ 9 มกราคม พ.ศ. 2560

การใช้งาน Character LCD Display กับ Arduino
(ตอนที่2 - รูปแบบการเชื่อมต่อแบบ I2C)

           จากบทความตอนที่แล้ว ที่กล่าวถึง  การใช้งาน Character LCD Display กับ Arduino (ตอนที่1 - รูปแบบการเชื่อมต่อแบบ Parallel) ในบทความนี้ เราจะมาอธิบายในอีกส่วนหนึ่ง คือการเชื่อมต่อจอ Character LCD Display 16x2 กับ Arduino ในฟรูปแบบ I2C (Serial) รวมถึงการนำไปใช้งานจริงและมีฟังก์ชั่นอะไรบ้างที่ใช้ในการสั่งงานจอ LCD
            ก่อนอื่นเรามาย้อนไปดูกันก่อนว่าจอ LCD ที่มีการเชื่อมแบบ I2C นั้นมีขาในการเชื่อมต่ออะไรบ้าง จอ LCD ที่มีการเชื่อมต่อแบบ I2C หรือเรียกอีกอย่างว่าการเชื่อมต่อแบบ Serial จะเป็นจอ LCD ธรรมดาทั่วไปที่มาพร้อมกับบอร์ด I2C Bus ที่ทำให้การใช้งานได้สะดวกยิ่งขึ้นและยังมาพร้อมกับ VR สำหรับปรับความเข้มของจอ ในรูปแบบ I2C จะใช้ขาในการเชื่อมต่อกับ Microcontroller เพียง 4 ขา (แบบ Parallel ใช้ 16 ขา) ซึ่งทำให้ใช้งานได้ง่ายและสะดวกมากยิ่งขึ้น สามารถดูได้จากตารางด้านล่างครับ



การควบคุมการแสดงผลของจอ LCD (I2C)
           ในการควบคุมหรือสั่งงาน โดยทั่วไปจอ LCD จะมีส่วนควบคุม (Controller) อยู่ในตัวแล้ว ผู้ใช้สามารถส่งรหัสคำสั่งสำหรับควบคุมการทำงานของจอ  LCD (I2C) เช่นเดียวกันกับจอ LCD แบบธรรมดา พูดง่ายๆ คือรหัสคำสั่งที่ใช้ในการควบคุมนั้นเหมือนกัน แต่ต่างกันตรงที่รูปแบบในการรับส่งข้อมูล ในบทความนี้เราจะมาพูดถึงจอ LCD 16x2 ที่มีการส่งข้อมูลรูปแบบ I2C ที่ใช้ขาเพียง 4 ขาที่ใช้ในการเชื่อมต่อเท่านั้น
           1. GND เป็น Ground ใช้ต่อระหว่าง Ground ของระบบ Microcontroller กับ LCD
           2. VCC เป็นไฟเลี้ยงวงจรที่ป้อนให้กับ LCD มีขนาด +5VDC
           3. SDA (Serial Data) เป็นขาที่ใช้ในการรับส่งข้อมูล
           4. SCL (Serial Clock) เป็นขาสัญญาณนาฬิกาในการรับส่งข้อมูล
การรับ-ส่งข้อมูลแบบ I2C BUS


            - MCU จะทำการส่งสถานะเริ่มต้น (START Conditions) เพื่อแสดงการขอใช้บัส
            - แล้วตามด้วย รหัสควบคุม (Control Byte) ซึ่งประกอบ ด้วยรหัส ประจำตัวอุปกรณ์ Device ID, Device Address และ Mode ในการเขียนหรืออ่านข้อมูล
            - เมื่ออุปกรณ์รับทราบว่า MCU ต้องการจะติดต่อด้วย ก็ต้องส่งสถานะรับรู้ (Acknowledge) หรือแจ้งให้ MCU รับรู้ว่าข้อมูลที่ได้ส่งมามีความถูกต้อง
            - และเมื่อสิ้นสุดการส่งข้อมูล MCU จะต้องส่งสถานะสิ้นสุด (STOP Conditions) เพื่อบอกกับอุปกรณ์ว่า สิ้นสุดการใช้บัส
การเชื่อมต่อระหว่าง Microcontroller กับ LCD (I2C)
            สำหรับการเชื่อมต่อสัญญาณระหว่าง Microcontroller กับ LCD ที่มีบอร์ด I2C อยู่แล้วนั้น การส่งข้อมูลจาก Microcontroller จะถูกส่งออกมาในรูปแบบ I2C ไปยังบอร์ด I2C และบอร์ดจะมีหน้าที่จัดการข้อมูลให้ออกมาในรูปแบบปกติ หรือแบบ Parallel เพื่อใช้ในการติดต่อไปยังจอ LCD โดยที่รหัสคำสั่งที่ใช้ในการสั่งงานจอ LCD ยังคงไม่ต่างกับจอ LCD ที่เป็นแบบ Parallel โดยส่วนใหญ่บอร์ด I2C จะเชื่อมต่อกับตัวควบคุมของจอ LCD เพียง 4 บิตเท่านั้น เดี๋ยวเราจะมาดูกันว่า วงจรภายในระหว่างจอ LCD กับบอร์ด I2C นั้น มีการต่อไว้อย่างไรบ้าง


            จากรูปวงจรจะเห็นได้ว่าจอ LCD และ บอร์ด I2C ได้มีการเชื่อมต่อขาสำหรับการรับส่งข้อมูลเป็นแบบ 4 บิต ขาที่เชื่อมต่อไว้คือ ขา P4 > DB4, P5 > DB5, P6 > DB6, P7 > DB7 และขา P2 > E (Enable), P1 > R/W, P0 > RS รวมไปถึงตัวต้านทานสำหรับปรับค่าความเข้มของตัวอักษร และ Switch Blacklight จากวงจรขาที่จำเป็นในการใช้งานถูกเชื่อมต่อเข้ากับตัวบอร์ด I2C และอุปกรณ์อิเล็กทรอนิกส์เรียบร้อยแล้ว สถานะพร้อมใช้งานครับ


การเชื่อมต่อระหว่าง Arduino กับจอ LCD (I2C)





รายละเอียดชุดคำสั่งที่ใช้ในการสั่งงานระหว่าง Arduino กับจอ LCD
           คำสั่งที่ใช้ในการควบคุมจอ  LCD ของ Arduino แบบ I2C นั้นไม่ต่างจากจอ LCD แบบธรรมดา (Parallel) มากนัก ทั้งนี้ยังได้มีการพัฒนา Library I2C มาให้ใช้งานได้อย่างสะดวกมากยิ่งขึ้น เรามาเริ่มต้นขั้นตอนแรกในการเขียนโปรแกรมกันเลยครับ ขั้นตอนแรกคือการนำไฟล์ Library LCD (I2C) ไปไว้ใน Library ของ Arduino ก่อนเพื่อให้ง่ายต่อการเรียกใช้ Library ผู้ใช้สามารถทำตามขั้นตอนด้านล่างได้เลยครับ
           1. Download Library LCD (I2C) ก่อนครับ >> (ไฟล์ LiquidCrystal_I2C.7z)
           2. ทำการแยกไฟล์ที่โหลดมาข้างต้น แล้วนำไปไว้ยัง  C:\Program Files (x86)\Arduino\libraries (Drive ที่ได้ทำการติดตั้งโปรแกรม Arduino IDE ไว้)


            หลังจากที่เรานำไฟล์ Library ไปไว้เรียบร้อยแล้ว เราก็มาเริ่มการเขียนโปรแกรมกันเลยครับ ก่อนอื่นให้เราเรียก Library ของการสื่อสารแบบ I2C และ Library ของจอ LCD (I2C) ก่อนเลยครับ คือ Wire.h และ LiquidCrystal_I2C.h หลังจากทำการเรียก Library เรียบร้อยแล้ว เราจะมาดูกันว่ามีฟังก์ชั่นเบื้องต้นอะไรบ้างที่จะทำให้จอ LCD ของเราแสดงผล
           ฟังก์ชั่นแรก LiquidCrystal_I2C(); ใช้ในการประกาศ Address และ ขนาดของจอ รูปแบบของคำสั่งคือ LiquidCrystal_I2C lcd (Address, columns, rows); ในบทความนี้เราจะกำหนดดังนี้ LiquidCrystal_I2C lcd(0x27, 16, 2); หมายถึง Address ของจอคือ 27 ขนาดของจอคือ 16 ตัวอักษร 2 บรรทัด
           ฟังก์ชั่นต่อมา  begin(); ใช้ในการกำหนดการเริ่มต้นในการใช้งานจอ
           ฟังก์ชั่นต่อมา setCursor();ใช้ในการกำหนดตำแหน่งของ Cursor เช่น lcd.setCursor(0, 1); คือให้เคอร์เซอร์ไปที่ ตำแหน่งที่ 0 บรรทัดที่ 1 (การนับตำแหน่งเริ่มจาก 0)
           ฟังก์ชั่น print();  ใช้ในการกำหนดข้อความที่ต้องการแสดง เช่น lcd.print("ThaiEasyElec"); คือกำหนดให้แสดงข้อความ “ThaiEasyElec” ออกทางหน้าจอ LCD
ในบทความนี้เราจะใช้เพียงฟังก์ชั่นที่กล่าวถึงด้านบน ส่วนฟังก์ชั่นอื่นๆ สามารถดูได้จาก  Arduino.cc <<< คลิกได้เลยครับ
ตัวอย่างโค้ดโปรแกรม

#include <Wire.h>
#include <LiquidCrystal_I2C.h> //ประกาศ Library ของจอ I2C
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
// initialize the LCD
lcd.begin();
// Print a message to the LCD.
lcd.print("Hello !!!"); //ฟังก์ชั่นในการกำหนดข้อความที่ต้องการแสดงผล
lcd.setCursor(0, 1); //ฟังก์ชั่นในการกำหนดตำแหน่ง Cursor
lcd.print("ThaiEasyElec");
}
void loop()
{
}

ผลลัพธ์ที่ได้ตามรูปด้านล่างนะครับ !!!!




อ้างอิง
http://www.thaieasyelec.com/article-wiki/review-product-article/การใช้งาน-character-lcd-display-กับ-arduino-ตอนที่2-รูปแบบการเชื่อมต่อแบบ-i2c.html

วันอังคารที่ 27 ธันวาคม พ.ศ. 2559

Home Alarm Systems ระบบเตือนภัยภายในบ้านควบคุมโดยบอร์ด Arduino
อุปกรณ์ที่ใช้
1. บอร์ด Arduino Uno R3 (EADN014) (บทความ Arduino) Q'ty 1 pcs

           เป็นบอร์ดไมโครคอนโทรเลอร์ตระกูล AVR ที่มีการพัฒนาแบบ Open Source คือมีการเปิดเผยข้อมูลทั้งด้าน Hardware และ Software ตัวบอร์ด Arduino ถูกออกแบบมาให้ใช้งานได้ง่าย ดังนั้นจึงเหมาะสำหรับผู้เริ่มต้นศึกษา และสามารถนำไปดัดแปลงเพิ่มเติม หรือพัฒนาต่อยอดได้อีกด้วย


2. จอ LCD Character 20x4 (EDPM045) (บทความ LCD) Q'ty 1 pcs
           จอ Liquid Crystal Display (LCD) เป็นจอแสดงผลรูปแบบหนึ่งที่นิยมนำมาใช้งานร่วมกับระบบสมองกลฝังตัวอย่างแพร่หลาย จอ LCD มีทั้งแบบแสดงผลเป็นตัวอักขระเรียกว่า Character LCD ซึ่งมีการกำหนดตัวอักษรหรืออักขระที่สามารถแสดงผลไว้อยู่แล้ว และแบบแสดงเป็นจุดเรียกว่า Graphic LCD


3. บอร์ดรีเลย์ 2 Channels (EFDV237) (บทความ Relay) Q'ty 1 pcs
           รีเลย์ (Relay) เป็นอุปกรณ์ไฟฟ้าชนิดหนึ่ง ซึ่งทำหน้าที่ตัดต่อวงจรแบบเดียวกับสวิตช์ โดยควบคุมการทำงานด้วยไฟฟ้า รีเลย์มีหลายประเภทหลายขนาด ตั้งแต่ขนาดเล็กที่ใช้ในงานอิเล็กทรอนิกส์ทั่วไป จนถึงขนาดใหญ่ที่ใช้ในงานไฟฟ้าแรงสูง โดยมีรูปร่างแตกต่างกันออกไป แต่มีหลักการทำงานที่คล้ายคลึงกัน สำหรับรีเลย์นิยมใช้ในการตัด-ต่อวงจร นอกจากนี้ยังสามารถนำไปใช้งานแบบอื่นได้หลากหลายรูปแบบ


4. Keypad 4x4 (EMSW025) Q'ty 1 pcs
           แป้นปุ่มกดหรือ Keypad เป็นอุปกรณ์สำหรับรับอินพุตจากผู้ใช้ มีลักษณะเป็นปุ่มกดหลายปุ่มจัดเรียงกันในลักษณะเป็นอาร์เรย์ แบ่งเป็นแถวแนวนอน (Row) และแถวแนวตั้ง (Column) เช่น 3x4 (12 ปุ่ม) หรือ 4x4 (16 ปุ่ม) เป็นต้น แต่ละปุ่มก็จะมีสัญลักษณ์เขียนกำกับไว้ เช่น ตัวเลข 0-9 # * A-D เป็นต้น


5. Buzzer Module (EADN028) Q'ty 1 pcs
           ลำโพงแบบ Magnetic-diaphragm ขนาดเล็กให้เสียงดัง มีความต้านทานภายในต่ำ Buzzer จะคล้ายกับลำโพงคือมันสามารถส่งเสียงได้โดยการสั่นสะเทือนที่เป็นจังหวะความถี่แล้วเกิดเป็นคลื่นเสียง


6. Flame Detector Module (EFDV309) Q'ty 1 pcs
           อุปกรณ์ตรวจจับเปลวไฟ (Flame Detector) สามารถตรวจจับเปลวไฟในขณะที่เกิดเหตุเพลิงไหม้ มักติดตั้งไว้เพื่อตรวจสอบในบริเวณที่มีวัตถุไวไฟวางอยู่


7. LED Module (EADN023) Q'ty 2 pcs
           LED (Light-Emitting Diode) หรือที่แปลเป็นไทยว่า ไดโอดเปล่งแสง หลอดไฟ LED เมื่อได้รับแรงดันไฟฟ้าจะปล่อยคลื่นแสงออกมาให้ความสว่าง หลอดไฟ LED ที่เราเห็นมีขายกันตามร้านอุปกรณ์อิเล็กทรอนิกส์นั้นมีหลายแบบ โดยแต่ละแบบนั้นจะมีหลักการทำงานเหมือนกัน


8. PIR Motion Sensor Module (ESEN071) (บทความ PIR) Q'ty 1 pcs
           อุปกรณ์ Sensor ชนิดหนึ่งที่ใช้ตรวจจับคลื่นรังสี Infrared ที่แพร่จาก มนุษย์ หรือ สัตว์ ที่มีการเคลื่อนไหว ทำให้มีการนำเอา PIR มาประยุคใช้งานกันเป็นอย่างมากใช้เพื่อตรวจจับการเคลื่อนไหวของสิ่งมีชีวิต หรือ ตรวจจับการบุกรุกในงานรักษาความปลอดภัย


9. IIC (I2C) Adaptor Plate (EFDV296) Q'ty 1 pcs
           โมดูล I2C Bus เป็นโมดูลแปลงขาสัญญาณ Parallel เป็น I2C เพื่อลดจำนวนขาสัญญาณในการใช้งานจาก 16 ขาเหลือเพียง 4 ขา ส่วนใหญ่นำมาใช้งานคู่กับจอ Character LCD เพื่อให้สะดวกต่อการเชื่อมต่อ และสามารถต่อจอแสดงผลหรืออุปกรณ์อื่นได้ในจำนวนที่มากขึ้น สามารถปรับให้รองรับได้ถึง 8 ตำแหน่งแอดเดรส (20-27) เพื่อความยืดหยุ่นในการใช้งาน


หลักการทำงาน
           ระบบจำลองการรักษาความปลอดภัยภายในบ้านนี้ จะทำงานในขณะที่ผู้ใช้งานนั้นไม่อยู่บ้านหรือล็อคบ้านไว้ ระบบนี้ประกอบไปด้วยเซ็นเซอร์ที่ทำหน้าที่ในการตรวจจับสิ่งต่างๆ เช่น การบุกรุกเข้ามาโจรกรรม การเกิดอัคคีภัย เป็นต้น
           ขณะทำงานระบบจะเปิดการตรวจจับโดยรับสัญญาณอินพุตจากเซ็นเซอร์ 2 อย่างด้วยกันคือ PIR Motion Sensor (เซ็นเซอร์ตรวจจับการเคลื่อนไหว) ในระบบจำลองนี้ จะติดเซนเซอร์ไว้ในห้องรับแขก และ Flame Detector Sensor (เซ็นเซอร์ตรวจจับเปลวไฟ) จะติดเซนเซอร์ไว้ในห้องครัว เมื่อผู้อาศัยไม่อยู่บ้านหรือล็อคบ้านไว้ PIR Motion Sensor และ Flame Detector Sensor จะทำงาน เมื่อมีการเคลื่อนไหวภายในบ้าน สัญญาณกันขโมยจะส่งเสียง Alarm แจ้งเตือนออกทาง Buzzer ทันที หรือเมื่อเกิดเปลวไฟบริเวณห้องครัว (Flame Detector Sensor จะทำงาน) และสัญญาณ Alarm ก็จะทำงานเช่นกัน
           แต่เมื่อผู้อาศัยกลับมาแล้วและปลดล็อคประตูด้วยรหัสผ่าน “1234” ตามด้วยเครื่องหมาย # ตามที่ตั้งไว้ มีผลทำให้ระบบเซนเซอร์ตรวจจับปิดการทำงาน และหลังจากปลดล็อคแล้ว ผู้อาศัยจะสามารถควบคุมการปิดเปิดเครื่องใช้ไฟฟ้าภายในบ้านได้ โดยกดปุ่มที่ Keypad (ปุ่ม A - หลอดไฟดวงที่ 1 หรือ ปุ่ม B - หลอดไฟดวงที่ 2) และเมื่อผู้อาศัยจะเข้านอน ต้องการล็อคบ้านและเปิดระบบเตือนภัย ก็สามารถทำได้โดยกดที่ Keypad (ปุ่ม C) 
           จากการทำงานของระบบนี้ เป็นเพียงการทำงานเบื้องต้นให้เห็นภาพ ผู้ใช้สามารถนำไปต่อยอดพัฒนาเพิ่มเติมได้ เช่น เชื่อมต่อกับ GSM Module เพื่อสื่อสารผ่านเครือข่ายโทรศัพท์มือถือและอินเตอร์เน็ต หรือเชื่อมต่ออุปกรณ์ LAN หรือ Wi-Fi เพิ่มเติมเพื่อสื่อสารผ่านอินเตอร์เน็ต แล้วประยุกต์การทำงานให้เกิด Alarm ให้ระบบส่ง SMS หรือโทรออกไปยังเจ้าของบ้านเพื่อเตือนภัยได้อีกด้วย
วิธีการต่อวงจร


โค้ดโปรแกรมการทำงาน การควบคุมการทำงานอุปกรณ์ต่างๆ (อ้างอิงตามบทความนี้) จำเป็นต้องมีการเรียกใช้ไลบรารี่ต่างๆ ดังต่อไปนี้คือ Password, Keypad, Wire และ LiquidCrystal_I2C 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <Password.h>
#include <Keypad.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

Password password = Password( "1234" ); // Set the Password

// Set the LCD address to 0x27 for a 20 chars and 4 line display
LiquidCrystal_I2C lcd(0x27, 20, 4);

const byte ROWS = 4;        // Four rows
const byte COLS = 4;        //  columns
const int status_lock = A0; // LED Status Pin
const int status_unlock = A1; // LED Status Pin
const int led_bed = 11;     // Home Light2 Pin
const int led_bath = 12;    // Home Light1 Pin
int pir = A2;               // PIR Sensor Pin
int flame = A3;             // Flame Sensor Pin
int Buzzer = 10;            // Buzzer Module Pin
int alarmValue = 0; 
int fl = 0, state = 0, state1 = 0, state2 = 0, Alarm_fl = 0; // Flag
int dir = 8, dir1 = 0;
String test = "                    ";
// Define the Keymap
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte rowPins[ROWS] = { 2,3,4,5, };// Connect keypad ROW0, ROW1, ROW2 and
                    // ROW3 to these Arduino pins.
byte colPins[COLS] = { 6,7,8,9 };// Connect keypad COL0, COL1, COL2 and
                        // COL3 to these Arduino pins.

// Create the Keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
ในส่วนแรกของโปรแกรมเป็นการประกาศเรียกใช้ไลบรารี่และตั้งค่า เริ่มจากกำหนด Password ในบทความนี้เป็น Password("1234" );
กำหนดค่าของจอ LCD (ในบทความนี้ ใช้จอ LCD ร่วมกับ I2C Adaptor) ต้องทำการกำหนดค่า 3 ค่า คือ ตำแหน่งแอดเดรส จำนวนตัวอักษร และจำนวนบรรทัดเป็น LiquidCrystal_I2C lcd(0x27, 20, 4);
กำหนดค่าตัวแปรต่างๆ ที่ต้องการนำไปใช้ในโปรแกรม
และสุดท้าย กำหนดขาในการนำไปใช้งานกับ Keypad โดยต้อง Mapkey ที่ต้องการใช้งานไว้ก่อนว่าเป็นแบบไหน ซึ่งในบทความนี้ใช้เป็น 4x4 Keypad พร้อมทั้งกำหนด PinRow, PinColumn หลังจากกำหนดเสร็จแล้วเรียกใช้ฟังก์ชั่นในการสร้าง Keypad จากไลบรารี่โดยนำพารามิเตอร์ที่กำหนดไว้ใส่ลงไปในฟังก์ชั่นเพื่อ Mapkey

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void setup()
{
    Serial.begin(9600); // Define Serial for Debug Sensor & Keyped
    lcd.begin();  //Define LCD
    lcd.backlight();
    pinMode(status_lock, OUTPUT);    // Sets the digital pin as output
    pinMode(status_unlock, OUTPUT);  // Sets the digital pin as output
    pinMode(led_bed, OUTPUT);        // Sets the digital pin as output
    pinMode(led_bath, OUTPUT);       // Sets the digital pin as output

    keypad.addEventListener(keypadEvent); // Add an event listener for this keypad
    // Sets First Screen LCD
     lcd.print("* Hello Welcome To *");
     lcd.setCursor(0, 1);
     lcd.print(" Home Alarm Systems ");
     lcd.setCursor(0, 2);
     lcd.print("www.ThaiEasyElec.com");
     lcd.setCursor(0, 3);
     lcd.print("  ** Home Lock **  ");
}

void loop()
{
  keypad.getKey(); // Check the Keyped
  motion_on();     // Open PIR Motion Sensor
  flame_on();      // Open Flame Detector Sensor
  close_all_power(); // Close Light1-2 and Set status_lock
}
ฟังก์ชั่น Setup เป็นการตั้งค่าหรือกำหนดการทำงานอินพุตเอาต์พุตของขาต่างๆ ดังนี้
กำหนดความเร็วในการสื่อสาร Serial เพื่อใช้ในการรับ-ส่งข้อมูลกับคอมพิวเตอร์
เรียกใช้ฟังก์ชั่นเพื่อ Initial จอ LCD ที่เรานำมาใช้งานในที่นี้เป็นการติดต่อแบบ I2C
กำหนดการทำงานของขา status_lock(A0)  status_unlock(A1)  led_bed(11)  led_bath(12) ให้เป็นโหมดเอาต์พุต
ฟังก์ชั่น Loop เรียกใช้งานฟังก์ชั่นย่อยๆ ด้วยกันทั้งหมด 4 ฟังก์ชั่น คือ
motion_on(); = เปิดการใช้งาน PIR Motion Sensor รับค่าจาก Analog A2 เพื่อตรวจสอบการเคลื่อนไหว
flame_on(); = เปิดการใช้งาน Flame Detector รับค่าจาก Analog A3 เพื่อตรวจสอบเปลวไฟ
close_all_power(); = ปิดหรือตัดไฟเครื่องใช้ไฟฟ้าที่ไม่ได้ใช้งานภายในบ้าน 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//take care of some special events
void keypadEvent(KeypadEvent eKey){
    switch (keypad.getState()){
    case PRESSED:
        //Serial.print("Pressed: ");
        //Serial.println(eKey);
        lcd.setCursor(dir1, 3);
        lcd.print(test);
        test = "*";
        lcd.setCursor(dir, 3);
        lcd.print(test);
        dir1 = dir;
        switch (eKey){
            case 'A':
                if(fl == 1){
                    if(state == 0){
                        digitalWrite(led_bed, HIGH); // Open the light 2
                        state = 1;
                    }else if(state == 1){
                        digitalWrite(led_bed, LOW); // Close the light 2
                        state = 0;
                    }
                }
                break;
            case 'B':
                if(fl == 1){
                    if(state1 == 0){
                        digitalWrite(led_bath, HIGH); // Open the light 1
                        state1 = 1;
                    }else if(state1 == 1){
                        digitalWrite(led_bath, LOW); // Close the light 1
                        state1 = 0;
                    }
                }
                break;
            case 'C':
                if(fl == 1){
                    state2 = 1;
                    lcd.setCursor(0, 3);
                    lcd.print("  ** Home Lock **  ");
                    dir  = 8;
                    dir1 = 0;
                    test = "                    ";
                }
                break;
            case '#':
                checkPassword(); // Call the function checkPassword
                password.reset(); //Reset Key
                break;
            default:
                password.append(eKey);
        }
    }
}

KeypadEvent เป็นฟังก์ชั่นตรวจสอบเหตุการณ์ของ Keypad เมื่อกดคีย์เข้ามา ใช้ในการกำหนดเหตุการณ์ให้เป็นไปตามที่เราต้องการ เช่น ถ้าทำการกดปุ่ม A ให้สั่งงาน Output ที่ขา led_bed (11) ให้อยู่ในสภาวะ HIGH(1) เป็นต้น ในบทความนี้เราได้กำหนดเหตุการณ์ไว้ด้วยกันทั้งหมด 4 เหตุการณ์ด้วยกัน คือ
1.             เมื่อกดปุ่ม # ให้นำคีย์ที่กดเข้ามาก่อนหน้าไปตรวจสอบด้วยฟังก์ชั่น checkPassword และเคลียร์ค่าคีย์ที่กดเข้ามาก่อนหน้าทั้งหมดเพื่อรอรับคีย์ใหม่
2.             เมื่อกดรหัสผ่านถูกต้องแล้ว การกดปุ่ม A หนึ่งครั้งจะเป็นการสั่งงานให้ Output1 อยู่ในสภาวะ HIGH หรือถ้ามีการกดซ้ำก็จะสั่งงาน Output1 อยู่สภาวะ LOW สลับกันไปเรื่อยๆ
3.             เมื่อกดรหัสผ่านถูกต้องแล้ว การกดปุ่ม B หนึ่งครั้งจะเป็นการสั่งงานให้ Output2 อยู่ในสภาวะ HIGH หรือถ้ามีการกดซ้ำก็จะสั่งงาน Output2 อยู่สภาวะ LOW สลับกันไปเรื่อยๆ
4.             กดปุ่ม C เมื่อต้องการล็อคบ้านหรือเปิดระบบการแจ้งเตือนขึ้นมาใหม่อีกครั้ง

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void checkPassword(){ // Function check the password
    if (password.evaluate()){
    //Add code to run if it works
        while(1){
            //Serial.println("Success");
            fl = 1;
            digitalWrite(status_lock, LOW);
            digitalWrite(status_unlock, HIGH);
            lcd.setCursor(0, 3);
            lcd.print(" ** Home Unlock ** ");
            keypad.getKey();
            Alarm_off();
            password.reset();
        }
    }else{
        Serial.println("Wrong");
        //add code to run if it did not work
        lcd.setCursor(0, 3);
        lcd.print("**Password Wrong **");
        delay(1000);
    }
}

checkPassword เป็นฟังก์ชั่นตรวจสอบ password ว่าคีย์ที่กดเข้ามานั้นตรงกับที่กำหนดไว้ข้างต้นหรือไม่ ในฟังก์ชั่นนี้เราต้องกำหนดเหตุการณ์ว่าถ้า password ถูกต้อง จะให้ทำอะไร และถ้าไม่ถูกต้องจะให้ทำอะไร เราได้กำหนดไว้แล้วในที่นี้ คือ
กรณี password ถูกต้อง ให้สั่งงาน Output ที่ขา status_lock เป็นสภาวะ LOW พร้อมทั้งสั่งงาน Output ที่ขา status_unlock เป็นสภาวะ HIGH ต่อมาให้เปลี่ยนการแสดงผลทางหน้าจอ LCD บรรทัดที่ 4 เป็น HomeUnlock และทำการวนรอรับค่าจาก Keypad อีกครั้งเพื่อใช้ในการสั่งงาน เปิด-ปิด ไฟภายในบ้าน พร้อมทั้งตัดระบบเตือนภัยทั้งหมด
กรณี password ไม่ถูกต้อง ให้ทำการกลับเริ่มต้นรับคีย์ใหม่จนกว่า password จะถูกต้อง

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void close_all_power(){ // Function close the light all.
    digitalWrite(status_lock, HIGH);
    digitalWrite(status_unlock, LOW);
    digitalWrite(led_bed, LOW);
    digitalWrite(led_bath, LOW);
}
void Alarm(){ // Function Alarm.
    tone(Buzzer, 10, 100); // Alarm at 10 Hz 100 milliseconds.
    delay(100); // delay 100 milliseconds
    tone(Buzzer, 300, 100);// Alarm at 300 Hz 100 milliseconds.
    delay(100); // delay 100 milliseconds
}
void Alarm_off(){ // Function Alarm off.
    digitalWrite(Buzzer,HIGH); //Set buzzer pin is HIGH for stop alarm
}

close_all_power เป็นฟังก์ชั่นกำหนดให้ปิดไฟทั้งหมดที่ต้องการหรือสั่งงานให้ Output ที่ต้องการ อยู่ในสภาวะ LOW ทั้งหมด
Alarm เป็นฟังก์ชั่นสั่งงานหรือกำหนดให้ buzzer ดังที่ความถี่เท่าไร นานแค่ไหน ในบทความนี้เราจะตั้งให้สลับเสียงกัน 2 เสียงเพื่อให้เหมือนกับ Alarm 2 เสียงทั่วๆ ไป เราสามารถกำหนดเพิ่มเติมหรือแก้ไข ขึ้นอยู่กับการนำไปใช้งาน
Alarm_off เป็นฟังก์ชั่นกำหนดให้ buzzer ไม่ส่งเสียงดังหรือปิด buzzer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void motion_on(){ // Function Open PIR Motion Sensor.
    alarmValue = analogRead(pir); // Read analog sensor 0-1023.
    //Serial.println (alarmValue); // Debug Sensor value.
    if(alarmValue >= 1000){ // Check the value
        Alarm();
    }
        if(alarmValue < 1000){
        Alarm_off();
    }
}
void flame_on(){ // Function Open Flame Detector Sensor.   
    alarmValue = analogRead(flame); // Read analog sensor 0-1023.
    //Serial.println (alarmValue);  // Debug Sensor value. 
    if(alarmValue <= 700){   // Check the value     
        Alarm();
    }
    if(alarmValue > 700){
        Alarm_off();
    }
}

motion _on เป็นฟังก์ชั่นเปิดใช้งาน PIR Motion Sensor การทำงานคือรับค่าที่ได้จาก Sensor มาเป็น Analog แรงดัน 0-5 V มาแปลงเป็นดิจิตอล โดยต้องบันทึกค่าไว้ก่อนว่าตอนที่ไม่มีการเคลื่อนไหวจะเท่ากับเท่าไร ในที่นี้ค่าตอนที่ไม่มีการเคลื่อนไหวอ่านได้ประมาณ 700 และเมื่อมีการเคลื่อนไหวอ่านได้ประมาณ 1000+ จึงกำหนดว่าถ้ามากกว่า 1000 แสดงว่ามีการเคลื่อนไหวให้ทำการ Alarm ทันที แต่ถ้าน้อยกว่า 1000 แสดงว่าไม่มีการเคลื่อนไหวก็ไม่ต้อง Alarm (ผู้ใช้ต้องตรวจสอบค่าที่ได้จากเซ็นเซอร์แต่ละตัวก่อนการใช้งาน เนื่องจากค่า output นั้นขึ้นอยู่กับอุปกรณ์แต่ละตัวทำให้ค่าที่ได้อาจไม่เท่ากัน)
flame_on เป็นฟังก์ชั่นเปิดการใช้งาน Flame Detector การทำงานคือรับค่าที่ได้จาก Sensor มาเป็น Analog แรงดัน 0-5 V เช่นเดียวกันกับ PIR Motion Sensor แต่ Flame Detector นั้นใช้ในการตรวจวัดแสงไฟ หรือเปลวไฟ ต้องทำการบันทึกค่าไว้ก่อนว่าตอนที่ไม่เกิดเปลวไฟจะเท่ากับเท่าไร และตอนที่เกิดเปลวไฟนั้นมีค่าเท่าไร ในที่นี้ค่าตอนยังไม่มีเปลวไฟ ค่าที่ได้ประมาณ 800+ และเมื่อเกิดเปลวไฟค่าที่ได้ลดลงเหลือประมาณ 500+ แต่ไม่เกิน 700 จึงกำหนดว่าถ้าน้อยกว่า 700 แสดงว่ามีเปลวไฟเกิดขึ้นให้ทำการ Alarm ทันที แต่ถ้ามากกว่า 700 แสดงว่าไม่มีเปลวไฟเกิดขึ้นก็ไม่ต้อง Alarm  (เช่นเดียวกับ PIR Motion Sensor ผู้ใช้ต้องตรวจสอบค่าที่ได้จากเซ็นเซอร์แต่ละตัวก่อนการใช้งาน  เนื่องจากค่า output นั้นขึ้นอยู่กับอุปกรณ์แต่ละตัวทำให้ค่าที่ได้อาจไม่เท่ากัน)
         หากสนใจจะต่อขยายเพิ่มเติมสามารถนำไปต่อกับ GSM โมดูล แล้วเมื่อเกิด Alarm ให้ส่ง SMS หรือโทรออกไปแจ้งผู้อาศัยได้ สามารถหาข้อมูลเพิ่มเติมและประยุกต์ใช้ได้จากบทความด้านล่างครับ



อ้างอิง
http://www.thaieasyelec.com/article-wiki/embedded-electronics-application/home-alarm-systems-control-by-arduino.html