Category: Raspberry Pi

ตอนที่แล้วเราได้ทดลองทำการสั่งงานรีเลย์แบบ Manual ผ่านหน้าเว็บไปแล้ว

ครั้งนี้เราลองสั่งให้รีเลย์ทำงานโดยผ่านการประมวลผลค่าที่ได้จากเซนเซอร์ เพื่อให้ก้าวไปอีกขั้นของ IoT

 

โดยเราจะใช้เซนเซอร์ที่เคยได้นำเสนอไปก่อนหน้านี้แล้ว นั่นคือ DHT22 Temperature & Humidity Sensor (ต่อที่ PIN: 32 [GPIO 12])
และรีเลย์ 4 Channel ซึ่งสามารถนำไปต่อกับอุปกรณ์เครื่องใช้ไฟฟ้าได้ ต่อ PIN เดิมจากตอนที่แล้ว

 

ความต้องการเบื้องต้นคือ
1. เมื่ออุณหภูมิต่ำกว่าหรือเท่ากับ 28 องศา ให้เปิดพัดลมระบายอากาศ 1 (ที่ต่ออยู่กับ Relay 1)
2. เมื่ออุณหภูมิสูงกว่า 28 องศา ให้ปิดพัดลมระบายอากาศ 1 และเปิดพัดลมระบายอากาศ 2 (ต่ออยู่กับ Relay 2)
3. เมื่อความชื้นต่ำกว่า 50% ให้เปิดเครื่องสร้างความชื้น (Humidifier) (ต่ออยู่กับ Relay 3)  โดยไม่ต้องสนใจอุณหภูมิ

เริ่มเขียนโค้ดเพื่อทำการประมวลผลกันเลย (โค้ดบางส่วน ได้อธิบายไว้ในตัวอย่างบทความก่อนหน้านี้แล้ว)

 

ทำการติดตั้ง Library Adafruit จากบทความก่อนหน้านี้ Raspberry Pi 3 [Temperature & Humidity Sensor]

จากนั้นทำการเขียน python ด้วยคำสั่ง

sudo nano automated_relay.py

ด้วยโค้ดต่อไปนี้

 

import os
import time
import datetime

while True :
 temperature = os.popen(‘sudo /home/pi/sources/Adafruit_Python_DHT/examples/AdafruitDHT.py 2302 12 | cut -c 6-7’).read()
 humidity = os.popen(‘sudo /home/pi/sources/Adafruit_Python_DHT/examples/AdafruitDHT.py 2302 12 | cut -c 22-23’).read()
 now = datetime.datetime.now()

 print ”
 print ”
 print now.strftime(“%d-%m-%Y %H:%M:%S”)
 print ‘Temperature: ‘ + temperature + ‘Humidity: ‘ + humidity

 if int(temperature) <= 28:
  os.popen(‘sudo python /var/www/html/relay_off.py 2’).read()
  os.popen(‘sudo python /var/www/html/relay_on.py 1’).read()
  print ‘Temperature below 28C ==> Relay 1: ON. Relay 2: OFF’
 else:
  os.popen(‘sudo python /var/www/html/relay_off.py 1’).read()
  os.popen(‘sudo python /var/www/html/relay_on.py 2’).read()
  print ‘Temperature above 28C ==> Relay 1: OFF. Relay 2: ON’

 if int(humidity) < 50:
  os.popen(‘sudo python /var/www/html/relay_on.py 3’).read()
  print ‘Humidity below 50% ==> Relay 3: ON’
 else:
  os.popen(‘sudo python /var/www/html/relay_off.py 3’).read()
  print ‘Humidity above 50% ==> Relay 3: OFF’

 time.sleep(5)

 

 

จากนั้นเซฟและทดลองรันด้วยคำสั่ง python automated_relay.py

พบว่ารีเลย์ทำงานได้ตามต้องการและได้ผลดังรูปนี้

จากรูปด้านบน เมื่ออุณหภูมิอยู่ที่ 24 องศา ความชื้น 48% จะทำการ ON Relay 1 และ OFF Relay 2 และ ON Relay 3
จากนั้นทำการรอไป 5 วินาที จากนั้นจึงอ่านค่าใหม่ วนแบบนี้เรื่อยๆ
และเมื่อความชื้นสูงกว่า 50% ก็จะทำการ OFF Relay 3 ขึ้นมา โดยไม่ได้สนใจอุณหภูมิ
จากนั้นเมื่ออุณหภูมิสูงกว่า 28 องศา ก็จะทำการ OFF Relay 1 และ ON Relay 2 ตามโปรแกรมที่เราเขียนเอาไว้

 

โปรแกรมด้านบนนี้ เป็นโปรแกรมอย่างง่าย ซึ่งอาจจะมีข้อบกพร่อง (bug) อยู่หลายประการ เช่นการ initial state ของ relay ตอนเริ่มต้น, การแสดงผลบนหน้าจอ เป็นต้น
โดยท่านที่สนใจ สามารถนำไปปรับปรุงต่อได้ด้วยตัวเองครับ ผมต้องการเพียงเพื่อจะชี้ให้เห็นถึง concept การทำงานเท่านั้น

 

การนำไปประยุกต์ใช้ ขึ้นอยู่กับความต้องการเป็นหลัก ซึ่งมีเซนเซอร์ให้เลือกใช้มากมาย เช่น

• หากเราต้องการให้เปิดไฟเมื่อมีคนเดินผ่าน เราสามารถใช้ Passive Infrared Sensor (PIR) มาจับความเคลื่อนไหวและความร้อนของวัตถุ (จากรังสี Infrared ที่ปล่อยออกมา) และนำไป Trig Relay ได้ทันที
• ระบบรดน้ำอัตโนมัติ เมื่ออุณหภูมิหรือความชื้นหรือเวลา ตรงกับเงื่อนไขที่เราตั้งไว้ ให้ Trig Relay ที่ต่อกับ Solinoid Valve (วาล์วน้ำไฟฟ้า ที่จะเปิดเมื่อมีไฟไหลผ่าน) เพื่อรดน้ำต้นไม้
• ระบบระบายความร้อน หรือ HVAC ที่จะทำงานตามเงื่อนไขอุณหภูมิและความชื้น โดยสามารถโปรแกรมให้มีการเปรียบเทียบอุณหภูมิจากภายในและภายนอก ให้พัดลมระบายอากาศทำงานตามที่กำหนด
• ฯลฯ

 

จากบทความเรื่อง Raspberry PI ทั้งหมดที่เขียนมา จะเห็นว่าเป็นเรื่องเกี่ยวกับการเล่นกับอุปกรณ์ Input/output เท่านั้น ซึ่งแท้จริงๆแล้ว Raspberry PI นั้นมีความสามารถมากกว่านี้อีกเยอะ ซึ่งหากว่าท่านต้องการทำแค่ระบบ Automation หรือ IoT ในบ้านง่ายๆ ยังมี Solution อื่น ที่ประหยัดงบประมาณมากกว่านี้คือการเลือกใช้ Arduino Board ซึ่งจะเป็นการทำงานแบบ Microcontroller เข้ามาทำงานในส่วนประมวลผลง่ายๆ ไม่ซับซ้อน ที่สำคัญหรือราคาถูกกว่าครึ่ง (เฉพาะบอร์ด)

 

ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

ขอบคุณครับ

 

 

 

 

 

 

ตอนนี้เราจะมาสร้างหน้าเว็บสำหรับดูสถานะและควบคุมรีเลย์อย่างง่ายๆ

 

ก่อนอื่น ผมได้ทำการเปลี่ยน PIN ของ GPIO บน Raspberry Pi 3 เพื่อให้เป็นระเบียบมากขึ้นจากครั้งที่แล้ว
โดยผมได้เลือกใช้ PIN: 12 (GPIO 18), PIN: 16 (GPIO 23), PIN: 18 (GPIO 24) และ PIN: 22 (GPIO 25) สำหรับสั่งงานรีเลย์ตัวที่ 1-4 ตามลำดับ ดังรูปด้านล่างนี้

 

