How to install DS3231 RTC high precision on Raspberry pi 2

ในบางงาน เราไม่สามารถให้ RPi ของเราเชื่อมต่อกับอินเตอร์เนตได้ แม้ว่า RPi จะต่ออยู่กับ local network ก็ตาม ดังนั้น นาฬิกาของ RPi อาจจะเดินไม่ตรงได้ เพราะ Rpi ใช้หลักการ crontab เพื่อทำการอัพเดทเวลาตนเองเป็นรายคาบ ดังนั้น หากให้เวลาเดินตรงๆ เราก็ต้องหา Hardware จริงๆ มาต่อ เพื่อสร้างฐานเวลาให้กับ RPi ในทีนี้ ผมได้เลือกใช้ DS3231 RTC High precision (เขาว่างั้นนะ)  มาทำเป็นฐานเวลาให้ RPi

ต่อวงจรตามรูป

ที่ Raspberry pi หลังจากบูตมาแล้ว ให้ทำการ Enable I2C ด้วยคำสั่ง

#sudo raspi-config

ภายใต้เมนู Advace options จะมีให้เลือก Enable I2C ถามอะไรมา OK ให้หมด ไม่ต้องคิดมาก

เข้าไปเช็คที่ไฟล์ /boot/config.txt จะมีข้อความ อยู่บรรทัดสุดท้าย

dtparam=i2c_arm = on ปรากฏอยู่ ถ้าไม่มีก็เพิ่มซะ จะรออะไรหล่ะ

ทำการ #sudo reboot ซะ 1 ครั้ง

เสร็จแล้วเราก็จะมาบอกให้ Linux รู้จัก device ใหม่ ที่ address 0x68 บน I2C ด้วยคำสั่ง

#sudo modprobe i2c-bcm2708
#echo ds3231 0x68 > sudo tee /sys/class/i2c-adapter/i2c-1/new_device

ถ้า Enter คำสั่งนี้แล้วไม่มีข้อความแจ้ง Error แสดงว่าพิมพ์ถูกแหละ
ใช้คำสั่ง
#sudo hwclock  มันจะไปอ่านค่าเวลาจาก hardware ของเราในทีนี้ ก็คือ ds3231 นั่นแหละ จะนานหน่อย เวลาอ่านค่าเวลาจากมัน

แล้วเราก็เอาคำสั่งนี้แหละไปเพิ่มในไฟล์ /etc/rc.local เอาไว้ตอนที่มันบูทขึ้นมา จะได้จำได้ตลอด

#sudo nano /etc/rc.local

ให้เพิ่มข้อความนี้ ไว้ก่อน Exit 0

echo ds3231 0x68 > sudo tee /sys/class/i2c-adapter/i2c-1/new_device
sudo hwclock -s
Exit 0 <<< จะต้องอยู่ล่างสุด

หากเวลาเดินไม่ตรง เราสามารถใช้คำสั่ง

#sudo hwclock --set --date="2015-05-24 13:00:00"

ตั้งเวลาได้ แต่ ถ้าต่ออินเตอร์เนตอยู่ เราสามารถให้มัน sync กับ NTP server ก่อนได้ ด้วยคำสั่ง
#sudo ntpd -gq  ใช้เวลานิดหนึ่ง มันจะปรับเวลา ds3231 ให้ตรงกับ Timezone ของเรา
แล้วก็ write ค่าลง ds3231 ซะด้วยคำสั่ง
#sudo hwclock -w  ทันที

ขั้นตอนสุดท้าย เราต้องไป disable fake-hwclock เพื่อบอก RPi ว่า ตอนนี้เรามี Hardware ที่เป็น Clock จริงๆ แล้วนะ ไม่ต้องมาหลอกตัวเองอีกแล้ว ด้วยคำสั่ง

#sudo update-rc.d fake-hwclock disable
#sudo update-rc.d ntp disable

บันทึกเพิ่ม
ทำการติดตั้ง i2c-tools เอาไว้เช็คแอดแดรสของอุปกรณ์ที่ต่ออยู่กับ I2C
#sudo apt-get install i2c-tools

เราจะเรียกใช้คำสั่ง
#sudo i2cdetec -y 1 (1 สำหรับ RPi 2 )

ได้ ก็เห็น address ที่อยู่บน I2C bus ถ้าไม่แสดง ให้ทำการเช็คอุปกรณ์ที่ต่ออยู๋ ว่าไม่ได้เสีย หรือลืมจ่ายไฟเลี้ยง

ทำแล้วไม่เวิร์ก ลอง upgrade distro ดูครับ ผมก็ทำไม่เวิร์กเหมือนกันตอนแรก หลังจาก upgrade แล้วได้เลย

#sudo apt-get dist-upgrade

 

ที่มา :
http://bohdan-danishevsky.blogspot.com/2014/12/installing-hardware-rtc-ds3132-to.html
http://www.drewkeller.com/blog/adding-hardware-clock-raspberry-pi-ds3231
http://www.bashpi.org/?page_id=500
https://learn.adafruit.com/adding-a-real-time-clock-to-raspberry-pi?view=all
http://decuser.blogspot.com/2015/02/raspberry-pi-b-i2c-and-ds3231-rtc.html

อ่านเพิ่มเติม...

กล่องใส่ Raspberry Pi ฟรีๆ ( a card case for raspberry pi)

   จริงๆ บอร์ด Raspberry pi หน่ะ ไม่แพงหรอก แต่ พอรวมอุปกรณ์ประกอบอื่นๆ ไปๆมาๆ จะแพงกว่าบอร์ด Raspberry pi เสียด้วยซ้ำ จะไม่ low cost ซะแล้ว ยิ่งเจ้ากล่องที่ใส่ Raspberry pi นี่ ก็มีตั้งแต่ ราคา 150 บาท ไปจนถึง 5-600 บาท  ไม่รู้จะแพงไปไหน อีกหนำซ้ำ เจ้าบอร์ด Raspberry pi มันก็ไม่ได้สี่เหลี่ยมแปะๆ ซะทีไหนหล่ะ ยังอุตส่าห์มี SD-card ยื่นออกมา จะเอากล่องทั่วไป ก็ใช่ว่าจะได้ขนาดที่พอดี

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

ดาวน์โหลด http://squareitround.co.uk/Resources/Punnet_net_Mk1.pdf

ที่มา http://www.raspberrypi.org/archives/1310

อ่านเพิ่มเติม...

How to getting started WiringPi

ในการควบคุม GPIO ของ Raspberry pi นอกจากเราจะทำการ echo ค่า 1 และ 0 ไปที่ Filesystem ที่ชื่อ sysfs ของระบบ linux ที่เป็นที่เก็บไฟล์ื่ที่ติดต่อกับ GPIO Hardware ของ Raspberry Pi แล้ว (http://raspberry-pi-th.blogspot.com/2012/09/get-to-know-raspberry-pi-gpio.html) ยังมีอีกหลายวิธี ไม่ว่าจะเป็นการเรียกใช้ module RPi.GPIO(http://raspberry-pi-th.blogspot.com/2012/10/rpigpio-python-control-gpo-of-raspberry.html) ที่พัฒนาด้วยภาษาไพธอน แต่ก็ยังไม่ค่อยตอบโจทย์ผมเท่าไหร่ เพราะต้องใช้สิทธิ์ root ในการเรียกใช้คำสั่งเหล่านั้น ซึ่งไม่ค่อยสะดวกเท่าไหร่

วันนี้ผมจะมาแนะนำอีกหนึ่งไลบรารี่ ของคุณ Gordon Henderson ซึ่งได้พัฒนาชุดโปรแกรมสำหรับเรียกใช้งาน GPIO ของ Raspberry pi ด้วยภาษา C ซึ่งเข้าถึงรีจิสเตอร์ของ GPU ของ Raspberry Pi เลย และที่สำคัญ เราสามารถเรียกใช้ไลบรารี่ชุดนี้ ได้เหมือนคำสั่ง shell ของ linux ได้เหมือนๆ คำสั่งอื่นๆ ทั่วไป โดยไม่จำเป็นต้องเป็นสิทธิ์ Root ก่อนเลย ซึ่งสะดวกเป็นอย่างยิ่งครับ ในการนำไปต่อยอดพัฒนาโปรแกรมอื่นๆ ต่อไป 

เรามาติดตั้งกันก่อนเลยครับ เนื่องจากโปรแกรมนี้ ถูกเก็บไว้ด้วยรูปแบบกระจายซอร์สโค๊ดด้วย git-core หากเรายังไม่มี package นี้ในการช่วยดาวน์โหลดซอร์สโค๊ดต่างๆ จากผู้พัฒนาโปรแกรมให้ติดตั้ง git-core ด้วยคำสั่ง

sudo apt-get install git-core

จากนั้นทำการดาวน์โหลด wiringPi ด้วยคำสั่ง

git clone git://git.drogon.net/wiringPi

จากนั้นเข้าไปในโฟวเดอร์ wirignpi แล้วทำการเช็คอัพเดท

cd wiringPi
git pull origin

ต่อไปให้ทำการติดตั้ง ซึ่งจะเป็นการ compile โค๊ดที่เราโหลดมาบนบอร์ดของ โดยออกจากโฟวเดอร์ wiringPi ก่อน โดยเรียกคำสั่ง

cd ..
จากนั้นทำการรันไฟล์ build ด้วยคำสั่ง

./build

Raspberry pi จะทำการ compile wiringPi เพื่อให้กลายเป็นคำสั่ง shell ให้เราเรียกใช้ง่ายๆ ต่อไป

เมื่อ compile เสร็จแล้ว เราจะสามารถเรียกใช้คำสั่ง gpio ได้  ให้เราจินตนาการง่ายๆ ว่า คำสั่ง gpio ก็เหมือนคำสั่ง ls หรือ คำสั่ง cat หรือ cp เหมือนคำสั่งอื่นๆ บน linux นั่นเอง ดังนั้น มันจึงสามารถที่จะเรียกดูํ manual ของมันได้เช่นกัน ด้วยคำสั่ง

man gpio

ในคู่มือที่แสดงนี้ จะบอกถึงวิธีการเรียกใช้คำสั่งนี้ และที่ท้ายๆ คู่มือ เค้าจะเขียนบอกการจับคู่ขา WiringPi กับ GPIO จริงๆ ทั้ง Rev1 และ Rev2 ครับ

ผมขออธิบายการเรียกใช้งานคร่าวๆ ของคำสั่ง gpio นี้นะครับ ที่เหลือ สามารถศึกษาเพิ่มเติมได้ใน man gpio นี้แหละครับ

ในการเรียกใช้งาน GPIO ของ Raspberry pi โดยค่าเริ่มต้น เมื่อเราจ่ายไฟไปที่บอร์ด Raspberry pi เริ่มต้น ที่ GPIO ส่วนใหญ่ จะมี สถานะเป็น Input หากเราต้องการนำขา GPIO ไปใช้งานเป็น Output แล้ว เราจะต้องทำการกำหนดทิศทางของ GPIO ซะก่อน ด้วยคำสั่ง

gpio mode 0 out <--- สั่งให้ wirignpi pin 0 ทำหน้าที่เป็น output
gpio write 0 1  <--- สั่งให้เขียนค่า 1 ไปที่ wiringpi pin 0 ซึ่งจะเกิด login high ที่ pin นี้

ผมลองเปิด webiopi เพื่อเช็คสถานะของ GPIO ไปด้วย ( http://raspberry-pi-th.blogspot.com/2013/01/webiopi-control-raspberry-pi-s-gpio-via.html )

ในทำนองตรงกันข้าม หากเราต้องการให้ pin ใดๆ ทำหน้าที่เป็น input รอรับสถานะทางไฟฟ้า ก็กำหนดเป็น in แล้้วใช้คำว่า read แทนการ write ดังต่อไปนี้

gpio mode 11 in
gpio read 11 

หวังว่าคงไม่ งง นะครับ ว่าทำไม 11 กับ GPIO7 มันเกี่ยวข้องอะไรกัน ซึ่งมันเป็นเรื่องของการตั้งชื่อ map pin เข้ากับตัวโค๊ดของผู้เขียนโปรแกรมนั่นเอง ไม่มีอะไรมาก

นอกจากนี้ คำสั่ง gpio ยังมีลูกเล่นอื่นๆ อีกไม่ว่าจะเป็นการสร้างสัญญาณ PWM หรือการอ่านสถานะ pin ทั้งหมดก็สามารถทำได้เช่นกัน ลองศึกษาเพิ่มเติมดูจากคำสั่ง man gpio หรือที่เว็บ https://projects.drogon.net/raspberry-pi/wiringpi/

เดี๋ยวต่อไป ผมจะยกตัวอย่างการนำคำสั่ง gpio ไปลองใช้งานในด้านอื่นๆ ดูบ้างครับ ขอให้สนุกกับ Raspberry pi นะครับ

อ่านเพิ่มเติม...

How to install MJPG-Streamer

MJPG-Streamer คือ โปรแกรมประเภทคำสั่งที่สามารถพิมพ์คำสั่งลงไป แล้วโปรแกรมจะทำการดึงภาพออกจากเว็บแคมของเรา แล้วทำการส่งไปเก็บไว้ เพื่อที่เราจะสามารถเข้ามาดูได้ โดยผ่านเว็บบราวเซอร์ หรือผ่านทางมือถือก็ได้

บทความต่อไปนี้ ผมได้ค้นหามาจาก http://www.raspberrypi.org/phpBB3/viewtopic.php?f=30&t=8659  ซึ่งก่อนหน้านี้ ผมพยายามทำมาหลายครั้งแล้ว แต่ ไม่ประสบความสำเร็จเหมือนคนอื่นเค้า เนื่องจากบอร์ด Raspberry Pi ของผมเป็น Model B rev 1 ซึ่งอาจจะมีอุปสรรคมากกว่าบอร์ดรุ่นใหม่ๆ สักหน่อย ซึ่งอาจจะทำให้บทความนี้ อาจจะไม่เวิร์กสำหรับคนอื่นก็ได้ ก็ต้องขอบอกไว้ ณ ทีนี้ด้วย ซึ่งการที่เราจะต่ออุปกรณ์อะไรสักอย่างกับ Linux ย่อมมีอุปกรณ์เรื่องของ driver ที่ไม่รองรับ นั่นเป็นเรื่องธรรมดาของ Linux OS ครับ (ต้องทำใจนิดนึง)

อุปกรณ์ที่ผมใช้ก็คือ บอร์ด Raspberry Pi Model B rev 1 ซึ่งมี RAM อยู่ 256 กับกล้อง WebCam ยี่ห้อ OKER รุ่น Webcam OKER (177) ซึ่งนับว่าโชคดีมาก ที่เจ้า Driver kernel ของผมมันรองรับพอดี หากเพื่อน ต้องการทราบว่ากล้องรุ่นใดบ้างที่ driver รองรับ สามารถตรวจสอบได้ที่ http://www.ideasonboard.org/uvc/

เรามาเริ่มกันเลยครับ หลังจากที่เราได้เช็คอัพเดทแล้ว sudo apt-get update ให้เราไปโหลด package เหล่านี้มาก่อน ได้แก่

sudo apt-get install subversion
sudo apt-get install libv4l-dev
sudo apt-get install libjpeg8-dev
sudo apt-get install imagemagick

ซึ่ง Subversion เป็นตัวเอาไว้โหลดซอร์สโค๊ดจาก svn server ที่นักพัฒนาโปรแกรมนิยมเอาไปเก็บไว้ครับ ส่วน package อื่นๆ ที่เหลือ ก็เกี่ยวเนื่อง และ เป็นไลบรารี่เสริมในการ

compile MJPG-Streamer อีกทีครับ

ตอนนี้เราจะโหลด MJPG-Streamer บ้างหล่ะ ให้ใช้คำสั่งนี้ครับ ซึ่งจะได้ตัวอัพเดทล่าสุดเลย

svn co https://mjpg-streamer.svn.sourceforge.net/svnroot/mjpg-streamer mjpg-streamer

เสร็จแล้วให้เข้าไปที่โฟวเดอร์ mjpg-streamer/mjpg-streamer ด้วยคำสั่ง

cd mjpg-streamer/mjpg-streamer 

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

make USE_LIBV4L2=true clean all

ซึ่งไม่น่าจะมี error ใดๆ ขึ้นมานะครับ (อาจจะมี warning ได้ แต่ อย่าให้มี error ก็แล้วกัน ) เสร็จแล้วก็ตามด้วย

sudo make DESTDIR=/usr install

หากไม่มี error แล้ว ให้เราทำการเสียบกล้อง webcam ของเราเข้าทาง port USB ของบอร์ด Raspberry pi ครับ ก่อนที่จะเสียบสาย USB เราอาจจะสั่งคำสั่ง

tail -f /var/log/messages

เพื่อดูว่า uvcvideo kernel driver มองเห็นอุปกรณ์ที่เป็น camera หรือยัง ถ้ามองเห็นแล้ว ควรจะได้ข้อความตามรูปข้างล่าง

จากนั้น ผมลองติดตั้ง fswebcam ซึ่งตัวนี้ ผมจะใช้เป็นตัวเช็คว่า ผมจะต้องปรับค่า output ที่กล้องให้ค่าได้เป็นอะไร ซึ่งเราจะนำไปใช้ในการตั้งค่า streamer ต่อไป 

ติดตั้ง fswebcam  ด้วยคำสั่ง

sudo apt-get install fswebcam

เสร็จแล้วให้ใช้คำสั่ง

fswebcam --verbose

ซึ่งจากข้อมูลที่ได้มา ผมควรที่จะปรับค่า output ที่จะได้จาก streamer ให้เป็น YUYV และ frame rate ควรจะเท่ากับ 4

ผมก็นำเอาข้อมูลที่ได้นี้ มาใช้ร่วมกับคำสั่ง

mjpg_streamer -i "/usr/lib/input_uvc.so -d /dev/video0  -r 352x288 -f 4 -y YUYV" -o "/usr/lib/output_http.so -p 8090 -w /var/www/mjpg_streamer"

(ศึกษาพารามิเตอร์ต่างๆ ได้ที่ คำสั่ง mjpg_streamer --help  หรือ จากไฟล์ /home/pi/mjpg-streamer/mjpg-streamer/start.sh )

หลังจากที่สั่งคำสั่ง เรียบร้อยแล้ว จะเกิดการ stream ภาพที่ได้จากกล้องไปเก็บไว้ที่ web root folder เราสามารถเปิดดูภาพที่ได้ผ่านหน้าเว็บบราวเซอร์ได้เลย โดยใส่  URL ไปที่ ip ของ Raspberry pi แล้วตามด้วยพอร์ต 8090 ครับ จากนั้นตามด้วยพารามิเตอร์ ?action=stream

สมมติว่า ip address ของบอร์ด raspberry pi เท่ากับ 192.168.2.105 จะได้ว่า

http://192.168.2.105:8090/?action=stream

ที่หน้าเว็บบราวเซอร์จะพบภาพจากกล้องเว็บแคมของเราครับ

ถ้าเพื่อนๆ ลองปรับพารามิเตอร์คำสั่ง mjpg_streamer ให้เหมาะกับ output ของกล้องหล่ะก็ ภาพที่ได้จะออกมาดี (เท่าที่กล้องมันจะทำได้) เลยหล่ะครับ หวังว่าคงเป็นประโยชน์ นำไปต่อยอดกันได้นะครับ

อ่านเพิ่มเติม...

Raspberry Pi : Getting started with pyfirmata

จากในครั้งก่อนๆ ถ้าจำได้ ที่ผมได้แนะนำเรื่องการใช้ Arduino มาเป็นแขนเป็นขาให้ Raspberry Pi (ย้อนกลับไปดู http://raspberry-pi-th.blogspot.com/2012/11/raspberry-pi-and-arduino-experiment.html) ในตอนนั้น เราได้เขียนโปรแกรมติดต่อระหว่างบอร์ด Arduino และ บอร์ด Raspberry Pi โดยใช้ python-serial จาก Raspberry pi ติดต่อผ่าน uart protocal โดยให้บอร์ด Arduino ทำหน้าที่รอรับคำสั่งจาก Raspberry Pi เราจะพบว่า ค่อนข้างจะลำบากในแง่ของการพัฒนา แต่ถ้าหากใครที่มีความชำนาญแล้ว อาจจะชอบสไตล์นี้ก็ไม่ว่ากัน แต่ ถ้าหากจะมีไลบรารี่ที่สามารถอำนวยความสะดวกได้หล่ะ ก็น่าจะทำให้เราสามารถลดระยะเวลาในการพัฒนาโปรแกรมได้ไม่น้อย

วันนี้ เราจะมาลองใช้ไลบรารีสำเร็จรูปที่ชื่อ pyfirmata ซึ่งจะต้องติดตั้งลงบน Raspberry Pi แทนการเขียนโค๊ดเพื่อติดต่อระหว่าง Raspberry Pi และ Arduino ผ่านทาง Serial Port

Firmata คือ โปรแกรมที่ถูกออกแบบโปรโตคอลอย่างง่าย ที่ใช้สำหรับควบคุมขา PIN ต่างๆ บนบอร์ด Arduino โดยจะทำงานบนบอร์ด Arduino ซึ่งจะคอยทำงานรับส่งคำสั่ง ผ่านทาง Serial port

pyfirmata คือ ไลบรารีสำเร็จรูปที่ถูกพัฒนาด้วยภาษาไพธอนให้ทำงานอยู่บน host ในที่นี้ เราจะให้มาทำงานบน Raspberry Pi คอยสั่งคำสั่งและรับค่าผ่าน Serial port เมื่อติดต่อกับ Arduino

สิ่งจำเป็นที่เราต้องมี คือ
- สาย USB สำหรับต่อจากบอร์ด Arduino กับ บอร์ด Raspberry Pi
- บอร์ด Raspberry Pi ที่เชื่อมต่อกับอินเตอร์เนต เพื่อดาวน์โหลด ติดตั้ง package pyfirmata
- บอร์ด arduino รุ่นใดก็ได้ ในที่นี้ ผมใช้ Arduino Duemilanover w/ATmega328

อันดับแรกให้ทำการติดตั้ง pyfirmata ลงบนบอร์ด Raspberry pi แต่เนื่องจากา pyfirmata นั้น ต้องการ python-serial โมดูลทำงานร่วมด้วย หากใครยังไม่เคยติดตั้ง จะต้องทำการติดตั้ง python-serial ก่อน  (ดูการติดตั้ง python-serial http://raspberry-pi-th.blogspot.com/2012/10/how-to-communicate-raspberry-pi-s.html)  และเนี่องจาก package pyfirmata ถูกเก็บไว้แบบ mecurial distributed source control เพราะฉะนั้นก่อนติดตั้ง เราจะต้องต้องติดตั้ง mecurial package ของ debian ซะก่อน ด้วยคำสั่ง

sudo apt-get mercurial

เมื่อ Raspberry Pi ของเรามี python-serial และ mecurial เรียบร้อยแล้ว จากนี้ เราก็จะทำการติดตั้ง pyfirmata ด้วยคำสั่ง

hg clone https://bitbucket.org/tino/pyfirmata

เราจะได้โฟวเดอร์ pyfirmat มา จากนั้น เข้าไปในโฟวเดอร์ดังกล่าว

cd pyfirmata

แล้วติดตั้ง

sudo python setup.py install

หากไม่มีอะไรผิดพลาด เราน่าจะเรียกโมดูลนี้ได้ โดยเมื่อเราเข้าไปใช้ใน python console น่าจะเห็น function ต่างๆ ใน pyfirmata

sudo python
>>> import pyfirmata
>>> dir(pyfirmata)
['ANALOG', 'ANALOG_MESSAGE', 'Arduino', 'ArduinoMega', 'BOARDS', 'Board', 'DIGITAL', 'DIGITAL_MESSAGE', 'DIGITAL_PULSE', 'END_SYSEX', 'I2C_CONFIG', 'I2C_REPLY', 'I2C_REQUEST', 'INPUT', 'InvalidPinDefError', 'NoInputWarning', 'OUTPUT', 'PWM', 'Pin', 'PinAlreadyTakenError', 'Port', 'QUERY_FIRMWARE', 'REPORT_ANALOG', 'REPORT_DIGITAL', 'REPORT_FIRMWARE', 'REPORT_VERSION', 'SAMPLING_INTERVAL', 'SERVO', 'SERVO_CONFIG', 'SET_PIN_MODE', 'SHIFT_DATA', 'START_SYSEX', 'STRING_DATA', 'SYSEX_NON_REALTIME', 'SYSEX_REALTIME', 'SYSTEM_RESET', 'UNAVAILABLE', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', '__version__', 'boards', 'inspect', 'itertools', 'pyfirmata', 'serial', 'time', 'to_two_bytes', 'two_byte_iter_to_str', 'util']
>>>

แสดงว่าเราติดตั้ง pyfirmata สมบูรณ์แหละ ที่เหลือก็คือ ดูจาก tutorial และ exmaple การใช้งานของมัน

กลับมาที่บอร์ด Arduino เราจำเป็นจะต้องมีโค๊ดที่ทำหน้าที่รับคำสั่งจาก pyfirmata ที่มีรูปแบบโปรโตคอลเฉพาะที่ตรงกัน เพื่อทำหน้าที่รับ ส่ง คำสั่ง ระหว่าง pyfirmata ที่รันอยู่บน Raspberry Pi และ firmata ที่รันอยู่บน Arduino ซึ่งในส่วนของ Arduino ได้มีตัวอย่างของ firmata รวบรวมมาพร้อมอยู่แล้ว กับ Arduio IDE เวอร์ชั่นใหม่ๆ  ให้เราต่อบอร์ด Arduino เข้ากับคอมพิวเตเอร์ของเรา แล้วทำการเลือกตัวอย่าง StandardFirmata จากเมนู File>>Examples>>Firmata จากนั้นทำการ  verify โค๊ดก่อน หากไม่มีอะไรผิดพลาดเกิดขึ้น ก็ให้เราทำการ upload เพื่อทำการ burn hex file ลงบนบอร์ด arduino

 

กลับไปที่บอร์ด Raspberry Pi เราจะทำการสร้างไฟล์ทดสอบการทำงานด้วย python เพื่อทำการทดสอบ pyfirmata ว่าจะสามารถติดต่อกับบอร์ด arduino ได้หรือเปล่า โดยให้เราสร้างไฟล์ขึ้นมาทดสอบ โดยเรียกโปรแกรม nano เพื่อสร้างไฟล์ blink.py

ทำการบันทึก (Ctrl+x) กด y เพื่อยืนยัน จากนั้น นำบอร์ด Arduino (ที่ผ่านการโปรแกรม เรียบร้อยแล้ว) มาเสียบด้วยสาย USB เข้าที่พอร์ต USB ของ Raspberry Pi  หากใช้คำสั่ง tail –f  /var/log/message จะพบว่า Raspberry pi มองเห็นบอร์ด arudino เป็น ttyUSB0 (ซึ่งเราได้นำค่านี้ไปกำหนดลงในโปรแกรม blink.py ด้วย) เมื่อทุกอย่างเรียบร้อยแล้ว ให้ลองทำการสั่ง python blink.py แล้วดูผลลัพธ์ที่หลอด LED13 ที่บอร์ด arduino จะเห็นว่า เกิดการติดดับ สลับกัน 2 ครั้ง เป็นไปตามโค๊ดที่เราเขียน

สรุปกันอีกครั้ง

1. ติดตั้ง pyfirmata lib ลงบน raspberry pi
2. โปรแกรม firmata standard ลงบนบอร์ด arduino
3. เขียนโค๊ด blink.py ลงบน Raspberry pi
4. ต่อสาย USB ระหว่างบอร์ด Raspberry Pi และบอร์ด Arduino
5. ทดสอบโค๊ด และดูผลลัพธ์ที่ได้

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

ขอให้สนุกกับ Raspberry Pi และ Arduino ครับ

อ่านเพิ่มเติม...

How to communicate Raspberry Pi ‘s serial port by python-serial module

    จากตอนที่แล้ว (คลิก) เราสามารถที่จะติดต่อ และเข้าใช้ Raspberry Pi ผ่านทาง Serial Communication ของ บอร์ด Raspberry Pi แล้ว ซึ่งในการพัฒนาโปรแกรม บางครั้งเราจะต้องทำการติดต่อกับอุปกรณ์ภายนอกบอร์ด Raspberry Pi ผ่านทาง Serial Communication เช่น ถ้าเราต้องการให้ Raspberry Pi ทำการอ่านค่า GPS module ซึ่งต้องการ การสื่อสารผ่าน UART นั้น เราก็จำเป็นที่จะต้องพัฒนาโปรแกรมให้เรียกความสามารถของ Serial Port มาใช้งาน

สำหรับระบบ Device File (ถ้ามีโอกาสจะได้มาอธิบายอีกที) ของ Raspberry Pi แล้ว Serial Port ของมันจะมองเป็น /dev/ttyAMA0 นั่นเป็นตำแหน่งไฟล์ที่จัดการเกี่ยวกับการรับส่งข้อมูล แบบ Serial Communication ถ้าจะเปรียบเทียบกับ windows แล้ว /dev/ttyAMA0 ก็เปรียบเสมือน COM1, COM2,.... นั่นเอง ซึ่งเรามักใช้เป็นตัวอ้างอิงในการติดต่อสื่อสารแบบ Serial Communiction แบบ Asyncronous หรือที่เราเข้าใจว่า ติดต่อแบบ RS232 นั่นแหละ

อ้างอิงกลับไปตอนที่แล้ว เราสามารถเรียกใช้งาน console ผ่าน Serial Port ของ raspberry Pi ได้ ซึ่งหากเราต้องการที่จะใช้ Serial Port ของ Raspberry Pi เพื่อไปติดต่อ รับส่งข้อมูล กับ Device อื่นๆ เช่น GPS module หรือบอร์ดไมโครคอนโทรลเลอร์ Arduino (ซึ่งจะได้ทดลองต่อไปในอนาคต) เราจะต้องทำการปิดช่องทางการ login ผ่าน serial port ตัวนี้เสียก่อน โดยเข้าไปแก้ไขไฟล์ /etc/inittab

คำสั่ง sudo nano /etc/inittab

จากนั้นมองหาบรรทัดล่างสุดที่เขียนว่า T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100 ให้ทำการคอมเม้นต์ด้วยเครื่องหมาย "#" จะได้
#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

ขอบคุณแหล่งข้อมูลจาก http://codeandlife.com

ทำการบันทึกไฟล์ และ reboot ระบบก่อน 1 คร้่ง (ด้วยคำสั่ง sudo reboot)

เมื่อเราทราบตำแหน่งที่จะติดต่อกับ Raspberry Pi แบบ Serial แล้ว ต่อไป เราก็ต้องมองหา library หรือภาษาที่จะใช้พัฒนาโปรแกรม ในทีนี้ ผมจะขอยกตัวอย่างการใช้ python package ตัวหนึ่ง ซึ่งชื่อ python-serial ในการพัฒนาโปรแกรมสำหรับติดต่อกับ Serial Port ซึ่งสำหรับ Debian แล้ว เราสามารถติดตั้ง package นี้ ได้ด้วยคำสั่ง

sudo apt-get install python-serial

รอสักครู่จนโปรแกรมติดตั้งเสร็จ จากนั้น ตรวจสอบว่า python ของเรา สามารถที่จะเรียก package นี้เข้ามาทำงานได้จริง โดยเราจะทดสอบด้วยการเรียก python interpreter แล้วจึงทำการ import serial  package เข้ามาร่วมด้วย
เรียก python interpreter ด้วยคำสั่ง
sudo python

>>>import serial
>>>dir(serial)

ถ้า python แสดงรายละเอียดของ package นี้ได้ ก็แสดงว่าเราสามารถเรียกใช้ python-serial ได้ แล้วก็จะสามารถพัฒนาโปรแกรมสำหรับติดต่อ Serial Port ของ Raspberry Pi ได้เช่นกัน (ขึ้นอยู่กับความสามารถทาง Python Programming ของเราแล้วหล่ะ)

ต่อมา เราก็มาทำการทดสอบโปรแกรมง่ายๆ เพื่อติดต่อสื่อสารผ่าน Serial Port ของ Raspberry Pi ด้วยภาษาไพธอนก่อน จากตอนที่แล้ว ผมได้ใช้ UCON-UART ของบริษัท Inex ในการติดต่อสื่อสารแบบ RS232 ไปแล้ว (หากมีโอกาส จะได้ลองติดต่อกับ GPS module ต่อไป) มาในตอนนี้ ก็ยังน่าจะใช้ UCON-UART เหมือนเดิม เพื่อให้เกิดความแน่ใจก่อนว่า python-serial สามารถที่จะส่งข้อมูลออกทาง Serial Port ของ Raspberry Pi ได้จริง ทำการต่อวงจรเหมือนเดิมครับ

ใช้คำสั่ง nano rs232.py เพื่อสร้างไฟล์โค๊ด python ของเรา

#! /usr/bin/python
import serial
import string

ser = serial.Serial('/dev/ttyAMA0',115200,timeout=1)
ser.open()
ser.write('What do you want to send\n')

def readLine(ser):
    str = ""
    while 1:
        ch = ser.read(1)
        if(ch == '\n' or ch == '\r' or ch == ''):
            break
        str += ch

    #"print "str = " + str

    return str

while True:
    line =  readLine(ser)
    try:
        if line == 'stop':
            print 'stop communication'
            print 'Good bye!!!'
            ser.close()
            break
        else:
            if len(line) > 0:
                ser.write(line + '\n')
                line = ''
    except KeyboardInterrupt:
        ser.close()
        print 'Good bye!!!'
        raise

บันทึกไฟล์แล้วแล้วเปลี่ยนโหมดให้สามารถ execute ได้ด้วยคำสั่ง sudo chmod 755 rs232.py

ทางฝั่งคอมพิวเตอร์ของเรา มองหาโปรแกรมที่รับส่งข้อมูลผ่าน Serial Communication ในที่นี้ ผมใช้ Serial Monitor ที่ติดมากับ Arduino IDE  กำหนด BaudRate 115200 แล้วกำหนดให้มีการส่ง newline แนบท้ายข้อความที่เราส่งไปด้วย จากนั้น กลับที่ Raspberry Pi แล้วรันโปรแกรมที่เราได้พิมพ์ไป ด้วยคำสั่ง sudo ./rs232.py
ทางฝั่ง Raspberry Pi จะรอรับตัวอักษรจากคอมพิวเตอร์ของเรา 
ส่วนทางฝั่งคอมพิวเตอร์จะปรากฏข้อความ  "What do you want to send" ที่ Serial Monitor

ทดลองพิมพ์ข้อความจาก Serial Monitor ไปหา Raspberry Pi จากนั้นจะปรากฏข้อความที่เราพิมพ์ไปแล้วกลับมาที่ Serial Monitor (ฝั่งรับข้อมูล) หากต้องการหยุดการสื่อสาร Serial Communication ให้เราพิมพ์คำว่า stop โปรแกรมทางฝั่ง Raspberry Pi จะหยุดการเชื่อมต่อ และปิด serial port

จากตัวอย่างนี้ เราสามารถนำไปประยุกต์เพื่อให้ Raspberry Pi ติดต่อกับ Device อื่นๆ ที่มีรูปแบบการสื่อสารแบบ UART ได้

สำหรับวันนี้ สวัสดีครับ

อ่านเพิ่มเติม...

How to communicate w/ Raspberry Pi via USB to Serial

      ในบางครั้ง หากเราไม่สะดวกที่จะรีโมทเข้าใช้ Raspian ผ่านทาง SSH (ซึ่งจะต้องต่อสาย network ระหว่างบอร์ดเข้ากับระบบ network) เราสามารถที่จะรีโมทเข้าใช้ Raspian ผ่านทาง Serial Communication ได้ ในที่นี้ ผมจะสาธิตการติดต่อกับบอร์ด Raspberry Pi ผ่านทาง Serial Communication ของ Raspberry Pi (Tx,Rx,GND pin) ต่อกับบอร์ด UCON-UART ของบริษัท Inex

คำเตือน - เนื่องจาก GPIO ของ Raspberry Pi นั้น ต่อเข้ากับ CPU ของมันโดยตรง ซึ่งรับแรงดันไฟฟ้าได้เพียง 3.3V เท่านั้น เพราะฉะนั้น จะต้องมั่นใจว่าระดับแรงดันที่ต่อเข้ากับ GPIO pin นั้นจะต้องอยู่ในระดับแรงดัน 3.3V

ในที่นี้ บอร์ด UCON-UART นั้นสามารถที่จะเซตจั้มเปอร์ให้ระดับแรงดันสื่อสาร 3.3V ได้ ซึ่งทำให้ผมแทบไม่ต้องมีวงจรแปลงระดับแรงดันไฟอื่นๆ เข้ามาเกี่ยวข้อง แต่ถ้าหากเพื่อนๆ ไม่สามารถหา UCON-UART ได้ ก็ยังสามารถที่จะใช้ MAX3232CPE ซึ่งให้แรงดันสื่อสาร Serial Comm 3.3V ได้เช่นกัน

รูปประกอบจาก http://codeandlife.com

ทำการเชื่อมวงจรตามรูปข้างล่าง โดยต่อสายสัญญาณดังนี้

Raspberry Pi    UCON-UART
       RX ---------------------TX
       TX ---------------------RX
     GND--------------------GND

จากนั้นทำการเปิดหน้าต่างโปรแกรม Putty แล้วทำการตั้งค่าการเชื่อมต่อ ตามรูป

เพื่อให้มั่นใจ เราควรกำหนดค่า setting

Speed (buad) : 115200
Data bits        : 8
Stop bits        : 1
Parity            : None
Flow control   : None

แล้วกด Open เปิดการเชื่อมต่อทิ้งไว้ จากนั้น ทำการจ่ายไฟเข้าบอร์ด Raspberry Pi รอสักครู่ จะปรากฏข้อความตอน Boot ระบบผ่านหน้าต่าง Putty ของเรา

ปล. หากมีการเชื่อมต่อที่ขา Tx ของ Raspberry Pi ก่อนจ่ายไฟให้บอร์ด Raspberry Pi แล้ว เราจะไม่สามารถสือสารกับบอร์ด Raspberry Pi ผ่านทาง SSH ได้

 

ข้อเสีย ของวิธีนี้ คือ เราไม่สามารถเปิดหน้าต่างการเชื่อมต่อได้มากกว่า 1 หน้าต่าง ซึ่งไม่เหมือนกับวิธี SSH

แต่อย่างน้อย เราก็มีอีกทางเลือกในการเข้ารีโมทเข้าไปที่บอร์ด Raspberry PI

สวัสดีครับ

อ่านเพิ่มเติม...

Simple Home Security System By Raspberry Pi

วันนี้ เรามาลองสร้างระบบเตือนภัยจากผู้บุกรุก โดยเราจะให้เจ้าบอร์ด Raspberry Pi ของเราทำการส่งเมล์ไปหาเรา ถ้ามีใครสักคนพยายามงัดแงะหน้าต่าง หรือประตูของเรา หรือจะเช็คจุดไหนก็ได้ ที่สามารถต่อสวิทช์ หรืออุปกรณ์ตรวจสอบใดๆ ก็ได้ที่ทำให้เกิดการเปลี่ยนแปลง logic จาก Low ไป High เพื่อที่เราจะได้ต่อเข้ากับ GPIO ของบอร์ด Raspberry Pi เมื่อเกิดการเปลี่ยนแปลงสถานะ logic ณ จุดใดๆ ที่ต่ออยู่กับ GPIO ของ Raspberry Pi แล้ว ให้เจ้าบอร์ด Raspberry Pi ของเราส่งเมล์มาบอกเรา เพียงเท่านี้ เราก็จะได้ระบบรักษาความปลอดภัย ที่กินไฟน้อยที่สุดในโลกแล้ว (อาจจะฟังดูเวอร์ไปเล็กน้อย :P )
อันนี้ เป็นวงจรการทำงานพื้นฐานนะครับ แน่นอน ถ้าจะทำจริงๆ ก็ต้องดัดแปลง ปรับปรุงให้เกิดความเสถียรภาพมากกว่านี้ ไม่ว่าจะเป็นระบบสำรองไฟฟ้า หากเกิดกรณีไฟฟ้าดับ และระบบป้องกันไฟเกิน และอื่นๆ อีกที่ควรจะใส่เข้าไป เพื่อให้ระบบเราทำงานได้ แม้ในสภาวะที่ไม่ปกติด้วยนะครับ ก็ลองไปคิดๆ กันดูว่าต้องมีอะไรบ้าง

ในที่นี้ ผมจะสมมติให้ push button ทำหน้าที่เป็นสวิทช์ประตู เมื่อมีการเปลี่ยน logic จาก high เป็น low ให้ raspberry Pi ทำการเริ่มส่งเมล์ มาตามที่กำหนดไว้ในโค๊ด

ด้วยความสามารถของ Python เราสามารถที่จะเรียก package smtplib เพื่อติดต่อกับ mail server (ในที่นี้ ผมต้องการติดต่อกับ mail server ของ Gmail ) แล้วทำการส่งข้อความไปที่ inbox ของ mail ปลายทางที่เราต้องการได้ (ซึ่งนั่น น่าจะเป็นเมล์ของเรานะครับ) เรามาดูโค๊ดกันเลยครับ
สร้างไฟล์นี้ด้วยคำสั่ง nano mail.py
แล้วเขียนโค๊ดตามข้างล่างนี้ (ระวังเรื่อง indent ด้วยนะครับ สำหรับภาษาไพธอนเราจะใช้การ indent เป็นตัวจัดกลุ่มของคำสั่ง )
#--------------------------- Code start here ------------------------------------------------
#! /usr/bin/python
import RPi.GPIO as GPIO
import smtplib
import time
LOOP = True
GPIO.setmode(GPIO.BOARD)
GPIO.setup(26,GPIO.IN,pull_up_down=GPIO.PUD_UP)
SMTP_SERVER = 'smtp.gmail.com'
SMTP_PORT = 587
sender = 'raspberry security system'
recipient = 'wisit.paewkratok@gmail.com'
subject = 'Raspberry Pi Alert System'
body  = 'The door is opned!!!'
headers = ["From: " + sender,
           "Subject: " + subject,
           "To: " + recipient,
           "MIME-Version: 1.0",
           "Content-Type: text/html"]
headers = "\r\n".join(headers)
username = ‘ชื่อล๊อกอินของ Gmail'
password = 'พาสเวิร์ดสำหรับ Gmail'
while True:
    if(GPIO.input(26) == False):
        print('Mail alert sending....\n')
        server = smtplib.SMTP(SMTP_SERVER,SMTP_PORT)
        server.ehlo()
        server.starttls()
        server.ehlo()
        server.login(username,password)
        server.sendmail(sender,recipient,headers + "\r\n\r\n" + body)
        server.quit()
        GPIO.cleanup()
        LOOP = False
        print('Program terminated\n\n')
        break
    time.sleep(1)
    print('program is running ' + time.ctime() )
#----------------------------------- End Code ----------------------------------------------------------
ทำการบันทึกไฟล์ แล้วทำการเปลี่ยนให้ไฟล์นี้สามารถ execute ได้ ด้วยคำสั่ง
sudo chmod 755 mail.py
แล้วทำการทดลองรันสคริปต์ไพธอน ด้วยคำสั่ง
sudo ./mail.py

 

ถ้าทุกอย่างถูกต้อง เราจะพบเมล์ในกล่องขาเข้าของจดหมาย จาก raspberry security system

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

อ่านเพิ่มเติม...

Raspberry Pi show text message via LCD 16x2 module

วันนี้ เรามาลองต่อ LCD 16x2 กับบอร์ด Raspberry Pi กันดูครับ อย่างที่ทราบกันอยู่แล้ว ว่าบอร์ด Raspberry Pi เรามี GPIO อยู่ ซึ่งเราสามารถที่จะควบคุมเจ้า GPIO ให้เกิด Logic Hi Low ได้ตามใจ ผ่าน  RPi.GPIO ซึ่งเขียนด้วยภาษาไพธอน จากจุดนี้เอง เมื่อเรานำลำดับการสร้างสัญญาณดิจิตอล ให้สอดคล้องกับลำดับการควบคุมการสั่งงานให้ LCD 16x2 แล้วหล่ะก็ เราก็จะสามารถที่จะควบคุมตัวอักษรให้ปรากฏที่หน้าจอ LCD 16x2 ได้เช่นกัน (จริงๆ หลักการนี้ ก็ใช้ในการสร้าง Library สำหรับติดต่อจอ LCD 16x2 ด้วยไมโครคอนโทรลเลอร์ตระกูลอื่นๆ เช่นกัน)
ในที่นี้ ผมขอเอาตัวอย่างการแสดงการควบคุมจอ LCD16x2 ด้วย RPi.GPIO จาก Matt Hawkins เลยหล่ะกันครับ เรามาลองต่อวงจรตามรูปด้านล่างกันครับ แต่ในที่นี้ผมไม่ได้ต่อ Transistor เข้ากับขา Anode ของจอ LCD แต่ผมต่อขา Anode ของจอ LCD เข้ากับไฟ 5 V ของ Raspberry Pi เลย

จากนั้น ทำการเขียนโค๊ด ตามนี้  จะเขียนที่ PC ของเราก็ได้ แล้วค่อยอัพโหลดเข้าไปที่บอร์ดผ่าน FTP หรือจะไปเขียนที่บอร์ด Raspberry Pi ผ่าน SSH ก็ได้ครับ ถนัดแบบไหน ก็เอาเลยครับ
#--------------------------  Code start here  ------------------------------------------------------
#!/usr/bin/python
#
# HD44780 LCD Test Script for
# Raspberry Pi
#
# Author : Matt Hawkins
# Site   : http://www.raspberrypi-spy.co.uk
#
# Date   : 03/08/2012
#
# The wiring for the LCD is as follows:
# 1 : GND
# 2 : 5V
# 3 : Contrast (0-5V)*
# 4 : RS (Register Select)
# 5 : R/W (Read Write)       - GROUND THIS PIN
# 6 : Enable or Strobe
# 7 : Data Bit 0             - NOT USED
# 8 : Data Bit 1             - NOT USED
# 9 : Data Bit 2             - NOT USED
# 10: Data Bit 3             - NOT USED
# 11: Data Bit 4
# 12: Data Bit 5
# 13: Data Bit 6
# 14: Data Bit 7
# 15: LCD Backlight +5V**
# 16: LCD Backlight GND
#import
import RPi.GPIO as GPIO
import time
# Define GPIO to LCD mapping
LCD_RS = 7
LCD_E  = 8
LCD_D4 = 25
LCD_D5 = 24
LCD_D6 = 23
LCD_D7 = 18
LED_ON = 15
# Define some device constants
LCD_WIDTH = 16    # Maximum characters per line
LCD_CHR = True
LCD_CMD = False
LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line
LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line
# Timing constants
E_PULSE = 0.00005
E_DELAY = 0.00005
def main():
  # Main program block
  GPIO.setmode(GPIO.BCM)       # Use BCM GPIO numbers
  GPIO.setup(LCD_E, GPIO.OUT)  # E
  GPIO.setup(LCD_RS, GPIO.OUT) # RS
  GPIO.setup(LCD_D4, GPIO.OUT) # DB4
  GPIO.setup(LCD_D5, GPIO.OUT) # DB5
  GPIO.setup(LCD_D6, GPIO.OUT) # DB6
  GPIO.setup(LCD_D7, GPIO.OUT) # DB7
  GPIO.setup(LED_ON, GPIO.OUT) # Backlight enable
  # Initialise display
  lcd_init()
  # Toggle backlight on-off-on
  GPIO.output(LED_ON, True)
  time.sleep(1)
  GPIO.output(LED_ON, False)
  time.sleep(1)
  GPIO.output(LED_ON, True)
  time.sleep(1)
  # Send some centred test
  lcd_byte(LCD_LINE_1, LCD_CMD)
  lcd_string("Rasbperry Pi",2)
  lcd_byte(LCD_LINE_2, LCD_CMD)
  lcd_string("Model B",2)
  time.sleep(3) # 3 second delay
  # Send some left justified text
  lcd_byte(LCD_LINE_1, LCD_CMD)
  lcd_string("1234567890123456",1)
  lcd_byte(LCD_LINE_2, LCD_CMD)
  lcd_string("abcdefghijklmnop",1)
  time.sleep(3) # 3 second delay
  # Send some right justified text
  lcd_byte(LCD_LINE_1, LCD_CMD)
  lcd_string("Raspberrypi-spy",3)
  lcd_byte(LCD_LINE_2, LCD_CMD)
  lcd_string(".co.uk",3)
  time.sleep(30)
  # Turn off backlight
  GPIO.output(LED_ON, False)
def lcd_init():
  # Initialise display
  lcd_byte(0x33,LCD_CMD)
  lcd_byte(0x32,LCD_CMD)
  lcd_byte(0x28,LCD_CMD)
  lcd_byte(0x0C,LCD_CMD) 
  lcd_byte(0x06,LCD_CMD)
  lcd_byte(0x01,LCD_CMD) 
def lcd_string(message,style):
  # Send string to display
  # style=1 Left justified
  # style=2 Centred
  # style=3 Right justified
  if style==1:
    message = message.ljust(LCD_WIDTH," ") 
  elif style==2:
    message = message.center(LCD_WIDTH," ")
  elif style==3:
    message = message.rjust(LCD_WIDTH," ")
  for i in range(LCD_WIDTH):
    lcd_byte(ord(message[i]),LCD_CHR)
def lcd_byte(bits, mode):
  # Send byte to data pins
  # bits = data
  # mode = True  for character
  #        False for command
  GPIO.output(LCD_RS, mode) # RS
  # High bits
  GPIO.output(LCD_D4, False)
  GPIO.output(LCD_D5, False)
  GPIO.output(LCD_D6, False)
  GPIO.output(LCD_D7, False)
  if bits&0x10==0x10:
    GPIO.output(LCD_D4, True)
  if bits&0x20==0x20:
    GPIO.output(LCD_D5, True)
  if bits&0x40==0x40:
    GPIO.output(LCD_D6, True)
  if bits&0x80==0x80:
    GPIO.output(LCD_D7, True)
  # Toggle 'Enable' pin
  time.sleep(E_DELAY)   
  GPIO.output(LCD_E, True) 
  time.sleep(E_PULSE)
  GPIO.output(LCD_E, False) 
  time.sleep(E_DELAY)     
  # Low bits
  GPIO.output(LCD_D4, False)
  GPIO.output(LCD_D5, False)
  GPIO.output(LCD_D6, False)
  GPIO.output(LCD_D7, False)
  if bits&0x01==0x01:
    GPIO.output(LCD_D4, True)
  if bits&0x02==0x02:
    GPIO.output(LCD_D5, True)
  if bits&0x04==0x04:
    GPIO.output(LCD_D6, True)
  if bits&0x08==0x08:
    GPIO.output(LCD_D7, True)
  # Toggle 'Enable' pin
  time.sleep(E_DELAY)   
  GPIO.output(LCD_E, True) 
  time.sleep(E_PULSE)
  GPIO.output(LCD_E, False) 
  time.sleep(E_DELAY)  
if __name__ == '__main__':
  main()
#-------------------------- Ending Code ------------------------------------------------------
แก้ไข หรือ เพิ่ม ตามใจชอบ อาจจะเพิ่ม time.sleep(2) ระหว่างชุดข้อความก็ได้ครับ
lcd_byte(LCD_LINE_1, LCD_CMD)
lcd_string("1234567890123456",1)
lcd_byte(LCD_LINE_2, LCD_CMD)
lcd_string("abcdefghijklmnop",1)
time.sleep(2)
ทำการบันทึกไฟล์ (ในที่นี้ผมให้เป็นชื่อไฟล์ lcd.py)  แล้วเปลี่ยนโหมดไฟล์ให้สามารถ execute ได้ด้วย คำสั่ง
sudo chmod 744 lcd.py
แล้วทำการรันไฟล์นี้ ด้วยคำสั่ง (ให้อยู่ใน folder เดียวกันกับไฟล์ที่อยู่)
sudo ./lcd.py  
สังเกตสิ่งที่เกิดขึ้นหน้าจอ LCD ครับ

เราจะเห็นแนวทางการพัฒนา library สำหรับการติดต่อกับอุปกรณ์อื่นๆ โดยใช้ความสามารถของ RPi.GPIO บวกกับการจัดลำดับสัญญาณไฟฟ้าให้เป็นไปตาม data sheet ของอุปกรณ์แต่ละตัว เราก็จะสามารถควบคุมอุปกรณ์ตัวนั้นได้แล้วครับ เพื่อนๆ ลองนำไปประยุกต์ใช้กันดูนะครับ

ปล.ขอบคุณภาพประกอบบางส่วน และโค๊ดจาก http://www.raspberrypi-spy.co.uk

อ่านเพิ่มเติม...

How to mount USB Flash Drive with Raspberry Pi

     โดยปกติแล้วที่บอร์ด Raspberry Pi จะมี USB port สำหรับต่อกับ Device ต่างๆ อยู่ 2 port ด้วยกัน หากเราไม่ได้ต่อ Keyboard และ Mouse แบบ USB เข้ากับ พอร์ตนี้ แล้ว ก็จะทำให้ USB Port ทั้งสอง Port นี้ว่างอยู่ เราสามารถหาอุปกรณ์อย่างอื่นมาต่อได้ ในตอนนี้ เราจะมาเพิ่มพื้นที่หน่วยความจำให้กับเจ้า Raspberry Pi ด้วยการเพิ่ม USB Flash Drive ให้กับเจ้า Raspberry Pi ขั้นตอนไม่ยากครับ ง่ายๆ

เพื่อให้มั่นใจว่าระบบมองเห็น USB Flash Drive ที่เสียบเข้ามาจริง เราจะทำการเช็คที่ /var/log/message โดยที่โฟลเดอร์นี้ จะทำการเก็บข้อความ (log message) ระบบที่เกิดขึ้น ซึ่งประกอบไปด้วยข้อความแจ้งว่ามีการส่งเมล์ออกไป, ข้อความแสดงการทำงานของ Cron service , ข้อความของ Kern , ข้อความแสดงการล๊อกอินจาก user อื่นๆ และข้อความแจ้งเตือนว่ามีอุปกรณ์อย่างอื่นพ่วงต่อเข้ามา ซึ่งนั่นเป็นสิ่งที่เรากำลังมองหาอยู่

โดยทั่วไป Linux จะมองเห็น USB Flash Drive เป็น sda1  ที่นี้ เราก็จะมองหา sda1 ที่ /var/log/message โดยใช้คำสั่ง tail เพื่อของดูเนื้อหาตอนท้ายๆ ของไฟล์ message (เนื่องจากไฟล์นี้จะถูกเขียนลงไปเรื่อยๆ ที่บรรทัดสุดท้าย หากมี message จากจุดต่างๆ ของระบบส่งเข้ามา) 

ใช้คำสั่ง เพื่อดู message ที่เข้ามาล่าสุดใน /var/log/message ด้วยคำสั่ง

sudo tail -f /var/log/message

 

ทำการเสียบเจ้า USB Flash Drive ของเราเข้ากับช่องเสียบ USB ของบอร์ด Raspberry Pi สังเกตที่หน้าจอ terminal นี้ จะพบว่า message มีการเปลี่ยนแปลง และถ้า USB Flash Drive เราไม่เสีย จะพบว่า Raspberry Pi มองเห็นเจ้า USB Flash Drive ของเราแล้ว ให้กด Ctrl+C เพื่อหยุดการดู message ได้ครับ

ต่อไปเราจะต้องทำการสร้าง directory เปล่าๆ ขึ้นมา เพื่อทำการ mount ให้เจ้า USB Flash Drive ของเราเข้ากับ Directory นั้น พูดง่ายๆ ก็คือ ทำให้ Directory นั้นกลายเป็น USB Flash Drive นั่นเอง 

ใช้คำสั่ง สร้าง directory ที่ชื่อ usbdisk (หรือจะชื่ออื่นๆ ก็ได้นะครับ) ขึ้นมา ในที่นี้ผมจะเก็บไว้ภายใต้โฟวเดอร์ /media นะครับ

sudo mkdir /media/usbdisk

เสร็จแล้ว เราจะทำการ mount hardware คือ เจ้า USB Flash Drive เข้ากับโฟวเดอร์นี้ ด้วยคำสั่ง

sudo mount -t vfat -o uid=pi,gid=pi /dev/sda1 /media/usbdisk/

ตอนนี้ เราจะได้โฟวเดอร์ usbdisk เป็นที่เก็บทุกอย่างเท่าที่ USB Flash Drive มี ลองเข้าไปดูครับ จะเจอไฟล์ที่เราเก็บไว้ที่ USB Flash Drive

 

เราก็จะได้พื้นที่เพิ่มเติม นอกเหนือจาก SD-Card ที่เรามี แต่เป็นพื้นที่ที่สามารถเคลื่อนย้ายได้ มีอย่างหนึ่งที่ต้องบอกไว้ก็คือ ทุกครั้งที่เราจะทำการ ถอด USB Flash Drive ออกจากบอร์ด Raspberry Pi เราจะต้องทำตรงกันข้ามกับคำสั่ง mount นั่นคือคำสั่ง umount

ก่อนถอด USB Flash Drive เราจะใช้คำสั่ง umount ไปที่ Directory ที่เรา mount ไว้

sudo umount /media/usbdisk

จากนั้น เราจะทำการลบ usbdisk ด้วยก็ได้ หรือจะปล่อยไว้แบบนี้ก็ได้ ครับ ไม่มีปัญหา เพราะเราได้ umount ออกไปแล้ว

เพื่อนๆ อาจจะนำไปประยุกต์ใช้ในการเก็บข้อมูลอีกรูปแบบหนึ่งก็ได้ นอกเหนือจากการเก็บข้อมูลไว้ที่ Database

แล้วพบกันใหม่ครับ ^^

อ่านเพิ่มเติม...

Raspberry Pi Play MP3 file

    อย่างที่ทราบกันดี ว่า บอร์ด Raspberry Pi นั้น ได้มีชุด Audio out ติดมาให้พร้อมอยู่แล้ว แต่เรายังไม่ได้เรียกความสามารถตรงนั้นออกมาใช้กันเลย วันนี้เราจะมาทำให้เจ้าบอร์ด Raspberry Pi เล่นเพลง MP3 กันสักหน่อย

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

อันดับแรก ก็ให้เราติดตั้งโปรแกรม alsa-utils หรือ Advanced Linux Sound Architecture Utility คือชุดโปรแกรมที่ทำหน้าที่ติดต่อกับไฟล์เสียง โดยใช้คำสั่งติดตั้ง package alsa-utils

sudo apt-get install alsa-utils

จากนั้นเราต้องการโปรแกรมที่สามารถที่จะเข้าใจ และสั่งให้เล่นไฟล์ MP3 ได้ นั่นก็คือ โปรแกรม  mpg321 นั่นเอง โดยเจ้าโปรแกรมนี้ จะสามารถสั่งให้เล่น หรือ หยุด หรือ เพิ่มเสียง ลดเสียง และอื่นๆ ได้ ด้วยการเพิ่มพารามิเตอร์ผ่าน command line  ให้ทำการติดตั้งโปรแกรมนี้ลงไปด้วยคำสั่ง

sudo apt-get install mpg321

เสร็จแล้วให้ทำการ reboot ก่อนหนึ่งครั้ง ด้วยคำสั่ง sudo reboot (หากเพื่อนๆ ลืม :P )

จากนี้ เราจะต้องทำการเพิ่ม Driver sound เข้าไปใน Kernel ของเจ้า Raspian ซะก่อน ด้วยคำสั่ง modprobe แล้วตามด้วย driver sound ของเรา ด้วยคำสั่ง

sudo modprobe snd-bcm2835

โดยปกติแล้วช่องสัญญาณเสียงนั้น จะออกมาทาง Port  HDMI  ถ้าหากเราต้องการที่จะให้สัญญาณเสียง ย้ายมาออกทางช่อง Audio out ที่มีลักษณะเป็นแจ๊คตัวเมีย หล่ะก็ เราจะต้องกำหนดค่า ด้วยคำสั่ง

sudo amixer cset numid=3 1

ปล. ขอบคุณรูปภาพประกอบจาก http://learn.adafruit.com

ทุกอย่างก็น่าจะเรียบร้อย และบอร์ด Raspberry Pi ของเราก็พร้อมที่จะเล่นไฟล์ MP3 แล้ว  ให้เราทดสอบหาไฟล์ MP3 แล้วทำการ FTP เข้าไปที่บอร์ดของเรา หากยังไม่ได้ทำการตั้งค่าให้บอร์ดของเราติดต่อทาง FTP service ได้ ให้กลับไปทำให้บอร์ดของเรากลายเป็น FTP server ซะ (คลิกดูตอนที่แล้ว)

เมื่อเราโยนไฟล์ MP3 ไปไว้ใน Folder ที่เราต้องการแล้ว ให้เข้าไปที่ folder นั้น แล้วเรียกใช้คำสั่ง mpg321 ไฟล์.mp3  แล้วต่อแจ๊คหูฟังตัวผู้ เข้ากับแจ๊คตัวเมีย จะได้ยินเสียงเพลง และข้อความขึ้นที่หน้าจอ terminal เกี่ยวกับไฟล์เพลงที่เล่นอยู่

ใครที่คิดจะทำตู้เพลง (Jukebox) ก็ลองจินตนาการกันดูนะครับ อาจะให้ RPi.GPIO รับค่าจากสวิทช์ แล้วมาส่งคำสั่งมาเล่นเพลงดูก็ได้นะครับ ก็เป็นโปรเจคที่น่าสนใจไม่น้อยเลย

อ่านเพิ่มเติม...

RPi.GPIO Python control GPIO of Raspberry Pi

     จากในตอนก่อนหน้านี้ เราสามารถที่จะควบคุม GPIO pin ของ Raspberry Pi ด้วย Shell ของ Linux ด้วยการเข้าไปอ่านและเขียนที่ sysfs ซึ่งสามารถมอง GPIO pin ของ Raspberry Pi เป็นเสมือนไฟล์ๆ หนึ่ง ที่เมื่อเราอ่าน และเขียนลงไปแล้ว ก็สามารถที่จะควบคุม GPIO ได้เช่นกัน ซึ่งวิธีนั้น เราก็แค่ทำการเขียน shell script ก็สามารถที่จะสร้างโปรแกรมควบคุม GPIO ได้แล้ว แต่ยังมีวิธีอื่นๆ อีกมากมายที่จะควบคุม GPIO ของ Raspberry Pi อีกวิธีหนึ่งก็คือ การใช้ Library ที่พัฒนามาจากภาษาต่างๆ  ซึ่งภาษาไพธอน เป็นอีกภาษาหนึ่งที่เป็นมิตรกับ Linux และได้มีการพัฒนา library ให้สามารถควบคุม GPIO ได้ โดยใช้ RPi.GPIO
เดิมที Debian Wheezy ที่ติดตั้งมานั้น จะมี Python 2.7.3 ติดมาด้วยอยู่แล้ว เพราะฉะนั้น เราก็แค่ ลง RPi.GPIO เพิ่มเข้าไป ก็สามารถที่จะเรียกใช้ไลบรารี่ชุดนี้ได้แล้ว
หลังจากที่ login ผ่าน SSH แล้ว ทำการโหลดไลบรารี่ชุดนี้ ซึ่งจะถูกบีบอัดไว้ ใน linux นั้น ไฟล์ที่ถูกบีบอัดจะมีนามสกุล .gz 
ดาวน์โหลดไฟล์ จากเว็บ http://pypi.python.org/pypi/RPi.GPIO โดยเราจะเข้าไปเอาลิ้งค์จากหน้าเว็บดังกล่าว

ใช้คำสั่งดาวน์โหลดไฟล์จากลิ้งค์ดังกล่าว
wget http://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.4.1a.tar.gz#md5=9acdb66290350aaa74b99de859ded153

จะได้ไฟล์ RPi.GPIO-0.4.1a.tar.gz  (ณ ตอนนี้ เวอร์ชั่น 0.4.1a)
ทำการแตกไฟล์ ด้วยคำสั่ง
tar zxvf RPi.GPIO-0.4.1a.tar.gz
เราจะได้โฟวเดอร์ RPi.GPIO-0.4.1a ทำการเข้าไปที่โฟวเดอร์นี้
cd RPi.GPIO-0.4.1a
แล้วทำการติดตั้ง ด้วยคำสั่ง
sudo python setup.py install
คำสั่ง setup.py จะทำการนำไฟล์ไปไว้ตาม path ของ package python ถ้าไม่มีอะไรผิดพลาด เราจะสามารถ import package ที่เราติดตั้งเข้าไปในโค๊ดของเราได้
เราจะทำการสร้างโค๊ด เพื่อทดสอบ RPi.GPIO ไลบรารี่ นี้
ทำการเขียนโด๊ดง่ายๆ ด้วย คำสั่งสร้างไฟล์
nano blink.py
เขียนโค๊ดตามที่ปรากฏข้างล่างนี้

หมายเหตุ : จากตอนที่แล้ว เราได้ทำการสั่งควบคุม GPIO7 ด้วย shell script แต่ในไลบรารี RPi.GPIO นั้น ได้ทำการ map pin ที่ไม่เหมือนเดิม เราจะต้องอ้างอิงตามไลบรารี่ ตาม RPi.GPIO ตามนี้

เมื่อเราต่อเข้ากับ GPIO7 จะตรงกับ map pin ที่ 26 ของ RPi.GPIO ซึ่งเมื่อพิจารณที่บอร์ดของ Raspberry Pi แล้ว จะตรงกับ PIN_26 เช่นกัน
ทำการเปลี่ยนโหมด เพื่อทำให้ไฟล์นี้สามารถที่จะ Execute ได้ ด้วยคำสั่ง
chmod +x blink.py
เราจะได้ไฟล์ที่สามารถ Execute ได้ (เหมือนกับไฟล์ exe ของ windows) 
เนื่องจากไฟล์นี้มีการเข้าถึงบางส่วนของ Hardware เพราะฉะนั้นจะต้องรันด้วยคำสั่ง sudo นำหน้าไฟล์ที่จะรัน
sudo ./blink.py 
จะเห็นไฟ LED กระพริบติด-ดับ สลับกัน โดยหน่วงเวลาครึ่งวินาที (  time.sleep(.5)  )  10 ครั้ง แล้วโปรแกรม ก็หยุดทำงาน

เท่านี้ เราก็สามารถที่จะควบคุม GPIO ของ Raspberry Pi ได้แล้ว ทีเหลือก็ขึ้นอยู่กับ Python Programming แล้วหล่ะ

อ่านเพิ่มเติม...

Get to know Raspberry Pi GPIO

    นอกจากเจ้าบอร์ด Raspberry Pi ของเราจะมี Port ต่างๆให้ใช้งานแล้ว ไม่ว่าจะเป็น Port USB , Port Network , Port Audio เป็นต้นแล้ว พอร์ตต่างๆ พวกนี้ ล้วนต่อเข้ากับซีฟไอซีเบอร์ BCM2835 ARM pheriperal ซึ่งทำหน้าที่เป็นแขน เป็นขา เป็นหูเป็นตา เอาไว้ใช้งานของเจ้า CPU แล้ว ที่ไอซีเบอร์นี้ ยังมีช่อง GPIO เหลือ จากการต่อกับพอร์ตเหล่านั้น มาให้เราใช้งานอีก ซึ่งเค้าเหลือไว้สำหรับให้เราเอาไปใช้งานอะไรก็ได้ ตามแต่เราจะนึกอยากใช้ จะสังเกตเห็น Pin ตัวผู้ เรียงเป็นแถวคู่ 2 แถวนั่นแหละครับ เป็นแนว PIN GPIO

 

     GPIO ย่อมาจาก General Purpose Input/Output นั่นก็แปลว่า ขา pin เหล่านี้ มีไว้ใช้ในงานทั่วๆ ไป โดยควบคุมผ่านซอร์ฟแวร์ โดยในที่นี้ เราจะมาดูขา GPIO ของเจ้าบอร์ด Raspberry Pi ของเรานะครับ ส่วนถ้าเป็นบอร์ดอื่นๆ ก็ค่อยมาว่ากันต่อไป ดูรูปข้างล่าง แล้วเทียบกับบอร์ดจริงนะครับ

    ถึงแม้ที่ขั้วต่อ P1 ตำแหน่งที่ P1-02 มีแรงดัน 5 Vdc นั่นก็ไม่ได้หมายความว่า ขา GPIO ที่เหลือจะรับแรงดันได้ 5 Vdc นะครับ ทุกขาของ GPIO สามารถรับแรงดัน หรือจ่ายแรงดันไฟตรง ได้ไม่เกิน 3.3 Vdc เท่านั้น ตรงนี้ ต้องระวังให้ดี เพราะถ้าดูจากลายวงจรของบอร์ดแล้วหล่ะก็ จะพบว่า ตำแหน่งขั้วต่อ P1 นั้น ต่อตรงเข้าไปที่ chip ของ ARM Processor เลย นอกจากเรื่องแรงดันไฟกระแสตรง ที่เราต้องระวังไม่ให้รับไฟเกินแล้ว เรายังต้องระวังเรื่องของไฟฟ้าสถิตย์ที่อยู่รอบๆ ตัวเรา จะชาร์ตเข้าไปที่ขาดังกล่าวด้วย วิธิป้องกัน ก็พยายามสัมผัสที่ขั้วพวกนี้ ให้น้อย หรือไม่ก็ทำขั้วต่อออกมา เป็นพวกสายแพร ที่มีขั้วต่อเป็นแบบพลาสติก เพื่อป้องกันการสัมผัสจากตัวเราไปโดนที่ขาเหล่านี้โดยตรง (หลีกเลี่ยงให้มากที่สุด ว่างั้นเหอะ)

    ในบางตำแหน่ง pin สามารถทำงานในอีกฟังก์ชั่นหนึ่ง สังเกตจากตาราง ที่ช่อง Alt 0 Function จะพบนอกจากจะทำหน้าที่เป็น GPIO แล้ว ยังทำหน้าที่อื่นได้อีกด้วย เช่น I2C , SPI , UART  แต่ไม่มีขาไหนทำหน้าที่ ADC เพื่อรับสัญญาณ Analog เลย เราคงต้องต่อไอซีเพิ่ม หากต้องการอ่านค่าจาก Sensor หรือจาก output ของอุปกรณ์ใดๆ ที่ให้สัญญาณ Analog เข้ามาที่บอร์ด Raspberry Pi

     ทั้งหมดนั่นเป็น GPIO ที่ Raspberry Pi เหลือไว้ให้เราใช้ จริงๆ มันมี GPIO มากกว่านี้ แต่มันถูกนำไปใช้อ่าน SD-Card บ้าง ใช้ทำ HDMI บ้าง ใช้ต่อกับอุปกรณ์อื่นๆ เช่น Port Network , Audio out บ้าง ทำให้เหลือ GPIO ให้เราใช้เพียงเท่านี้ แต่นั่นก็เพียงพอ แล้วหล่ะผมว่านะ ถ้าใครต้องการ GPIO เพิ่มมากกว่านี้ ก็อาจจะใส่ไอซีขยายพอร์ต ที่สื่อสารผ่าน I2C หรือ SPI ก็ได้ เพราะเรามี GPIO พวกที่ติดต่อผ่าน Protocal พวกนี้ได้อยู่แล้ว

    ในการพัฒนาโปรแกรม เพื่อเรียกใช้ GPIO นั้น ตอนนี้ ก็มีหลายๆ คนใช้ภาษา GCC ก็มี ใช้ Python ก็มี หรือแม้แต่จะใช้ความสามารถของ Shell ที่มีอยู่แล้ว คู่กับ Linux มาก็ได้ ในการติดต่อกับ GPIO พวกนี้ ไม่ว่าจะใช้ภาษาใดก็ตาม สุดท้ายแล้ว เรากำลังเล่นกับ Filesystem ที่ชื่อ sysfs ที่อยู่ใน memory ซึ่งเป็นส่วนที่ไว้ติดต่อกับ Kernel ของ Linux นั่นเอง ศึกษาเพิ่มเติมได้จาก "การใช้งาน GPIO บน Embedded Linux" ของท่าน atlantaman ครับ

    ในตอนนี้ ผมจะทดสอบการติดต่อกับ GPIO7 ด้วยคำสั่ง Shell นี่แหละครับ เพื่อให้เกิดความเข้าใจกันก่อน ซึ่งในตอนต่อไป เราคงจะไปเรียกใช้ Lib ที่มีคนทำไว้แล้ว มาใช้งาน น่าจะสะดวกกว่า

    ซึ่งเจ้า sysfs ที่ติดต่อกับ GPIO นั่น จะอยู่ใน folder /sys/class/gpio ใน folder นี้ จะเป็นของ root ครับ เราจะต้องแปลงร่างตัวเองให้กลายเป็น root ก่อน โดยใช้คำสั่ง

su root 

จากนั้นก็ใส่ password ของ root เข้าไป หากจำไม่ได้ หรือยังไม่ได้เปลี่ยน ก็ให้เปลี่ยน password root ซะ ด้วยคำสั่ง

sudo passwd root 

แล้วก็เปลี่ยนตัวเองให้กลายเป็น root สังเกตว่า จะเปลี่ยนจาก $ กลายเป็น # แสดงว่าเรากลายเป็น root แล้ว

เราอาาจะต้องลง package tree เพื่อเรียกใช้คำสั่ง tree เพื่อเอาไว้ดูว่าโครงสร้าง folder เป็นอย่างไร อันนี้จะลง หรือไม่ลง ก็ไม่เกี่ยวกับการสั่ง GPIO นะครับ เพียงแต่มันทำให้เราเห็นโครงสร้าง folder หรือ link file เท่านั้นเอง

ติดตั้ง tree package ใช้คำสั่ง

apt-get install tree (ถ้าเราเป็น root อยู่แล้ว) หรือใช้คำสั่ง
sudo apt-get install tree (หากเราไม่ได้เป็น root ครับ )

เปลี่ยนตัวเองเป็น root แล้วเข้าไปที่

cd /sys/class/gpio

แล้วลองเรียกใช้คำสั่ง tree gpiochip0 ดู ผลลัพธ์ แล้วศึกษาตามลิ้งค์ที่ให้ไปครับ ว่าคล้ายกันไหม

เราจำเป็นต้องสร้าง link file ก่อนครับ เพื่อให้ link file ที่เราสร้าง เชื่อมโยงกับ GPIO7 ก่อน ด้วยคำสั่ง

echo 7 > export

เมื่อเราใช้คำสั่ง ls -la เราจะพบว่า เกิด link file เกิดขึ้น ชื่อ gpio7

ต่อไป ก็กำหนดให้ GPIO7 ทำหน้าที่เป็น output pin ซะ ด้วยคำสั่ง

echo out > gpio7/direction

ตอนนี้ gpio7 ของเรากลายเป็น output pin แล้ว ที่เหลือก็สั่งให้เกิด logic 1,0 เพื่อให้เกิดสัญญาณดิจิตอลที่ขา GPIO7  ด้วยคำสั่ง

echo 1 > gpio7/value
echo 0 > gpio7/value

สังเกตที่บอร์ดของเรา ที่เราได้ต่อ LED อนุกรมกับ R ค่าสักประมาณ 330 - 560 โอห์ม กับหลอด LED ที่หลอดนี้ จะติดดับตามคำสั่งของเรา

อ่านเพิ่มเติม...