หลังจากการทดสอบการทำงานของรีเลย์ทุกตัว (ในบทความที่แล้ว) จากนั้นเราจึงเริ่มขึ้นตอนการติดตั้ง Apache Web Server, PHP และเขียนหน้าเว็บ ดังขั้นตอนต่อไปนี้ครับ

 

ติดตั้ง Apache Web Server และ PHP ดังนี้

ใช้คำสั่ง sudo apt-get install apache2 เพื่อติดต้ัง apache web server

(หากขึ้นว่า Package apache2 is not available ให้ใช้คำสั่ง sudo nano /etc/apt/sources.list  จากนั้น uncomment บันทัดสุดท้าย เซฟไฟล์และใช้คำสั่ง sudo apt-get update เมื่อเรียบร้อยแล้วให้ลองใช้คำสั่งด้านบนอีกครั้ง)

จากนั้นทดสอบเปิดเว็บด้วย

http://localhost/ หรือ http://{RASPBERRY_IP}/

 

จากนั้นติดตั้ง PHP5 Module สำหรับ Apache

sudo apt-get install php libapache2-mod-php

 

เมื่อเรียบร้อยแล้ว ให้ใช้คำสั่งต่อไปนี้

cd /var/www/html

เนื่องจากไฟล์ index.html จะมีเจ้าของเป็น root ทำให้ไม่สามารถแก้ไขหรือลบได้ ให้ใช้คำสั่งเปลี่ยน owner ดังนี้

sudo chown pi: index.html

จากนั้นทำการลบไฟล์ index.html เพราะเราไม่ใช้

ใช้คำสั่ง sudo nano index.php เพื่อสร้างไฟล์และเขียนโค้ดต่อไปนี้ เพื่อทดสอบการทำงานของ php

<?php phpinfo(); ?>

และลองเปิดหน้าเว็บดู จะพบกับหน้านี้ ถือว่าติดตั้งเสร็จเรียบร้อยแล้ว

 

จากนั้นเพิ่ม user ของ apache นั่นคือ www-data ให้สามารถใช้คำสั่ง sudo ได้ ด้วยวิธีการต่อไปนี้

sudo nano /etc/sudoers

จากนั้นเพิ่มบันทัดต่อไปนี้ลงไปท้ายสุด

www-data ALL=(ALL) NOPASSWD: ALL

และเพื่อความสะดวก ทุกท่านสามารถดาวน์โหลดไฟล์ที่ผมได้ทำเอาไว้แล้ว ==> relay_control_via_web.zip
(สามารถแก้ไขรูปแบบการแสดงผลให้สวยงามขึ้นได้ในภายหลังได้ด้วยตัวท่านเอง) และทำการ copy file ไปไว้ที่ /var/www/html

 

โดยหลักการทำงานคือ

เมื่อมีการเปิดหน้าเว็บขึ้นมา จะเรียกไฟล์ index.html และจะทำการ post ajax firstcheck.php เพื่อทำการตรวจสอบสถานะของรีเลย์ (ซึ่งภายใน firstcheck.php จะเป็นการเรียกคำสั่ง python firstcheck.py และส่งค่ากลับเป็น json)

เมื่อมีการสั่งงานรีเลย์ จะทำการ post ajax changestate.php โดยที่ไปเรียกคำสั่ง relay_off หรือ relay_on (มี parameter คือชุดของรีเลย์ ที่ได้ทำการเซฟค่า BCM GPIO ID เอาไว้ในไฟล์ .py ดังกล่าวแล้ว) เพื่อเป็นการสั่งให้รีเลย์ดังกล่าว ทำงาน

(เพื่อความปลอดภัย ในกรณีที่ท่านต้องการแยกไฟล์ .py ออกจาก web root directory /var/www/html ท่านสามารถทำได้ โดยท่านจะต้องทำการแก้ไขไฟล์ .php ให้เรียก path ที่ถูกต้อง – และตรวจสอบ permission execute ของไฟล์สำหรับ user: www-data ด้วย)

 

ทดสอบลองเปิดหน้าเว็บ
(เว็บถูกพัฒนาขึ้นด้วย bootstrap ดังนั้น จะสามารถใช้งานผ่านหน้าจอมือถือได้ทันที เพียงเรียก http://RASPBERRY_IP/)

         
ทดสอบการแสดงผลและการสั่งงานบน Google Chrome ทั้งบน iOS และ PC

 

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

 

ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

ขอบคุณครับ

จากตอนที่แล้ว เราได้ลองต่อเซนเซอร์ภายนอก ซึ่งเซนเซอร์จะเป็นประเภท Input เพื่อนำข้อมูลไปประมวลผลต่อตามที่เราต้องการ

ยังมีอุปกรณ์บางตัวที่เราสามารถต่อเป็น Output จาก Raspberry Pi ได้ด้วย

ซึ่งหนึ่งในนั้นจะเป็นอุปกรณ์หลักที่นำมาเชื่อมต่อกับอุปกรณ์อื่นๆ ได้อย่างหลากหลาย นั่นคือ รีเลย์ (Relay) – (ไม่ใช่ Delay นะครับ กรุณาอย่าสับสน)

 

Relay คืออะไร

Relay ถ้าให้พูดจากความเข้าใจคือ สวิตซ์ ประเภทหนึ่งครับ ที่จะทำงานตามกระแสไฟ นั่นคือ เมื่อมีกระแสไฟไปเหนี่ยวนำภายใน สวิตซ์ก็จะทำงาน (Energize)
(พูดให้เข้าใจอีกครั้งหนึ่งคือ เหมือนสวิตซ์ตามผนังนี่แหละครับ แต่แทนที่จะเอามือไปกด เราก็ใช้กระแสไฟเข้าไปให้มันทำงานแทนนั่นเอง)
และในบางครั้ง ในระบบไฟฟ้ากำลัง อาจจะเรียกอุปกรณ์นี้ว่า Magnetic Contactor ซึ่งเป็นหลักการทำงานแบบเดียวกันครับ

(ขออภัย หากรูปจะไม่ถูกต้องตามหลักการเป๊ะๆ เพราะวาดจากความเข้าใจ)

จากในรูปด้านบนนี้
DC+, DC- คือ ไฟที่เราจะจ่ายให้ขดลวดแม่เหล็ก (ตาม spec ของ relay) เพื่อจะไปทำให้สวิตซ์ Relay ทำงาน
โดยที่ขา
C = Common ขาที่ต้องการให้กระแสไฟมารออยู่ หรือ กระแสไหลกลับ
NC = Normal Close เมื่อไม่มีไฟจ่ายที่ขดลวดแม่เหล็ก ขา C และ NC จะเชื่อมต่อถึงกันอยู่
NO = Normal Open จะทำงานเมื่อมีไฟจ่ายมาที่ขดลวดแม่เหล็ก จะทำให้ขา C และ NO นั้น เชื่อมถึงกัน และทำให้ขา C ขาดการเชื่อมกับ NC

วิธีการอ่านสเปครีเลย์ (ตัวสี่เหลี่ยมสีน้ำเงินในรูปด้านบน)
– 5VDC คือไฟที่เราจ่ายเพื่อให้รีเลย์ทำงาน (Energize)
– 10A 250VAC คือ หน้าคอนแทคทนกระแสได้ 10A ที่ 250V AC
– 15A 125VAC คือ หน้าคอนแทคทนกระแสได้ 15A ที่ 125V AC

 

รีเลย์ที่จะเอามาใช้กับ Raspberry Pi ควรจะเป็นรีเลย์ที่ทำงานด้วยไฟ 5V เพราะจะได้ต่อ +5V และ GND ออกจากบอร์ดของ Raspberry Pi ได้เลย ซึ่งรีเลย์ก็จะมีด้วยกันสองแบบคือ Active Low และ Active High นั่นคือ…

– Active Low รีเลย์จะทำงานเมื่อมีการจ่าย Logic Low เข้ามา (จ่าย GND เข้ามา)
– Active High รีเลย์จะทำงานเมื่อมีการจ่าย Logic High เข้ามา (จ่าย +5V เข้ามา)

รีเลย์บางรุ่นรองรับทั้งสองแบบ แต่จะมี Jumper ให้เซ็ตว่าต้องการทำงานในแบบไหน

 

** ถ้าหากไม่รู้จริงๆ ก็ลองเขียนโปรแกรมตามด้านล่าง เพื่อทดสอบได้ครับ ไม่พัง จ่ายผิด รีเลย์ก็แค่ไม่ทำงานครับ **

** รุ่นที่ผมนำเอามาใช้งาน จะเป็น Active Low นั่นคือจ่าย GND หรือ Logic 0 (เลขศูนย์) เพื่อให้รีเลย์ทำงาน **

 

การเชื่อมต่อนั้นไม่ยากครับ

GND ต่อกับ GND ของ Raspberry Pi
VCC ต่อกับ +5V ของ Raspberry Pi
IN1…4 ต่อกับ GPIO ขาที่ว่างอยู่ โดยดูจาก Pinout ของ Raspberry Pi ครับ

โดยผมเลือกที่จะเชื่อมต่อขาของ Raspberry Pi ดังนี้

ขาที่ [2] เพื่อจ่าย +5V ให้กับรีเลย์
ขาที่ [6] เพื่อจ่าย GND
ขาที่ [29] GPIO 5 เพื่อควบคุม Relay 1
ขาที่ [31] GPIO 6 เพื่อควบคุม Relay 2
ขาที่ [33] GPIO 13 เพื่อควบคุม Relay 3
ขาที่ [37] GPIO 26 เพื่อควบคุม Relay 4

** ไม่จำเป็นต้องต่อให้ครบ ต่อเท่าที่ใช้ก็ได้ **
** ในตลาด มีรีเลย์หลายรุ่นทั้งแบบ 1 ตัว, 4 ตัว, 8 ตัว, 16 ตัว ให้เลือกใช้ตามความต้องการได้เลยครับ **

 

เมื่อเชื่อมต่อเรียบร้อยแล้ว ก็ Power ON ตัว Raspberry Pi ขึ้นมาเลยครับ จากนั้นลองเขียน Python สั่งงานดู ตามด้านล่างนี้เลยครับ

เปิด Terminal จากนั้นใช้คำสั่ง

mkdir projects/relay

cd projects/relay

sudo nano test_cycle.py

เราจะมาลองเขียนให้ on relay 1 ถึง 4 จากนั้นตามด้วย off relay 1 ถึง 4 เพื่อเป็นการทดสอบ Logic ว่ารีเลย์ทำงาน ดังนี้ครับ

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

pins = [5, 6, 13, 26] #เป็น array
GPIO.setup(pins, GPIO.OUT, initial = GPIO.HIGH)

time.sleep(1)

for pin in pins :
 GPIO.output(pin,  GPIO.HIGH)
 print(“PIN: ” + str(pin) + ” is 1 (GPIO.HIGH)”)
 time.sleep(5)
 GPIO.output(pin,  GPIO.LOW)
        print(“PIN: ” + str(pin) + ” is 0 (GPIO.LOW)”)
        time.sleep(5)

GPIO.cleanup()
print “Cleaned up relays”

อธิบายโค้ดคร่าวๆ ดังนี้

GPIO.setmode(GPIO.BCM) #มีสองแบบคือ GPIO.BCM ใช้ GPIO ID และ GPIO.BOARD ใช้ PIN NUMBER

GPIO.setwarnings(False) #เพื่อไม่ให้ show warning ของ relay เช่น สถานะเก่าค้างอยู่ เป็นต้น

pins = [5, 6, 13, 26] #เป็น array ตาม setmode

GPIO.setup(pins, GPIO.OUT, initial = GPIO.HIGH) #เซ็ตอัพ pins ให้เป็นการทำงานแบบ output (เนื่องจาก gpio สามารถเป็นได้ทั้ง input และ output) และ relay ที่เรามาต่อเป็น Active LOW ซึ่งทำงานเมื่อจ่าย GPIO.LOW หรือ Logic 0 จึงเซ็ตค่าเริ่มต้นเป็น HIGH เอาไว้ไม่ให้ทำงานตอน setup (สามารถใช้ 1 แทน GPIO.HIGH ได้)

GPIO.output(pin,  GPIO.LOW) #คือการสั่งจ่าย GPIO.LOW หรือ Logic 0 ให้กับ pin ที่เราต้องการ เพื่อให้ทำงาน (Energize)

 

จากนั้นทดลองรัน ด้วยคำสั่ง python cycle.py

    

ในระหว่างการทำงาน จะเห็นว่าเมื่อมีการจ่าย GPIO.HIGH หรือ Logic 1 ให้กับรีเลย์ จะไม่เกิดการเปลี่ยนแปลงใดๆ
และเมื่อจ่าย GPIO.LOW หรือ Logic 0 ให้กับรีเลย์ จะได้ยินเสียงรีเลย์ทำงาน และเห็นว่าไฟสถานะ LED ติดขึ้น

 

เมื่อรีเลย์ทำงานแล้ว เราสามารถนำ Terminal ของ Relay ไปควบคุมอุปกรณ์ไฟฟ้าได้ (ตามพิกัดกระแสไฟสูงสุดของรีเลย์)
** การทำงานอุปกรณ์ไฟฟ้า (ถึงแม้จะเป็นไฟ 220V แรงต่ำ) ควรใช้ความระมัดระวัง **
** ควรทำการตัดกระแสไฟก่อนทุกครั้ง เพื่อความปลอดภัยของตัวท่านเอง **

 

วิธีการตรวจสอบช่องต่อของรีเลย์
สามารถดูได้จากสัญลักษณ์ ทำให้เรารู้ว่าขาไหนคือ COM, NC หรือ NO (รีเลย์แต่ละตัวจะมี 3 ขา ส่วนใหญ่จะวาง pattern เหมือนกัน เพราะฉะนั้น หาขาแค่ตัวเดียวก็พอครับ)
หรือจะใช้มัลติมิเตอร์วัด เพื่อความมั่นใจ โดยใช้วิธีการดังนี้

เพื่อความเข้าใจที่ตรงกัน ผมขอให้ขาที่ [1] คือขาด้านบน (ของรีเลย์แต่ละตัว) ขาที่ [2] คือ ขาตรงกลาง และขาที่ [3] คือขาด้านล่าง ตามในรูปครับ

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

 

2.ทดสอบเอาปลายโพรบแตะขาที่ [2] [3] พบว่ามีความต้านทานเป็น 0 นั่นหมายถึงว่า สองช่องนี้ติดต่อกันได้ นั่นคือขา [2] และ [3] ทำงานแบบ NC

 

3.ทำการ Energize Relay ตัวที่เราวัดขึ้นมา เพื่อหาขา COM และ NO จากในรูปด้านบนนี้ เห็นว่าขาที่เราเคยวัด [2] และ [3] กลายเป็น Open ไปแล้ว (นั่นคือ ขาทั้งสองไม่แตะกัน – ในรูปที่มัลติมิเตอร์ จะมีมีตัว M (Mega) ขึ้นมา นั่นคือความต้านทานเป็นล้านโอห์ม ซึ่งไม่สามารถวัดได้)

 

4.Energize Relay ทิ้งเอาไว้แบบนั้น เปลี่ยนขาวัดเป็นขา [1] และ [2] ปรากฎว่าความต้านทานเป็น 0 นั่นคือ สองช่องนี้ ไฟสามารถเดินผ่านไปได้

 

จะเห็นว่าขาที่ใช้ร่วมกันเมื่อรีเลย์ทำงานและไม่ทำงานนั่นคือขาที่ [2] ทำให้ขาที่ [2] คือขา COM นั่นเอง และขา [1] ก็คือขา NO และขา [3] ก็คือ NC ครับ
เมื่อเราได้ขามาแล้ว ก็ขึ้นอยู่กับการนำไปประยุกต์ใช้งาน ซึ่งส่วนใหญ่จะทำการต่อขาแบบ COM กับ NO ครับ

 

โดยจะมีเฉพาะเส้น L (Line) เท่านั้น ที่จะผ่านสวิตซ์รีเลย์ ส่วนสาย N (Neutral) สามารถต่อเข้าโหลดได้เลย ซึ่งโหลดอาจจะเป็นหลอดไฟ พัดลม หรือเครื่องใช้ไฟฟ้าอื่นๆ ในพิกัดกระแสที่รีเลย์รับได้

 

ผิดพลาดประการใด ขออภัยมา ณ ที่นี้ครับ

ป.ล. การสั่งงานแบบผ่าน command line ก็ไม่สะดวกนัก สำหรับตอนหน้า จะเป็นการสั่งงาน relay ผ่านทาง web interface และรีโมทเข้ามาผ่านทาง port 80 ได้ด้วยครับ

 

จากตอนที่แล้ว เราได้เขียนคำสั่งเพื่อที่จะดึงค่าจากเซนเซอร์แล้ว

ครั้งนี้จะเป็นการใช้วิธีดังค่าดังกล่าว มาเก็บไว้เป็นไฟล์ csv จากนั้นนำไปแสดงเป็นกราฟ โดยแสดงผลผ่าน Web Interface

ด้วยวิธีดังต่อไปนี้ครับ

 

สร้างที่เก็บไฟล์ด้วยคำสั่งต่อไปนี้

mkdir –p /home/pi/projects/temp–and–humidity
mkdir –p /home/pi/projects/temp–and–humidity/sensor–values
cd /home/pi/projects/temp–and–humidity

(หากใครไม่ต้องการสร้าง directory เพื่อเก็บข้อมูลตามตัวอย่างนี้ ให้แก้ไฟล์ temp_hud_csv_log.py ด้วยครับ)

จากนั้นดาวน์โหลดสคริปด้วยคำสั่งนี้

wget https://sysadmin.psu.ac.th/wp-content/uploads/2018/03/temp_hud_csv_log.txt
mv temp_hud_csv_log.txt temp_hud_csv_log.py

(เนื่องจาก sysadmin นี้ไม่รองรับการอัพโหลดไฟล์ .py จึงต้องอัพโหลดเป็น .txt ไปก่อน แล้วค่อยเอามา rename เอาเอง)

 

ตรวจสอบและติดตั้ง dependencies ด้วยคำสั่งนี้ sudo easy_install apscheduler และรอจนเสร็จ

      

 

โดยค่า default สคริปนี้จะถูกเซ็ตให้เป็นเซนเซอร์ AM2302 และใช้ GPIO 4 ซึ่งถ้าหากเราใช้เซนเซอร์และขาคนละขากัน ให้เข้าไปแก้ไฟล์ temp_hud_csv_log.py

จากนั้นเริ่มต้นการทำงานด้วยคำสั่ง sudo python temp_hud_csv_log.py

รอซัก 2-3 นาที เราจะเห็นว่ามีไฟล์เกิดขึ้นใน sub folder ชื่อ sensor-values

 

ต่อไปเราจะทำการอ่านค่าใน csv files ไปแสดงผลเป็นกราฟด้วย NVD3 charts for d3.js ใช้งานร่วมกับ node.js JavaScript ซึ่งรวมเว็บเซอร์เวอร์ node.js Express เอาไว้ในตัว (ซึ่ง node.js ได้ถูกติดตั้งเป็น official ใน raspberry pi image os file ซึ่งสามารถเช็คเวอร์ชั่นได้จากคำสั่ง node –version)

 

ทำการดาวน์โหลด html file ใส่ไว้ในโฟลเดอร์ย่อย public ด้วยคำสั่งต่อไปนี้

mkdir –p /home/pi/projects/temp–and–humidity/public
cd /home/pi/projects/temp–and–humidity/public
wget https://sysadmin.psu.ac.th/wp-content/uploads/2018/03/index.txt
mv index.txt index.html

ท่านสามารถแก้ไขไฟล์ index.html ได้ ไม่ว่าจะเป็น Title, DateTime Format, สีตัวอักษร, สีพื้นหลัง และอื่นๆ ได้เลย

 

จากนั้นติดตั้ง node.js script ด้วยคำสั่งต่อไปนี้

cd /home/pi/projects/temp–and–humidity
wget https://sysadmin.psu.ac.th/wp-content/uploads/2018/03/nodejs_webserver_soapws.txt
mv nodejs_webserver_soapws.txt nodejs_webserver_soapws.js

 

และทำการติดตั้ง dependencies ของ node.js ด้วยคำสั่งต่อไปนี้

npm install express
npm install body–parser
npm install csv–parse@1.1.0
npm install glob

** ถ้ามีปัญหาในการเรียก npm เช่น command not found. ให้ติดตั้งด้วยคำสั่ง sudo apt-get install npm ได้เลย **
 ** เป็นการติดตั้งใน home folder ของตัวเอง เพราะงั้นไม่ต้องใช้ sudo นำหน้า npm ครับ **
** csv-parse ผมใช้เป็นเวอร์ชั่น 1.1.0 เนื่องจากเวอร์ชั่นใหม่ ลองคอมไพล์แล้วไม่ผ่าน **

 

เมื่อเรียบร้อยแล้วลอง start web server service ด้วยคำสั่ง sudo node nodejs–webserver–with–soap–services.js

และลองเปิดเว็บด้วย http://[ไอพีของ Raspberry Pi]:9999/

** รูปนี้ผมเปิดจาก gui บน raspberry pi เลย จึงใช้ 127.0.0.1 **

 

จากนั้นทำการแก้ไขให้รันสคริปอัตโนมัติเมื่อ boot ขึ้นมา

ติดตั้ง forever เพื่อให้รัน background ด้วยคำสั่ง sudo npm –g install forever

จากนั้นแก้ไขไฟล์ /etc/rc.local ด้วยคำสั่ง sudo nano /etc/rc.local และเพิ่มบันทัดเหล่านี้ลงไป

cd /home/pi/projects/temp–and–humidity

/usr/bin/sudo /usr/bin/python temp_hud_csv_log.py & /usr/bin/sudo /usr/local/bin/forever start nodejs_webserver_soapws.js

 

เรียบร้อยครับ นอกนั้นจะเป็นการแก้ไข gui ซึ่งสามารถแก้เป็น html syntax ที่ไฟล์ index.html ได้เลย

ในตัวอย่างด้านล่างนี้ ลองทิ้งไว้ 2-3 วัน (รวมเสาร์/อาทิตย์) จากนั้นเปิดกราฟดู จะเห็นว่าเป็นกราฟเริ่มมีข้อมูลเยอะแล้ว

(ในตัวอย่าง เริ่มเก็บ 9 มีนาคม 13.54 น. – 12 มีนาคม 12.56 น.)

 

เมื่อเอาเมาส์ไปชี้ที่กราฟ จะปรากฎค่านั้นๆ ด้วย

 

และเมื่อลองเลือกช่วงวันดู จะปรากฎเป็นดังนี้

วันที่ 10 มีนาคม ความชื้นจะลดลงในช่วงกลางวัน ตั้งแต่ประมาณ 7.15 น. เป็นต้นไป
ซึ่งสวนทางกับอุณหภูมิที่เพิ่มขึ้นจาก 27.9 องศา ไปสูงสุดที่ประมาณ 32 องศา

วันที่ 12 มีนาคม (วันทำงาน) พบว่าอุณหภูมิและความชื้นลดลงอย่างรวดเร็วเมื่อเปิดแอร์ ที่เวลาประมาณ 8.45 น.
จากนั้นจะสวิงตามรอบการทำงานของคอมเพรสเซอร์แอร์ (แอร์ธรรมดา มิใช่ inverter แต่อย่างใด) ระหว่าง 22.4 – 25 องศา

 

ผิดพลาดประการใดขออภัยมา ณ โอกาสนี้ครับ ขอบคุณครับ

 

 

สวัสดีและขออภัยที่ห่างหายไป เนื่องจากติดภารกิจทั้งงานราษฏร์และงานหลวงครับ

 

ครั้งนี้จะเป็นการเริ่มต่อเซนเซอร์ภายนอก เซนเซอร์พื้นฐานที่มีในปัจจุบันก็จะเป็นเซนเซอร์เกี่ยวกับสภาพแวดล้อม ไม่ว่าจะเป็น เซนเซอร์อุณหภูมิ, เซนเซอร์ความชื้นในอากาศ, เซนเซอร์ความชื้นในดิน, เซนเซอร์น้ำ (ทำงานเมื่อมีน้ำมาสัมผัสเซนเซอร์ – ใช้ตรวจเช็คฝนตก), เซนเซอร์แสง (สวิตซ์), เซนเซอร์ความเข้มแสง, เซนเซอร์วัด pH, เซนเซอร์ UV, เซนเซอร์วัดฝุ่นละอองในอากาศ, เซนเซอร์วัดความชื้นในดิน, เซนเซอร์วัดแรงสั่นสะเทือน และเซนเซอร์อื่นๆ อีกมากมาย ซึ่งหลักการทำงานนั้นส่วนใหญ่จะเหมือนกันหมด คือการอ่านค่ามาจากเซนเซอร์ และนำค่านั้นมาแปรผลที่เราสามารถอ่านได้ง่าย

 

บทความนี้จะเริ่มด้วยเซนเซอร์ที่ Basic ที่สุด เพื่อให้ทุกท่านพอจะได้เห็นหลักการทำงานและเป็นแนวทางในการเชื่อมต่อเซนเซอร์อ่นๆ ต่อไปครับ นั่นคือ เซนเซอร์วัดอุณหภูมิและความชื้น AM2302 (DHT22) นั่นเอง

โดยจะมี Pinout ดังนี้ (จากซ้ายบน คือขาที่ 1)
ขาที่ 1 คือ VCC รองรับ 3.6-6V
ขาที่ 2 คือ Data
ขาที่ 3 คือ NC (Normal Close)
ขาที่ 4 คือ GND

เราจะต้องทำการต่อ R (Resistor) ด้วย 4.7KOhm ระหว่างขา Data และ VCC ไว้เพื่อป้องกันการรับ/ส่ง ข้อมูลผิดพลาด

ดังรูปนี้

ซึ่งถ้าเกิดเราเอามาต่อกันภายนอก จะทำให้เกิดความไม่สวยงามแยะยุ่งยาก จึงขอแนะนำเป็นอุปกรณ์ที่ Built-In R ลงในบอร์ดเลย ดังตามที่กำลังจะนำเสนอให้ดูนี้

จากนั้นเราทำการต่อสาย ซึ่งผมใช้ Jump Wire ตัวเมียทั้งสองฝั่ง เพื่อสะดวกในการต่อเข้ากับ GPIO ของ Raspberry Pi และเพื่ออนาคตสามารถปรับเปลี่ยนได้ง่าย

** เนื่องจากมีแค่ 3 เส้น จึงไม่ได้เน้นว่ามีแดงต้องเป็น +5V, สีดำต้องเป็น GND แค่เสียบให้ถูกทั้งต้นและปลาย ก็พอแล้วครับ **

 

จากนั้นทำการเสียบเข้าบอร์ด โดยดูจาก Diagram และผมเลือกต่อเข้าช่อง GPIO 4 (ขาที่ 7 – สายสีแดง ในรูป)

ทำการประกอบลง Enclosure (ไม่จำเป็น) เพื่อความเป็นระเบียบเรียบร้อยเท่าที่จะทำได้ จากนั้นทำการต่อสายและ Boot เครื่องครับ

 

จากนั้นมาในส่วนของโปรแกรมกันครับ

เริ่มทำการเขียน Python อย่างง่าย เพื่อที่จะดึงค่าอุณหภูมิและความชื้นมาแสดงบนหน้าจอ ดังนี้ครับ

 

ทำการอัพเดทระบบด้วยคำสั่ง sudo apt-get update -y

 

จากนั้นติดตั้ง dependency ที่ต้องใช้ด้วยคำสั่ง sudo apt–get install –y build–essential python–dev git

(ถ้าใครติดตั้งมาก่อนในบทความก่อนหน้านี้ ก็ผ่านไปได้เลยครับ)

จากนั้นทำการติดตั้ง Library จาก Adafruit (เพื่อที่เราจะได้ไม่ต้องเขียน GPIO Connection เอง ซึ่งยุ่งยาก) ด้วยคำสั่งต่อไปนี้ครับ

mkdir –p /home/pi/sources
cd /home/pi/sources
git clone https://github.com/adafruit/Adafruit_Python_DHT.git
cd Adafruit_Python_DHT
sudo python setup.py install

      

รอจนเสร็จเรียบร้อย

 

จากนั้นทดลองเรียกค่าจากเซนเซอร์ด้วยคำสั่ง

sudo /home/pi/sources/Adafruit_Python_DHT/examples/AdafruitDHT.py 2302 4

โดย 2302 คือ ชนิดของเซนเซอร์และ 4 คือ GPIO ID (ดูจาก Pinout ของ Raspberry Pi และไม่ใช่เลขขานะครับ)
ก็จะได้ค่ามาดังรูป

ตามตัวอย่างด้านบนนี้ เป็นการใช้ Python Example ที่มีมากับ Library ที่เรา Clone มา
อันที่จริงแล้วเราสามารถเขียน Python ให้สามารถเรียกค่าได้โดยง่ายเพียงไม่กี่บันทัด โดยผ่าน Python ดังนี้

1. เข้า python interactive mode ด้วยคำสั่ง sudo python
2. พิมพ์คำสั่งข้างล่างนี้ (ขึ้นบันทัดใหม่ด้วย Enter)

import Adafruit_DHT
humidity, temperature = Adafruit_DHT.read_retry(Adafruit_DHT.AM2302, 4)

3. จากนั้นลองพิมพ์ temperature จะได้ค่าอุณหภูมิออกมา

4. ลองพิมพ์ humidity จะได้ค่าความชื้นออกมา

5. ออจาก python interactive mode ด้วยการกด Ctrl+D

 

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

 

ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

 

 

 

จากตอนที่แล้ว เราทำการเชื่อมต่อจอ LCD 16×2 และเขียน Basic Python ให้สามารถแสดงข้อความง่ายๆ ได้แล้ว

ตอนนี้เราจะลองนำค่าที่อยู่ในตัว Raspberry Pi 3 มาแสดง เช่น

Date & Time
Network Adapter IP Address
CPU Percentage Usage
CPU Temperature
Memory Total
Memory Usage
Memory Free
Disk Total
Disk Usage
Disk Free

เป็นต้น

 

** ส่วนตัวผมจะถนัดใช้ nano เป็น text editor นะครับ ส่วนท่านอื่นที่ไม่คล่อง จะใช้ผ่าน vi หรือ text editor บน gui ก็ไม่ว่ากันครับ **

** ไฟล์ทั้งหมดผม mkdir LCD เอาไว้บน home directory ของ user: pi ครับ **
ซึ่งดาวน์โหลดตัวอย่าง ได้ที่นี่ จากนั้นนำไฟล์ RPi_LCD_Driver.py (จากตอนที่แล้ว) วางไว้ที่ directory เดียวกัน

 

การแสดงวัน/เวลาบนหน้าจอ

ใช้คำสั่งเพื่อสร้างไฟล์ sudo nano show_dt.py จากนั้นเขียนโค้ดตามด้านล่างนี้ครับ

 

import RPi_I2C_Driver
from datetime import datetime
mylcd = RPi_I2C_Driver.lcd()

while True:
    mylcd.lcd_display_string(“%s” %datetime.now().strftime(“%d/%m/%Y”), 1)
    mylcd.lcd_display_string(“%s” %datetime.now().strftime(“%H:%M:%S.%f”), 2)

 

while True เนื่องจากต้องการให้รันแบบ infinite loop แสดงวันเวลาโดยที่

%d แสดงวันที่
%m แสดงเดือน
%Y แสดงปี ค.ศ.

%H แสดงหลักชั่วโมง
%M แสดงหลักนาที
%S แสดงหลักวินาที
%f แสดง milli-seconds

 

เมื่อทดลองรันด้วยคำสั่ง sudo python show_dt.py หน้าจอ LCD จะแสดงดังตัวอย่างข้างล่างนี้

หลัก milli-seconds จะวิ่งเร็วมากจนหน้าจอแสดงไม่ทัน

จากนั้นท่านจะเห็นว่าไม่สามารถพิมพ์คำสั่งอื่นๆ ที่ terminal ได้อีก เนื่องจากโปรแกรมรันอยู่นั่นเอง ให้ท่าน Ctrl+C ออกมา

 

การแสดงค่า IP Address

ใช้โค้ดด้านล่างนี้ พร้อมกับเซฟไว้ในชื่อ myip.py

 

import RPi_I2C_Driver
import socket

mylcd = RPi_I2C_Driver.lcd()

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((‘psu.ac.th’, 80))
ip = s.getsockname()[0]
s.close()

mylcd.lcd_display_string(“IP Address:”, 1)
mylcd.lcd_display_string(ip, 2)

 

หน้าจอ LCD ก็จะแสดงข้อความดังนี้

** มีวิธีการเขียนแสดง ip address อีกหลายวิธี แต่ใช้วิธีนี้เนื่องจากเป็นวิธีที่จะได้ ip address ที่ใช้งานจริง เพราะในบางกรณีจะได้ loopback ip 127.0.0.1 แทน และในบางแบบ ก็สามารถระบุ interface เช่น eth0 หรือ wlan0 ได้ด้วย **

 

ต่อจากนี้ไปจะเป็นการเขียนเพื่อแสดงค่า Environment ของเครื่อง (เช่นเดียวกับ Performance ใน Task Manager ของ Windows) และเนื่องจากหน้าจอ LCD มีขนาดจำกัด จึงได้เขียนให้มีการวนแสดงค่าต่างๆ ออกมาตามเวลาที่กำหนด

 

ซึ่งเราจะต้องทำการอาศัย library ชื่อ python package ชื่อ psutil มาใช้เป็น library เพื่อดู process และเพื่อทำ system monitoring ครับ

 

ทำการติดตั้ง psutil ด้วยคำสั่งต่อไปนี้

sudo apt-get install build-essential python-dev python-pip

 

จากนั้นทำการติดตั้ง psutil ด้วย PIP คำสั่ง

sudo pip install psutil

 

จากนั้นทำการทดสอบการติดตั้ง จะต้องไม่แสดง error ให้เห็น (ไม่แสดงอะไรเลยนั่นเอง)

sudo python -c “import psutil”

 

ตามตัวอย่างต่อไปนี้

 

เมื่อเรียบร้อยแล้ว ให้ท่านลองเขียนโค้ดตามด้านล่างนี้ จากนั้นเซฟไว้ในไฟล์ชื่อ resource_mon.py

 

import os
import time
import socket
import psutil
import RPi_I2C_Driver

mylcd = RPi_I2C_Driver.lcd()

# Return CPU temperature as string
def getCPUtemperature():
    res = os.popen(‘vcgencmd measure_temp’).readline()
    return(res.replace(“temp=”,””).replace(“‘C\n”,””))

# Return RAM info (in kb)
# [0]: total RAM
# [1]: RAM in used
# [2]: free RAM
def getRAMinfo():
    p = os.popen(‘free’)
    i = 0
    while 1:
        i = i + 1
        line = p.readline()
        if i==2:
            return(line.split()[1:4])

# Return disk info (with unit)
# [0]: disk space total
# [1]: disk space in used
# [2]: disk space remaining
# [3]: percentage of used space
def getDiskInfo():
    p = os.popen(“df -h /”)
    i = 0
    while 1:
        i = i +1
        line = p.readline()
        if i==2:
            return(line.split()[1:5])

#CPU Usage
CPU_usage = str(psutil.cpu_percent(interval=1))

# CPU Temp
CPU_temp = getCPUtemperature()

# RAM info (converted to MB)
RAM_info = getRAMinfo()
RAM_total = round(int(RAM_info[0]) / 1000,1)
RAM_used = round(int(RAM_info[1]) / 1000,1)
RAM_free = round(int(RAM_info[2]) / 1000,1)

#Disk info
DISK_info = getDiskInfo()
DISK_total = DISK_info[0]
DISK_free = DISK_info[2]
DISK_perc = DISK_info[3]

while True:
 mylcd.lcd_display_string(“CPU Temperature:”, 1)
 mylcd.lcd_display_string(CPU_temp + ” DegCelcius”, 2)
 time.sleep(5)
 mylcd.lcd_clear()
 mylcd.lcd_display_string(“CPU Usage:”, 1)
 mylcd.lcd_display_string (CPU_usage + “%”, 2)
 time.sleep(5)
 mylcd.lcd_clear()
 mylcd.lcd_display_string(“RAM Total/Used”, 1)
 mylcd.lcd_display_string(str(RAM_total) + ” / ” + str(RAM_used) + “MB”, 2)
 time.sleep(5)
 mylcd.lcd_clear()
 mylcd.lcd_display_string(“DISK Total/%Used”, 1)
 mylcd.lcd_display_string(str(DISK_total) + ” / ” + str(DISK_perc), 2)
 time.sleep(5)
 mylcd.lcd_clear()

 

โดยในโค้ดนี้จะมีการเขียนแยก method และเขียนคำอธิบายเอาไว้ใน comment ของโค้ดให้แล้ว
สามารถนำปรับการแสดงผลได้ตามที่ท่านต้องการครับ และเมื่อรันด้วยคำสั่ง sudo python resource_mon.py
ก็จะพบกับหน้าจอวนไปเรื่อยๆ ดังนี้

           

บนซ้าย แสดงอุณหภูมิ CPU
บนขวา แสดง CPU Usage %
ล่างซ้าย แสดงการใช้ RAM ทั้งหมด/ที่ใช้ไป
ล่างขวา แสดงการใช้ DISK ทั้งหมด/%ที่ใช้ไป

           

 

ท่านสามารถปรับค่าที่ต้องการให้แสดงได้ตามที่ต้องการ
โดยค่าที่สามารถดึงมาใช้ได้ จะ comment เอาไว้ในโค้ดของ method ที่ทำการ assign ค่าให้กับตัวแปรมาแสดง

 

ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

 

สำหรับตอนหน้า จะเป็นการเชื่อมกับเซนเซอร์ภายนอก

จะเป็นเซนเซอร์อะไรนั้น ติดตามต่อตอนหน้า ในอีกระยะเวลาหนึ่ง

 

สวัสดีครับ

จากตอนที่แล้วเราได้ทำการเชื่อมต่อ hardware ซึ่งได้แก่ จอ LCD ขนาด 16×2 ผ่าน I2C Module ไปเรียบร้อยแล้วนั้น

เราจะเริ่มทำการ Config I2C และเขียน Python เพื่อแสดงข้อความตัวอักษรอย่างง่าย

 

Enable I2C Module

เริ่มด้วยการ login เข้าสู่ Raspberry Pi และใช้คำสั่ง sudo raspi-config บนหน้าจอ Terminal

จากนั้นเลือก 5 Interfacing Option และเลือก P5 I2C (Enable/Disable automatic loading…)

ทำการคอนเฟิร์ม ด้วยการตอบ YES จากนั้น Reboot

 

จากนั้นทำการอัพเดทไฟล์ /boot/config.txt ด้วยคำสั่ง sudo nano /boot/config.txt

ใส่ข้อความ (หรือ uncomment) ต่อไปนี้

dtparam=i2c1=on

dtparam=i2c_arm=on

จากนั้นทำการ reboot ครับ

 

ลองใช้คำสั่ง sudo i2cdetect -y 1 เพื่อดูว่าเจอ I2C Module หรือไม่ ซึ่งผลที่ได้คือ address ของอุปกรณ์ (อาจแตกต่างกันไปในแต่ละเครื่อง ซึ่งในที่นี้คือ address 0x3f นั่นเอง)

 

จากนั้นทำการตรวจสอบว่ามีการติดตั้ง Python ไว้หรือยัง ด้วยการทดลองเรียกใช้ซะเลย ด้วยคำสั่ง

python3 จะพบกับหน้าจอดังนี้ (ใช้คำสั่ง exit() เพื่อออกกลับไปยัง prompt เดิม)

แต่ถ้าหากยังไม่เคยติดตั้ง ให้ติดตั้งด้วยคำสั่ง sudo apt-get install python ครับ

 

เริ่มเขียน Python เพื่อแสดงตัวอักษรบน LCD กันเลย

เนื่องจากเราไม่ใช่คนแรกในโลกที่ใช้งานส่วนนี้ เพื่อเป็นการประหยัดเวลา เราจะทำการดาวน์โหลด library มาใช้งาน

ซึ่ง ดาวน์โหลดได้ที่นี่ (ต้อง Extract Zip จะเจอไฟล์  RPi_I2C_Driver.py) โดยจะต้องทำการแก้ไข บันทัดที่ 54 ADDRESS = 0x3f ให้เป็น Address ของเราเอง (ต้นฉบับจากที่นี่ https://gist.github.com/DenisFromHR/cc863375a6e19dce359d)

 

จากนั้นลองทำการเขียนกันดูครับ

import RPi_I2C_Driver
from time import *

mylcd = RPi_I2C_Driver.lcd()
mylcd.lcd_display_string(“Hello PSU !”, 1)

เซฟไฟล์ชื่อ hello.py จากนั้นสั่งรันด้วยคำสั่ง python hello.py จะพบว่า LCD สามารถแสดงข้อความได้แล้ว

 

คำสั่งพื้นฐานอื่นๆ ที่อาจต้องใช้ได้แก่

mylcd.lcd_display_string(“Hello PSU !”, 2, 3) แสดงข้อความที่ row 2, column 3

mylcd.lcd_clear() เพื่อเคลียร์หน้าจอ

เป็นต้นครับ

 

สำหรับตอนหน้า จะเป็นเรื่องของการแสดงข้อความอื่นๆ ในระบบ เช่น วัน/เวลา, IP Address, CPU/Memory/Disk Usage ครับ

 

ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

 

 

 

 

หลังจากตอนที่แล้วเราได้ทำการ setup โปรแกรมที่เราต้องการ

ในตอนนี้ขอพูดถึงอุปกรณ์ต่อพ่วงกันบ้าง เพื่อให้ดูเหมือนเข้าสู่ยุค IoT (Internet Of Things) มากขึ้น นั่นคือจอ LCD ระดับเบื้องต้น ขนาด 16×2 ดังรูปนี้

ซึ่งอุปกรณ์ตัวนี้ สามารถแสดงผลได้ 2 แถว แถวละ 16 ตัวอักษร ซึ่งเพียงพอในระดับเบื้องต้นสำหรับการเรียนรู้การเขียนโปรแกรมครับ

โดยในตลาดจะมีขายหลายรุ่น เช่น 16×2, 20×4 ไปจนถึง 128×64 อีกทั้งยังมี จอสีประเภท TFT 2.4 นิ้ว, 3 นิ้ว, 3.2 นิ้ว, 4 นิ้ว เป็นต้น และมีแบบหน้าจอสัมผัสให้เลือกใช้งานอีก มากมาย

 

การเชื่อมต่อจอ 16×2 กับบอร์ด Raspberry Pi 3

โดยทั่วไปแล้ว จะต้องทำการเชื่อมต่อดังรูปด้านล่างนี้

 

         

การเชื่อมต่อแบบ 4 bits (ซ้าย) – การเชื่อมต่อแบบ 8 bits (ขวา)

จะเห็นว่าเป็นการเชื่อมต่อที่ยุ่งยาก ใช้สายหลายเส้น และยากต่อการปรับเปลี่ยนการใช้งาน ดังนั้นจึงมึโมดูลที่เข้ามาช่วยตรงนี้คือ I2C

 

I2C คืออะไร

I2C คือบัสการเชื่อมต่ออนุกรมแบบ Synchronous ด้วยสายสัญญาณเพียง 2 เส้น (แต่จริงๆ ต่อ 4 เส้น ได้แก่ SDA, SLC, +5V และ GND) โดยจะมีสายสัญญาณข้อมูล คือ SDA (Serial Data Line) และสายสัญญาณนาฬิกา คือ SLC (Serial Clock Line) โดยแบ่งการทำงานออกเป็น 4 โหมดตามความเร็วดังนี้

1. Normal Mode ความเร็ว 100Kbps
2. Fast Mode ความเร็ว 400Kbps
3. Fast Mode Plus ความเร็ว 1Mbps
4. High Speed ควาามเร็ว 3.4Mbps

 

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

 

และเนื่องด้วยความง่ายของการใช้งานของ I2C ทำให้อุปกรณ์จอ LCD ส่วนใหญ่จะทำการติดตั้งมาพร้อมกับจอแล้ว ดังรูป

          

I2C Module คือโมดูลสีเข้มในรูป
บอร์ดสีเขียวคือ ด้านหลังของจอ LCD 16×2 ซึ่งได้ทำการเชื่อมต่อเรียบร้อยแล้ว

 

เริ่มทำการเชื่อมต่อกับ Raspberry Pi

โดย I2C จะต้องทำการเชื่อมต่อ 4 เส้น คือ +5V, GND, SDA, SLC กับ Pinout ของ Raspberry Pi 3

ดูจากข้อมูล Alternate Function เราจะต้องทำการต่อสาย SDA ที่ Pin 3, SCL ที่ Pin 5
และ +5V ที่ Pin 2 หรือ ส่วน GND นั้นมี Pin 6, 9, 25, 39, 14, 20, 30 หรือ 34 ให้เลือก

 

     

จากนั้นทำการ Power On Raspberry PI 3 ขึ้นมาครับ จะพบว่าหน้าจอ LCD ติดพร้อมไฟ Backlight (แต่ไม่มีตัวอักษรอะไรแสดง เพราะเรายังไม่ได้โปรแกรมครับ)

 

หน้าจอสามารถปรับ Contrast (ความเข้มของตัวอักษร) และสามารถ เปิด/ปิด ไฟ backlight ได้ด้วย Jumper บนโมดูล I2C ครับ

 

ตอนต่อไป จะเป็นการเริ่มเขียน Python เพื่อแสดงผลตัวอักษร

 

ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

หลังจากเราได้ติดตั้ง OS แล้ว ต่อไปจะเป็นการเชื่อมต่อกับเครือข่าย LAN หรือ Wi-Fi

ถ้าเป็นสายแลน ก็ไม่ยากครับ เสียบสายเข้าไปเลย โดย default config eth0 จะเป็น DHCP Client อยู่แล้ว

ส่วน Wi-Fi นั้น จากการหาข้อมูลชิบBroadcom BCM43438 Wireless Controller นั้น เหมือนจะรองรับเฉพาะ 2.4GHz ครับ

 

ผมจะเลือกทำการ connect Wi-Fi ก่อนนะครับ หลังจากนั้นค่อยเซ็ตอัพวัน/เวลา และโปรแกรม

เรื่องของการ connect เข้า Wi-Fi ที่เป็น WPA2 Enterprise นั่นก็อาจจะเป็นปัญหาเบื้องต้นที่เจอครับ คือ โดย default แล้วนั้น จะไม่ support ดังรูปข้างล่างนี้ ทำให้ connect เข้าโดยตรงไม่ได้

ต้องทำการแก้ไขปัญหาดังนี้ครับ

1.เปิด terminal จากนั้นแก้ไฟล์ wpa_supplicant.conf โดยใช้คำสั่ง

sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

 

2.เพิ่มบรรทัดต่อไปนี้เข้าไป

network={
ssid=“PSU WiFi (802.1x)“
priority=1
proto=RSN
key_mgmt=WPA-EAP
pairwise=CCMP
auth_alg=OPEN
eap=PEAP
identity=”YOUR_PSU_PASSPORT_USERNAME“
password=hash:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
phase1=“peaplabel=0”
phase2=“auth=MSCHAPV2”
}

 

เซฟไฟล์ด้วยการกด Ctrl + X ตอบ Y กด Enter กลับมาที่หน้าจอ Terminal ตามเดิม

ข้อมูลที่ท่านสามารถปรับแก้ได้คือตัวอักษรสีแดงด้านบน ได้แก่

ssid <= ชื่อ ssid ซึ่งบางที่อาจจะไม่ใช่ดังในตัวอย่าง

identity <= username ของ psu passport อยู่ภายใต้เครื่องหมาย ” ”

password=hash: มาจากการคำนวณ hash ด้วยคำสั่งต่อไปนี้

echo -n ‘YOUR_PASSWORD‘ | iconv -t utf16le | openssl md4

จากนั้นเอาค่ามาใส่แทนที่ xxxxxxxx ตามตัวอย่างข้างบน

 

3.เมื่อเรียบร้อยแล้วให้ restart service networking ซักครั้งหนึ่งด้วยคำสั่ง

sudo service networking restart

 

4.หากไม่เกิดการเปลี่ยนแปลงอะไร ให้ reboot ซักครั้ง

sudo reboot

 

5.เมื่อ reboot กลับมาแล้ว ท่านจะพบว่ามีการเชื่อมต่อ SSID ตามที่ท่านได้เซ็ตเอาไว้เรียบร้อยแล้ว ดังรูปด้านล่างนี้

 

** คำสั่งที่ท่านพิมพ์ผ่าน Terminal จะถูกเก็บ History เอาไว้ รวมทั้งรหัสผ่านที่ท่านได้สร้างเป็น hash เอาไว้ ท่านจะต้องทำการเคลียร์ออก ด้วยคำสั่ง

history -c (เพื่อเคลียร์ทั้งหมด) หรือ

 

history | tail เพื่อดูหมายเลขบรรทัด เช่น 300  จากนั้นใช้คำสั่ง

history -d 300 เพื่อลบเฉพาะบรรทัดนั้น

 

เมื่อเสร็จเรื่องการเชื่อมต่อแล้ว จากนั้นควรทำการเซ็ตอัพวันเวลา / timezone ให้เรียบร้อย

เปิด Terminal จากนั้นพิมพ์คำสั่ง sudo dpkg-reconfigure tzdata

         

เลือก Asia และเลือก Bangkok กด Enter เป็นอันเสร็จสิ้นครับ

 

จากนั้นควรทำการ sync time เพื่อให้ได้เวลาที่ถูกต้อง

** ใน Raspbian Stretch ส่วนของ NTP จะไม่ได้ถูกติดตั้งโดยอัตโนมัติ จะต้องทำการติดตั้งก่อนด้วยคำสั่งต่อไปนี้

sudo apt install ntp

รอจนเสร็จ จากนั้นทำการ enable ด้วยคำสั่ง

sudo systemctl enable ntp

และสั่งอัพเดทวัน/เวลา ด้วยคำสั่ง

sudo timedatectl set-ntp 1

 

สำหรับการติดตั้ง Software เพิ่มเติมนั้น สามารถทำได้โดยการใช้ Add / Remove Software

(ขอกลับมาใช้ GUI บ้างครับ)

ด้วยการกดที่ ICON Raspberry เลือก Preferences > Add/Remove Software

 

จากนั้นท่านจะพบกับ package ให้เลือก ตามที่ท่านต้องการ จากนั้นกด Apply ได้ทันทีครับ

 

 

และบางครั้งการทำงานผ่านหน้าจอ console ของ Raspberry Pi เอง อาจจะลำบาก ยากต่อการเข้าถึง จึงแนะนำให้ติดตั้ง Remote Desktop ด้วยครับ (ในที่นี้ เนื่องจากผมทำงานกับ Windows ซะเป็นส่วนใหญ่ จึงขอติดตั้งเฉพาะ RDP นะครับ ส่วนวิธีอื่น (เช่น VNC) ท่านสามารถหาอ่านได้ทั่วไปเลยครับ)

 

ทำการติดตั้ง package RDP ด้วยคำสั่งต่อไปนี้

sudo apt-get install xrdp

 

เมื่อเรียบร้อยแล้วท่านก็จะสามารถเข้าผ่าน Remote Desktop บน Windows ได้ทันที

โดย default username จะเป็น pi และ default password ก็คือ raspberry ครับ

 

และสำหรับการใช้งานสำหรับคนไทย ขาดไม่ได้คือการเพิ่มคีย์บอร์ดภาษาไทย เพื่อให้พิมพ์ไทยได้ ด้วยวิธีการดังต่อไปนี้

 

คลิ๊กขวาบน Taskbar ด้านบน เลือก Panel Settings

 

เลือกแทบ Panel Applets จากนั้นกดปุ่ม Add

 

เลือก Keyboard Layout Handler จากนั้นกด Add

 

กด Preferences เพื่อแก้ไขค่าของ Keyboard Layout Handler

 

         

นำเครื่องหมายถูก หน้า Keep system layouts ออก (unchecked) จากนั้นกดปุ่ม Add เพื่อเพิ่ม Keyboard Layouts

เลือก th Thai จากนั้นกด OK ออกมาจากหน้าจอ Add Keyboard Layout

หากต้องการปรับปุ่มสลับภาษา สามารถเลือกได้ที่ Change Layout Option โดยมีให้เลือกตามความถนัด

 

จากนั้นสังเกตมุมขวาบน จะเห็นสัญลักษณ์ธงชาติ แสดงภาษาที่ใช้งานอยู่ ณ ขณะนั้นครับ

 

 

สำหรับตอนต่อไป จะเป็นการเชื่อมต่อกับ I2C Module กับจอ LCD ขนาด 16×2 เพื่อแสดงผลตัวอักษร และการเขียน Python เบื้องต้นครับ

 

ผิดพลาดประการใด ขออภัยมา ณ ที่นี้ครับ