Timezone and NTP server Thailand

เราสามารถตั้งค่า Timezone ให้ Raspberry pi ของเราให้เป็น Timezone สำหรับประเทศไทยได้ ด้วยการแก้ไข config

sudo raspi-config

เลือก Internationalisation Options แล้วเลือก  Change Timezone 

จากนั้นเลือก Asia แล้วกด Enter แล้วเลือก Bangkok  Raspberry pi ก็จะปรับเวลาให้ตรงตามเวลาประเทศไทย

เราสามารถที่จะ config ให้ Raspbery pi ไปอัพเดทเวลาจาก NTP server ของประเทศไทยได้ โดยไปแก้ไขที่

sudo nano /etc/ntp.conf

ทำการ comment ของเก่า แล้วเพิ่มของใหม่เข้าไป ตามภาพ  ซึ่งมีรายชื่อ NTP server  ดังนี้

server 0.th.pool.ntp.org iburst
server 1.th.pool.ntp.org iburst
server 2.th.pool.ntp.org iburst
server 3.th.pool.ntp.org iburst

ทำการบันทึกไฟล์ ntp.conf  แล้วทำการ restart ntp service ด้วยคำสั่ง

sudo /etc/init.d/ntp restart 

และใช้คำสั่งเช็คดูการทำงานของ ntpd service และประสิทธิภาพการ sync เวลากับ NTP server

sudo ntpq -c lpeer  

และใช้คำสั่ง date เช็คเวลาดูอีกที ว่าตรงหรือยัง

เราสามารถเช็คการทำงานของ ntpd ได้ ด้วยการดูที่ syslog ด้วยการใช้คำสั่ง

tail –f /var/log/syslog  หากเห็นข้อความ  host name not found EAI_NODATA: 0.th.pool.ntp.org ให้ทำการเช็คที่ resole.conf

sudo nano /etc/resole.conf

แก้ไข nameserver ให้ถูกต้อง ตามรูป  ก็น่าจะโอเค แหละ ให้ restart ntpd service อีกครั้ง  คราวนี้ เวลาของ Raspberry pi ก็จะเดินตรงกับเวลาประเทศไทยแหละ

วันนี้ จบเพียงเท่านี้ ก่อน

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

how to use php commnad “shell_exec” as root in RPi

วันนี้ นำเสนอเทคนิคเล็กน้อย สำหรับการเรียกใช้คำสั่ง root ผ่านหน้าเว็บแอพลิเคชั่น อย่างเช่น php บน RPi

ตัวอย่างปัญหา คือ ผมต้องการตั้งค่า วันเวลา บน Rpi

เช่น ผมต้องการให้มีการแก้ไข เวลาของ RPi  แล้ว ปกติ เราสามารถเรียกใช้คำสั่ง

sudo date --set="15 NOV 2014 12:43:10"   โดยพิมพ์ไปที่ terminal ของ Rpi ได้  แต่ ถ้าเราต้องการทำ web application ให้สามารถแก้ไขเวลาของ RPi หล่ะ เราจะทำอย่างไร

โดยปกติแล้ว php จะสามารถรัน shell_exec แล้วตามด้วย linux command ได้ เช่น

<?php

$output = shell_exec(“ls –l”);

echo “<pre>$output</pre>

?>

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

shell_exec(‘sudo date --set="15 NOV 2014 12:43:10"’);  แบบนี้ เราจะทำไม่ได้ เพราะ ตัวเว็บเพจนี้ ไม่มีสิทธิ์ทำเช่นนั้นได้ วิธีแก้ไข ก็คือ เราต้องไปกำหนดสิทธิ์ให้เว็บ application นี้ก่อน ทำตามนี้

หากเราต้องการให้เรียกใช้คำสั่ง shell_exec ของ PHP  ใน RPi ให้สามารถเรียกใช้คำสั่ง root ได้ เราจำเป็นต้องแก้ไขสิทธิ ของ application ที่ต้องใช้งานสักหน่อย

พิมพ์  sudo visudo

ทำการเพิ่ม  www-data  ALL=(ALL)  NOPASSWD:ALL  ไปที่ท้ายไฟล์ แล้วทำการบันทึกไฟล์นี้

จากนั้นเขียนสคริปต์ไฟล์ php แล้วไปวางไว้ที่ /var/www 

<?php

$output = shell_exec(‘sudo date --set="15 NOV 2014 12:43:10"’);

echo “<pre>$output</pre>”;

?>

บันทึกโค๊ดนี้ ตั้งชื่อไฟล์ตามใจชอบ เช่น time.php  เสร็จแล้ว ลองเปิดหน้าเว็บบราวเซอร์ แล้ว เรียกไปที่ time.php โดยใส่ ip ของ RPi เช่น  http://192.168.1.103/time.php  เราก็จะสามารถตั้งค่าเวลาของ RPi ผ่านหน้าเว็บได้  ซึ่งโดยปกติ จะไม่สามารถเรียกใช้คำสั่ง sudo ผ่าน shell_exec ได้ 

ลองเอาไปประยุกต์กันดูนะครับ

ปล. บทความนี้ ไม่อาจเขียนละเอียดมากนัก ผู้ที่ไม่มีพื้นฐานเลย อาจจะงง สักเล็กน้อย ขออภัยไว้ ณ ทีนี้ด้วย

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

shell script check cpu raspberry pi ‘s temperature

หน้าร้อนใกล้เข้าแล้ว  เริ่มเป็นห่วงว่า Raspberry pi จะร้อนเกินไปหรือเปล่า ก็ลองใช้ shell script เช็คอุณหภูมิของ CPU ของ Raspberry pi สักหน่อย ว่า ตอนนี้อุณหภูมิ อยู่ที่เท่าไหร่แล้ว ใช้คำสั่งง่ายๆ ครับ vcgencmd measure_temp แค่ นี้ ก็จะได้คำตอบแล้ว ว่าอุณหภูมิเท่าไหร่  ถ้าจะให้วนลูปเรื่อยๆ ก็ได้ครับ

while true; do vcgencmd measure_temp; sleep 2; done

วนลูป แล้ว หยุด ทุกๆ 2 วินาที  ลองเอาไปประยุกต์กันดูครับ

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

Port Forwarding for Raspberry pi from outside world

เผื่อบางท่านที่ยังไม่ทราบ หรือกำลังหาวิธีทำ Port Forwarding จาก Router ไปหา Access point แล้วไปที่บอร์ด Raspberry pi โดยเราจะทำการ Port Forwarding หมายเลขพอร์ท 80 สำหรับเว็บ , หมายเลข 22 สำหรับทำ SSH รีโมทเข้าบอร์ด , หรือพอร์ทอื่นๆ ที่คุณต้องการรันแอพพลิเคชั่น

อันดับแรกเลย ผมจะบอกถึงอุปกรณ์เนตเวิร์กของผมก่อน ผมใช้บริการอินเตอร์เนต จาก 3BB network  ผมมี Huawei router จาก 3BB จากนั้นผมก็ต่อเข้ากับ Enginius ที่เป็นตัวขยาย Port Network และเป็นตัวปล่อยสัญญาณ wifi ภายในบ้าน จากนั้น ผมก็ต่อบอร์ด Raspberry pi เข้ากับ Engenius อีกครั้ง ตามรูป

จากนั้น เราต้องทำการ Fixed หมายเลข IP Address ของที่ Huawei ที่เป็น LAN และที่ Engenius ทั้ง WAN และ LAN เลย ส่วนที่บอร์ด Raspberry pi ก็ให้ Fixed ไว้ด้วยเช่นกัน

ทำการ Fixed IP Address ให้ได้ตามรูปด้านบนก่อน 

สำหรับ Huawei

 

สำหรับ Engenius 

จากรูปด้านบน เรามองว่า WAN ของ Huawei คือรับ IP และข้อมูลจากภายนอก แล้ว LAN คือ iP ในวงแลนของเรา แต่ เมื่อเราต่อ Engenius ต่อท้าย Huawei แล้ว จึงทำให้ WAN ของ Engenuis ก็รับข้อมูลจาก LAN ของ Huawei อีกที

ดังนั้น เราต้องทำการบอกที่ Huawei ให้ทำการส่งข้อมูล ที่ต้องการติดต่อกับพอร์ตใดๆ ไว้ที่ Huawei ให้ทำการส่งข้อมูลนั้น ต่อมาที่ WAN IP ของ Engenius  โดยเข้าไปตั้งค่า NAT ในหน้าเว็บของ HUAWEI โดยปกติจะเป็น http://192.168.1.1 แล้วไปที่เมนู Basic->NAT ทำการเพิ่ม Virtual Server ตามรูป ในที่นี้ผมต้องการให้ มีการ Forward port 80,22,8090,900 ไปที่ WAN IP ของ Engenius

จากนั้น เราก็ไปตั้งค่า Forwarding Port ที่ Engenius ต่อไปที่บอร์ด Rasbperry pi ของเราอีกที โดยที่บอร์ด Rasbperry pi ของเราถูก Fixed IP Address ไว้ที่ 192.168.2.105

ทำการ Fixed IP Address ของบอร์ด Raspberry pi ด้วยการแก้ไขไฟล์ interfaces

nano /etc/network/interfaces

แค่นี้ ก็เป็นอันเรียบร้อยแล้ว วิธีทดสอบก็คือ ลอง Connect ผ่าน WAN IP Address ของ Huawei ผ่านหน้าเว็บ (ถ้าเปิด Web service ไว้) หรือผ่าน SSH Terminal จากข้างนอกเข้ามา ซึ่งการหา WAN IP Address ก็ทำตามขั้นตอนจากตอนเก่าๆ ได้ ที่นี่

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

ปล. สำหรับใครที่ใช้ 3BB แล้ว Forward Port ไม่สำเร็จ โทรไปปรึกษา 3BB ที่เบอร์ 1530 นะครับ เพราะบางที เราอาจจะโดนบล๊อกจาก 3BB อยู่ก่อน บอกให้เขาปล๊อดบล๊อกให้ครับ

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

Raspberry Pi 1- Wire Digital Thermometer Sensor

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

     ช่วงนี้่อากาศก็ยังหนาวอย่างต่อเนื่อง ดึกๆ ยิ่งอากาศเย็น ระวังเรื่องสุขภาพกันด้วย พอพูดถึงเรื่องอากาศเย็น เราก็อยากจะรู้เหมือนกัน ตอนนี้มันเย็นกี่องศาแล้ว งั้นเราก็มาลองให้ Raspberry pi อ่านค่าอุณหภูมิผ่านไอซีดิจิตอล เบอร์ DS18B20 ผ่าน Protocol แบบ 1-wire ดูสักหน่อยสิ ว่าอุณหภูมิตอนนี้มันเท่าไหร่

เนื่องจากไม่ได้อัพเดทเฟิร์มแวร์ของ Raspbian นานแล้ว ก็เอาสักหน่อย ทั้ง update และ upgrade กันไปเลย

sudo apt-get update
sudo apt-get upgrate

ไอ้ตอน upgrade นี่นานเลยหล่ะ ถ้าใครไม่เคยอัพเกรดนานๆ เหมือนผม

เสร็จแล้ว ก็หาไอซีดิจิตอล DS18B20 สักตัว ไม่แพงแล้วทุกวันนี้ ถูกมาก แล้วก็ตัวต้านทาน ค่า 4.7k โอห์ม เอามา Pull-up ขา Data ของไอซี DS18B20 (ตามคำแนะนำดาต้าชีท)

ที่มารูปวงจร http://www.raspberrypi-spy.co.uk/

เมื่อต่อวงจรเสร็จแล้ว ก็ต้องมาทำการเพิ่มโมดูล 1-wire ไปที่ kernel ของ Linux ด้วยคำสั่ง

sudo modprobe w1-gpio
sudo modprobe w1_therm

ถ้าสำเร็จเราจะเห็นข้อมูลการรายงานค่าอุณหภูมิที่ directory /sys/bus/w1/devices ลองเข้าไปที่ directory นี้ดูครับ

cd /sys/bus/w1/devices
ls

ถ้าปรากฏ serial number ของเซ็นเซอร์ คล้ายๆ แบบนี้ก็ใช้ได้ครับ
28-0000031280c7  w1_bus_master1

ให้เราเข้าไปที่ 28-0000031280c7 แล้วอ่านไฟล์ w1_slave ที่อยู่ข้างในดูครับ
cd 28-0000031280c7
ls
cat w1_slave

มันจะรายงานค่าอุณหภูมิที่อ่านได้จากเซ็นเซอร์ DS18B20 มีหน่วยเป็นเซลเซียส

58 01 1e 00 1f ff 08 10 d9 : crc=d9 YES
58 01 1e 00 1f ff 08 10 d9 t=21500

มีค่าประมาณ 21.5 องศาเซลเซียส  สำหรับผม ก็ถือว่าหนาวแล้วขนาดนี้ บรื๊ออออออก็ลองเอาไปประยุกต์กันดูครับ ง่ายๆ อุ่นเครื่องกันเท่านี้ก่อนหล่ะกัน สวัสดีครับ

ที่มา raspberrypi-spy.co.uk

เสร็จแล้ว ก็ลอง Polling data ด้วย Python ดูสักหน่อยสิ

ปล. ลืมไปว่าเราสามารถแทรก คำสั่ง modprobe ในโค๊ดนี้ก็ได้ จะได้ว่า

import os
from time import sleep

os.system('sudo modprobe w1-gpio')
os.system('sudo modprobe w1_therm')

while True:
    tfile = open("/sys/bus/w1/devices/28-0000031280c7/w1_slave")
    text = tfile.read()
    tfile.close()
    temperature_data = text.split()[-1]
    temperature = float(temperature_data[2:])
    temperature = temperature / 1000
    print temperature
    sleep(2)

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

กล่องใส่ 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 ของกล้องหล่ะก็ ภาพที่ได้จะออกมาดี (เท่าที่กล้องมันจะทำได้) เลยหล่ะครับ หวังว่าคงเป็นประโยชน์ นำไปต่อยอดกันได้นะครับ

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

WebIOPi : Control Raspberry Pi ‘s GPIO via web browser

เราทราบดีอยู่แล้วว่า Raspberry pi นั้น สามารถทำให้เป็น web Server ได้ และในขณะเดียวกัน ก็ยังมี GPIO เหลือไว้ให้นักพัฒนาไว้ทำอะไรเล่นได้แตกต่างจาก PC ทั่วไปที่ไม่มี GPIO ให้ใช้ ก็เลยมีคนคิดที่จะทำ web application ที่สามารถที่จะควบคุม GPIO ผ่านทางหน้าเว็บ วันนี้ เรามาติดตั้ง web application ตัวหนึุ่่งที่น่าสนใจสำหรับ Raspberry pi นั่นก็คือ WebIOPi

WebIOPi คือเว็บแอพลิเคชั่น ที่ออกแบบด้วยภาษา Python ซึ่งทำงานร่วมกับ REST framework  จุดประสงค์เพื่อให้การควบคุม GPIO ของ Raspberry Pi แสดงผล แบบ(เกือบจะ) Realtime ให้เห็นผ่านหน้าเว็บ โดยที่เราไม่ต้อง refresh หน้าเว็บ เมื่อ GPIO มีการเปลี่ยนแปลงสถานะ

"WebIOPi is developed and tested on Raspbian"

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

wget http://webiopi.googlecode.com/files/WebIOPi-0.5.3.tar.gz
tar xvzf WebIOPi-0.5.3.tar.gz
cd WebIOPi-0.5.3
sudo ./setup.sh

รอสักครู่ จากนั้นก็สั่งให้ webiopi ทำงานด้วยการรันเซอร์วิส

sudo /etc/init.d/webiopi start

หากต้องการสั่งให้เซอร์วิสหยุดทำงาน ก็ตรงกันข้ามครับ

sudo /etc/init.d/webiopi stop

แต่ถ้าถูกใจแอพพลิเคชั่นนี้ และอยากให้ทำงานทุกครั้งที่เปิดเครื่องแล้วหล่ะก็ ให้กำหนดเป็นค่า default ตอนเปิดเครื่องไปเลย ด้วยคำสั่ง

sudo update-rc.d webiopi defaults

หลังจากนั้น เปิด web browser ของเราขึ้นมา แล้วกรอก URL ไปที่ไอพีของ Raspberry Pi ครับโดยใส่ port 8000 เข้าไปด้วย

เช่น ไอพีบอร์ด raspberry pi ของผมเป็น 192.168.2.105 จะได้ว่า  http://192.168.2.105:80000/webiopi/ ครับ

ทำการกรอก username / password ครับ ในที่นี้ถูกกำหนดเป็น webiopi รหัสผ่านก็ raspberry ครับ

จะปรากฏหน้าเว็บ จากนั้น ลองกำหนดให้ GPIO ใดๆ ก็ได้เป็น OUT แล้วลองเอา LED ต่อที่ pin นั้นๆ จากนั้นกดเปลี่ยนสถานะ หากเป็น Hi จะเปลี่ยนสีเป็นสีเหลืองที่หน้าเว็บ ที่หลอด LED ก็ควรจะติดด้วย

ทดลองเปิดหน้าเว็บจากคอมพิวเตอร์เครื่องอื่น หรือเปิด browser เพิ่มอีก และดูผลการเปลี่ยนแปลง เราจะเห็นว่าหน้าเว็บแสดงผลได้แทบจะทันทีทันใด ที่มีการเปลี่ยนแปลงที่ GPIO ครับ นั่นก็เป็นเพราะ REST framework นั่นเอง

ลองติดตั้ง แล้วศึกษาตัวโปรเจคนี้ดูครับ รับรองได้ประโยชน์แน่นอน

แหล่งที่มา : http://code.google.com/p/webiopi/

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

Raspberry pi play music from radio online

ง่ายๆก่อนนอนวันนี้เรามาลองทำ internet radio ฟังกันจาก Raspberry Pi ของเราดีกว่า ทำเสร็จแล้วก็กล่อมเรานอนไปเลย
1. ติดตั้งโปรแกรม mpd&mpc ง่ายๆแค่พิมพ์
sudo apt-get install mpd && sudo apt-get install mpc

2. เปิดไฟล์ /etc/mpd.conf มาแก้ไขด้วยคำสั่ง
sudo nano /etc/mpd.conf

3. เลื่อนแก้ไขดังนี้
bind_to_address "localhost"
แก้เป็น
#bind_to_address "localhost"

#mixer_type "software"
แก้เป็น
mixer_type "software"

กด Ctrl+x แล้วตอบ Y ออกมา
ที่แก้ไปอันแรกคือให้เราสามารถ remote คุมจากอุปกรณ์อื่นได้เช่น iPhone,Android
บรรทัดที่สองคือให้เราสามารถควบคุมระดับเสียงได้

4. เพื่อความชัวร์ว่าเสียงมันจะออกที่ช่อง audio พิมพ์
sudo amixer cset numid=3 1
อยากให้ไปดังที่ TV ผ่านสาย HDMI พิมพ์
sudo amixer cset numid=3 0

5. restart ทุกอย่างเพื่อ reload config ด้วยคำสั่ง
sudo service mpd restart

6. add สถานีที่ต้องการลงไป ดังนี้
mpc add http://205.164.62.11:5084/

7. ลองสั่งเล่นเพลงด้วยคำสั่ง mpc play

8. เพิ่มลดระดับเสียงได้คำสั่ง mpc volume 0-100

9. อย่าลืมเสียบลำโพงนะครับ

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

mpc add http://203.150.224.142:8000
เอาคลื่นไทยมาฝากนะครับ
ถ้ามีสองสถานีแบบนี้ใช้คำสั่ง mpc next หรือ mpc prev เพื่อเลื่อนสถานีนะครับ

บทความจากแอดมิน Raspberry Pi 66 Club

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

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 Install Arduino IDE on Debian

หากเพือนๆ สนใจที่จะพัฒนางานทางด้านไมโครคอนโทรลเลอร์เช่น Arduino บน Debian แล้วหล่ะก็ มีสิ่งที่น่าสนใจ เล็กๆ น้อยๆ ที่ผมได้ทดลอง และหาข้อมูล จะได้นำมาเขียนบันทึกไว้บน Blog แห่งนี้ วิธีการก็คือ

หลังจากที่เราได้เคยติดตั้ง Oracle VM VirtualBox และได้ติดตั้ง Debian ไปแล้ว เมื่อสั่งให้ระบบปฏิบัติการณ์เริ่มทำงาน เราจะเข้าสู่โหมด XWindows จากนั้น ให้ Logon ด้วย user ที่เราได้กำหนดไว้ ในที่นี้ ผมได้ Logon เข้าด้วย user: pi ที่ผมได้กำหนดไว้ จากนั้น ทำการเปลี่ยนตัวเองเป็น root เพื่อที่จะติดตั้ง arduino ide

su -
ใส่ password root ที่เราได้กำหนดไว้แล้ว
ต่อมาใช้คำสั่ง apt-get install arduino ตอบ y รอจนกว่าระบบติดตั้ง arduino เรียบร้อย

หากใครสงสัยว่า arduio คืออะไร สามารถศึกษาเพิ่มเติมได้ที่นี่ คลิก  

ทำการเสียบบอร์ด Arduino เข้ากับ PC หรือ  Notebook ของเรา แล้วทำการเลือกที่เมนูหน้าต่าง Oracle VM VirtualBox ไปที่
Device->USB Device แล้วทำการเลือก FTD FT232R  ตามรูป (ซึ่งน่าจะเป็นอย่างนั้น สำหรับบอร์ด arduino)

ที่หน้าต่าง console หากเราใช้คำสั่ง tail -f /var/log/message (สำหรับ root) เราจะเห็นข้อความสำหรับเจ้า FTDI USB Serial Device...... ttyUSB0 ด้วยเช่นกัน

ทำการเช็คที่ ls -l /dev/ttyUSB0 จะเห็นไฟล์นี้ เกิดขึ้นเช่นกันที่ folder /dev/
crw-rw---- 1 root dialout 188, 0 Jan 10 23:11 /dev/ttyUSB0

ปัญหาของเจ้า arduino IDE มันอยู่ตรงนี้ครับ คือหลังจากที่เราติดตั้ง arduino IDE เรียบร้อยแล้ว เราจะยังไม่สามารถที่เลือกที่เมนู IDE
tool->Serial Port ได้ (ไม่เชื่อลองเปิด IDE ขึ้นมา ) เราจะไม่สามารถเลือก Serial port ที่จะติดต่อกับบอร์ด arduino ได้ครับ ถึงแม้ว่า Debian จะมองเห็น USB ที่ต่อเข้ามาแล้วก็ตาม

เนื่องจากว่า ตอนนี้ เราเองเป็น user: pi แต่เจ้า ttyUSB0 นั่นอยู่ในกรุ๊บ dialout ครับ

crw-rw---- 1 root dialout 188, 0 Jan 10 23:11 /dev/ttyUSB0  (owner เป็น root แต่ group เป็นของ dialout ครับ ) 

วิธีแก้ไข ก็คือ ทำให้ pi นั้นสามารถเข้าใช้ group ของ dialout ได้ ด้วยคำสั่ง

root@raspberrypi:~#usermod -a -G dialout pi

หากเราใช้คำสั่ง pi@raspberrypi:~$ groups อีกครั้ง เราก็ยังพบว่า pi ยังไม่มีสิทธิใน dialout เหมือนเดิม อันนี้ ไม่ต้องตกใจครับ ให้เรา Logout แล้ว  Logon มาใหม่ครับ แล้วลองเช็คอีกที จะพบว่า

pi@raspberrypi:~$ groups
pi dialout cdrom floppy audio dip video plugdev netdev

มองเห็น dialout เรียบร้อยแล้ว ทดลองเปิด arduino ide อีกครั้ง ก็จะพบว่าที่เมนู tool->Serial Port สามารถเลือก /dev/ttyUSB0 ได้แล้วครับ

ลองเลือกโค๊ดตัวอย่าง แล้วทำการ upload โค๊ดตัวอย่างที่ผ่านการ build แล้ว ใส่ไปที่บอร์ด arduino ของเราครับ ซึ่งน่าจะทำงานได้ตามปกติ จากนี้ไปเราก็สามารถที่จะพัฒนางาน arduino บน Debian ได้แล้วครับ ซึ่งสามารถนำหลักการนี้ไปใช้บน Raspian ของ Raspberry Pi ได้เช่นกันครับ ซึ่งต่อไป ผมอาจจะนำเอา piFirmata มาใช้ในการพัฒนา Raspberry Pi กับ Arduino ต่อไปครับ (คิดไว้ก่อนเฉยๆ ไม่รู้จะว่างหรือเปล่านะ :P )

ปล. ผมอาาจะอธิบายขั้นตอนการ Build / Upload Code สำหรับ Arduino เร็วไป แต่คิดว่า เพื่อน น่าจะหาข้อมูลอ่านได้ไม่ยาก หากสงสัยขั้นตอนไหนหน่ะครับ ซึ่งทั่วๆไป วิธีการก็จะคล้ายๆกัน

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

THE DEBIAN ADMINISTRATOR'S HANDBOOK

    อย่างที่เราทราบกันดีอยู่แล้วว่า เจ้าระบบปฏิบัติการ Raspbian นั้น แท้จริงแล้วก็คือ Debian ที่ถูกตัดแต่งพันธุกรรมให้เหมาะกับฮาร์ดแวร์บนบอร์ด Raspberry Pi นั่นเอง เพราะฉะนั้นแล้ว ความเข้าใจในระบบปฏิบัติการ Debian ย่อมนำไปสู่การปรับแต่งค่า และการใช้งานเจ้า Raspian ด้วยเช่นกัน

     ผมจะยกตัวอย่างให้ฟัง เดิมทีผมมักจะใช้ CentOS เมื่อเวลาที่จะต้องกำหนดค่าต่างๆ ให้กับ Apache นั้นเราต้องไปกำหนดที่ค่า httpd.conf ซึ่งอยู่ใน path  /etc/httpd/conf/httpd.conf แต่สำหรับเจ้า Debian แล้ว มันไม่ได้เก็บค่าไว้ตรงนั้น มันดันไปเก็บค่าไว้ที่ /etc/apache2/sites-enabled/000-default และบางค่า ก็ไปเก็บไว้ที่ /etc/apache2/apache2.conf นั่นหมายความว่า ไม่ใช่ว่าทุกๆ OS จะต้องปฏิบัติตามเหมือนกันหมด แต่ก็ใช่ว่าจะแตกต่างกันสิ้นเชิงเลยเสียทีเดียว

     ในส่วนของการปรับแต่งค่าที่เกี่ยวข้องกับระบบ network นั้น จริงๆ แล้ว เรากำลังทำหน้าที่เป็น administrator อยู่นั่นเอง วันนี้ ผมมีหนังสือแนะนำให้ไปอ่านกันนะครับ สำหรับใครที่กำลังเล่นอยู่กับ Raspberry Pi ที่ใช้ Raspian เป็น OS และกำลังเจอปัญหาอย่างที่ผมได้เกริ่นไว้ข้างต้น แนะนำให้มาอ่านเล่มนี้ครับ จะได้ไม่เจอปัญหาเหมือนผม ;P

THE DEBIAN ADMINISTRATOR'S HANDBOOK มีไฟล์ให้เราเลือกไปอ่านได้ 3 ประเภทไฟล์ครับ ต้องการรูปแบบไหน ก็เข้าไปเลือกดาวน์โหลดกันได้เลยครับ ..... คลิก

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

How to find Raspbberry Pi’s IP Address when yon don’t know it.

      โดยปกติแล้ว หลังจากที่เราได้บอร์ด Raspbbery Pi มาแล้ว เมื่อทำการติดตั้ง Raspian ลงบน SD-Card เรียบร้อยแล้ว ในเวอร์ชั่นหลังๆ ของ Raspian
เค้าจะเปิด SSH ไว้ให้เรียบร้อยแล้ว หน้าที่ของเราก็คือ หาช่อง PORT Network จาก Router ของเราเสียบเข้าไปที่ Port Network ที่บอร์ด Raspberry Pi เมื่อจ่ายไฟเข้าบอร์ดเรียบร้อยแล้ว หากไม่มีอะไรผิดพลาด เจ้าบอร์ด Raspberry Pi ก็อยู่ในวง LAN เดียวกันกับเครื่องคอมพิวเตอร์ ของเราแล้ว (ด้วยการจ่าย IP Address จาก Router) หน้าที่ของเราก็คือ ทำการ Login แล้วทำการติดตั้ง Package อืนๆ ที่ต้องการ

     ปัญหาจะเกิดขึ้นตอนนี้ ก็คือ อย่างที่เรารู้อยู่แล้วว่าช่อง Display Output ของ Raspberry Pi มีให้เลือก คือ AV out (default) และ ช่อง HDMI (ซึ่งต้องเข้าไปเซตค่าก่อนใช้งาน) แล้วถ้าเราไม่สามารถหา TV หรือ Monitor ที่มีช่อง AV IN มาต่อกับบอร์ด Raspberry Pi หล่ะ เราจะเริ่มต้นใช้งานบอร์ดได้อย่างไร ?

     ด้วยความรู้ เรื่อง Network และ Linux ที่มีอยู่นิดหน่อย เราน่าจะใช้โปรแกรม nmap ในการทำการ scan หา Port 22 ซึ่งเป็น  Port สำหรับ SSH ที่ Raspberry Pi ถูกเปิดใช้งาน และเมื่อ Raspberry Pi ถูกต่ออยู่ในวง LAN เดียวกันเครื่องคอมพิวเตอร์ของเราแล้ว ก็น่าจะไม่ใช่เรื่องยาก ที่จะหา IP Address ของ Raspberry Pi เพื่อที่เราจะได้ทำการ SSH เพื่อเข้าใช้งาน Raspbbery Pi ต่อไป

เอาหล่ะ เราก็โหลดโปรแกรม nmap มาใช้กันเลย ซึ่งสามารถเข้าไปโหลดเวอร์ชั่นสำหรับ windows ได้จากเว็บ http://nmap.org/download.html#windows แต่ วันนี้ ผมไม่ได้มาแนะนำสำหรับเวอร์ชั่น windows ครับ ผมจะแนะนำเวอร์ชั่นของ Debian ;P

ก่อนหน้านี้ ผมได้แนะนำให้เพื่อนลองติดตั้ง VirtualBox เพื่อจำลองพื้นที่บน Windows ให้สามารถติดตั้ง Debian ได้ ฉะนั้น เราก็มาลองกันเลย ว่าเราจะเอา Debian บน VirtualBox มาใช้งานได้อย่างไร

เปิด VirtualBox ขึ้นมาครับ แต่ก่อนที่เราจะเริ่ม Start Debian ให้เราทำการตั้งค่า Network ให้เป็น Bridged Adapter กันก่อน เพื่อให้เจ้า Debian ของเราต่อออกอินเตอร์เนต เพราะเราต้องไปโหลด package nmap มาก่อน  เมื่อตั้งค่าเรียบร้อยให้ทำการ Start Debian ขึ้นมาเลยครับ

Login เข้าสู่ XWindows ตามปกติ เมื่อเรียบร้อยแล้ว ให้เปิด Terminal ขึ้นมาสักตัว จากเมนู  จากนั้นเปลี่ยนตัวเองเป็น root ซะ แล้วทำการโหลด nmap package ด้วยคำสั่ง  apt-get install nmap

เรียกใช้คำสั่ง nmap เพื่อให้ทำการแสดงหาเครื่องในเครือข่าย ที่เปิด port 22 พร้อมทั้งให้แสดง OS ที่ติดตั้งอยู่ด้วย โดยผมให้เริ่มทำการ scan ตั้งแต่ ip address 192.168.2.100 ถึง 192.168.2.255  (เพราะผมทราบอยู่ก่อนหน้าแล้วว่า router ผมเริ่มจ่าย IP อยู่ใน  range นี้) ด้วยคำสั่ง   nmap –sV –p 22 192.168.2.100-255
รอสักครู่ จะปรากฏข้อความรายงานผล 

ในที่นี้ ผมได้รับรายงาน มา  2 IP Address ที่เปิด Port 22 อยู่ในขณะนี้ แต่เนื่องจากเจ้า Debian virtual ของผมเป็นหมายเลขไอพี 192.168.2.109 อยู่แล้ว แสดงว่า เป้าหมายบอร์ด Raspberry Pi ที่เรากำลังหาอยู่นั้น เป็นหมายเลขไอพี 192.168.2.105 อย่างแน่นอน เราลอง เปิด putty ขึ้นมา เพื่อทำการเชื่อมต่อกับ SSH ที่ ไอพี 192.168.2.105  ผลปรากฏว่า ใช่เลย เราสามารถ login เข้าสู่ SSH ด้วย user pi แสดงว่า เราทำถูกแหละ

     นั่นก็เป็นแนวทางการใช้ nmap และการนำ Debian virtual มาช่วยในการทำงานของเรากับงาน Linux Embedded พวกนี้  น่าจะได้แนวทางไปประยุกต์ต่อไปนะครับ  ขอเสริมนิดหนึ่ง สำหรับโปรแกรม nmap เป็นโปรแกรมที่มีประโยชน์มาก สำหรับใครสนใจสามารถศึกษาได้เพิ่มเติม ผมรับรองว่ามีประโยชน์มาก โดยเฉพาะ linux network admin ครับ จำเป็นต้องใช้ และใช้บ่อยมาก 

    สุดท้าย ผมขอนำฉากๆ หนึ่งในหนังเรื่อง The matrix ครับ ในฉากนี้ ทรินิตี้ กำลังใช้คำสั่ง nmap ในการหา port ที่เปิดอยู่ แล้ว ทำการ hack เข้าไป เพื่อสั่งปิดแหล่งจ่ายไฟฟ้าทั้งหมดของโลก matrix หนังเรื่องนี้ สาระเยอะจริงๆ ถ้าตามเก็บรายละเอียดทั้งหมด จะพบว่า เราได้อะไรมากกว่า ฉากบู๊ที่ตื่นเต้น อีก

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

Raspberry Pi checking Router’s IP Address

     จากตอนที่แล้ว (คลิก) เราได้ทำความเข้าใจเรื่องการใช้งาน crond service ของ Linux กันไปแล้ว วันนี้ เราจะมาสร้างระบบคอยตรวจสอบ WAN IP Address ของ Router แล้วให้ส่งค่า IP Address ของ Router ที่ได้รับจาก ISP (ผู้ให้บริการอินเตอร์เนตที่เราใช้อยู่ ) หาก IP Address เกิดการเปลี่ยนแปลงเนื่องจากเหตุผลใดๆ ก็ตาม ให้ทำการส่งค่า IP Address ใหม่ ไปบอกเราทาง E-mail นะครับ

     จริงๆ หลักการ ก็ไม่ได้ยากอะไร เราจะให้บอร์ด Raspberry Pi ทำการเรียกไฟล์สคริปต์ php จาก Web Server ตัวหนึ่งที่ผมได้นำไฟล์ ip.php ไปฝากไว้ ซึ่งภายในไฟล์นี้ มีเพียงคำสั่งแสดง Remote ip address ซึ่งก็คือ IP Address ของ Router นั่นเอง

<?php echo $_SERVER['REMOTE_ADDR']; ?>

เมื่อได้ค่า router IP Address มาแล้ว หาก IP Address ไม่ตรงกับที่เคยเก็บค่าไว้ ก็จะทำการส่ง E-mail ไปบอกเรา ว่า ตอนนี้ IP Address ได้มีการเปลี่ยนแปลงเกิดขึ้นแล้วนะ ซึ่งเราจะนำ IP Address ของ  Router ที่ได้ ไปสร้างโปรเจคอื่นต่อไป แต่ตอนนี้ เอาเพียงเท่านี้ก่อนนะครับ เดี๋ยวจะงง

การทำงานคร่าวๆ ก็คือ ในตอนแรก Raspberry Pi เรียกดูไฟล์ ip.php ตาม URL ที่กำหนด
Raspberry Pi---> Access Point + Router--->request http://monitoring.orgfree.com/ip.php

จากนั้น web server monitoring.orgfree.com ตอบกลับ Remote IP Address ซึ่งนั่นเป็น IP Address ของ Router ที่เราได้รับจาก ISP ขณะนั้น
Raspberry Pi<--- Access Point + Router<---response Remote IP Address

จากนั้น เราก็จะนำค่า IP Address ไปเปรียบเทียบกับค่าที่เก็บไว้ใน text file ว่าค่าตรงกันหรือไม่ หากไม่ตรงกัน ก็จะทำการส่ง E-mail ไปบอกเรา ซึ่งเราจะนำโค๊ดจากก่อนหน้านี้ มาทำการปรับปรุง จะได้ว่า

#-------------------------------------------------------------------------------
# Name:        router.py
# Purpose:     for checking router's ip address
#
# Author:      http://raspberry-pi-th.blogspot.com
#
# Created:     22/12/2012
# Copyright:   (c) raspberry-pi-th.blogspot.com 2012
#-------------------------------------------------------------------------------
import smtplib
import urllib2
host = "http://monitoring.orgfree.com"
script = "ip.php"
path = "/"
file_target = '/home/pi/ip.txt'

def sendmail(ip_remote):
    SMTP_SERVER = 'smtp.gmail.com'
    SMTP_PORT = 587
    sender = 'raspberry router ip checker'
    recipient = '------------------'   # email ผู้รับ
    subject = 'Router IP Address notice'
    body  = 'Your router\'s ip address is changed to ' + ip_remote
    headers = ["From: " + sender,
                "Subject: " + subject,
                "To: " + recipient,
                "MIME-Version: 1.0",
                "Content-Type: text/html"]
    headers = "\r\n".join(headers)
    username = ‘---------------------’             # user name gmail
    password = '----------------------'           # password gmail
    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()

try:
    ip_remote =  urllib2.urlopen(host + path + script).read()
    print "ip remote " + ip_remote
    try:
        f = open(file_target,'r')
        read_ip = f.read()
        print "readout " + read_ip
        if (read_ip <> ip_remote):
            f.close()
            f = open(file_target,'w')
            f.write(ip_remote)
            sendmail(ip_remote)
            print "Email was sending"
        f.close()
    except Exception,e:
        print 'exception ' , e
        f = open(file_target,'w')
        f.write(ip_remote)
        f.close()
        sendmail(ip_remote)
        print "New file was created"
except urllib2.HTTPError, e:
    print host + path + script + " : " + str(e.code) + " " + str(e.msg)

#----------------- sript ending ----------------------------------

หมายเหตุ อย่าลืมใส่ username / password gmail account ของเราด้วยนะครับ

บันทึกไฟล์นี้ ชื่อ router.py ไว้ที่ /home/pi  อาจจะต้องทำการเปลี่ยนโหมด หากจำเป็น ด้วยคำสั่ง chmod 774 /home/pi/router.py จากนั้น นำสคริปต์ python ของเราไปฝากไว้ใน crontab (จากตอนที่แล้วของเรา) ให้ทำการเช็คทุกๆนาที หรือจะทุกๆ 10 นาที หรือ ทุกๆ ชั่วโมง ก็แล้วแต่ ความต้องการของเรา ในทีนี้ ผมให้มันเช็ค ทุกๆ นาทีหล่ะกัน จะได้เงื่อนไขใน crontab ดังนี้

* * * * * python /home/pi/router.py

ทำการบันทึก crond service แล้วรอดูผลที่ E-mail ของเรา ซึ่งในครั้งแรก ควรจะมีการส่งเมล์มาบอกเราทันที ที่สคริปต์ทำงาน เพราะว่า ไม่เคยมีไฟล์ ip.txt (ซึ่งได้จากรันสคริปต์ router.py) ปรากฏขึ้นเลยมาก่อน ก็เข้าเงื่อนไขการส่ง E-mail

เราลองลบไฟล์ ip.txt หรือไม่ก็ลองเข้าไปแก้ไข IP Address ภายในไฟล์ ip.txt แล้วลองสังเกตการเปลี่ยนแปลง ว่ายังมีการส่ง E-mail มาที่เราหรือเปล่า ซึ่งควรจะมีการส่งมา

จากนั้น เพื่อนๆ อาจจะทำการแก้ไขเงื่อนไขใน crontab เมื่อมั่นใจแล้วว่า สคริปต์ของเราทำงานได้อย่างที่ต้องการ โดยอาจจะเปลี่ยนเป็นเช็ค ทุกๆ ห้านาที ก็ได้ เพื่อไม่เป็นการ request ไปที่ web server มากเกินไป (อาจโดนเตะออก เหมือน spam ได้ )

ตั้งค่าใน crontab ใหม่ดังนี้
0,5,10,15,20,25,30,35,40,45,50,55 * * * * python /home/pi/router.py

     ก็มีเพียงแค่นี้ สำหรับบทความตอนนี้ ต่อไปเราก็จะทำการ Forward Port ที่ Router ของเราให้ส่งตรงข้อมูลไปที่บอร์ด Raspbbery Pi ของเราอีกที ซึ่งนั่นจะทำให้เรา สามารถควบคุมระยะไกล จากที่ใดๆ ก็ได้มาที่บอร์ด Raspbbery Pi โดยผ่านหมายเลข router IP Address ของเรา ที่ซึ่งแม้ IP จะถูกเปลี่ยนแปลงไป เราก็ยังสามารถติดตามได้ว่า Router IP Address ของเราตอนนี้ ได้หมายเลขอะไร ซึ่งผมจะได้แสดงให้ดูในครั้งต่อไปครับ ^_^

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

How to make crond service in linux

      ไม่ได้เข้ามาเขียนนานเหมือน ติดภาระกิจหลายอย่าง แต่ ก็ยังติดตามข่าวความก้าวหน้า และพัฒนาการของเจ้าบอร์ด Raspberry Pi อยู่เหมือนกัน ก่อนหน้านี้ ผมก็วุ่นวายอยู่กับการอัพเกรด Server ในแผนก เนื่องจาก CentOS ที่ใช้อยู่เก่าเกินกว่า จะอัพเกรด PHP จากเวอร์ชั่น 4 ไปเป็นเวอร์ชั่น 5 ก็เลยวุ่นวายพอสมควรที่ต้องโยกย้าย ถ่ายเทข้อมูลออก แล้วทำการติดตั้ง CentOS ใหม่ แล้วก็ลง PHP, MySQL ใหม่ด้วย ก็ดันมีปัญหากับข้อมูลอีก เวลาข้ามเวอร์ชั่นนี่ ต้องเช็คให้ดี ว่ามัน support กันใหม่ ทางทีดี ก็น่าจะลองบน VirtualBox ก่อนก็ได้นะครับ เผื่อความชัวร์

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

      ถ้าจะเปรียบเทียบง่ายๆ ก็คือ crontab ก็เหมือน scheduler หรือตัวจัดการงานตามเวลาที่เราได้ตั้งไว้นั่นเอง ซึ่งในระบบปฏิบัติการ Windows ก็มี ไม่รู้มีใครเคยใช้หรือเปล่า แต่ใน Linux แล้ว มันไม่ได้มีหน้าต่างให้ตั้งค่าอะไรสะดวกเหมือน windows ฉะนั้นเรามาศึกษาการตั้งค่าเจ้า crontab กันสักหน่อยครับ

แต่ละ user สามารถที่จะมี crontab หรือบางทีก็เรียก crond service ของแต่ละคน แยกจากกันได้ นั่นแปลว่า ถ้ามี user pi และ user root ก็สามารถที่จะตั้ง crontab แต่ละคนได้ ไม่ต้องใช้ crontab ร่วมกัน  โดยสามารถที่จะสร้าง หรือ ดู crontab ได้ด้วยคำสั่ง

crontab -e เพื่อสร้าง crontab ใหม่ หรือเข้าไปแก้ไข crontab ที่เราได้ตั้งไว้แล้ว
crontab -l เพื่อขอดูรายการ crontab ที่ตั้งไว้ (ดูเฉยๆ ไม่ได้ต้องการแก้ไข)

พอเราได้ลองใช้ คำสั่ง crontab -e แล้ว linux ก็จะทำการเลือก editor ตัวหนึ่งขึ้นมาให้เราทำการแก้ไข หน้าตา crontab เริ่มต้นจะประมาณนี้ (อาจจะแตกต่างกันไปบ้าง ตามแต่ linux แต่ละค่าย)

# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
#
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').#
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
#
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
#
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h  dom mon dow   command

อันนี้เป็นข้อความ crontab ของ Raspian ใน Raspberry Pi ครับ

ต่อมาที่เราต้องทำความเข้าใจก็คือ ในการตั้งค่าให้ crontab ถูกกระตุ้นทำงาน ตามวัน เวลา นาที ชั่้วโมง ใดๆ ก็ได้ ดังต่อไปนี้

*     *     *     *     *  Command to be executed
-     -     -     -     -
|     |     |     |     |
|     |     |     |     +----- Day of week (0-7)
|     |     |     +------- Month (1 - 12)
|     |     +--------- Day of month (1 - 31)
|     +----------- Hour (0 - 23)
+------------- Min (0 - 59)

เราใช้การเว้น 1 ช่องว่าง เป็นการแยกแต่ละค่า และในทีนี้เครื่องหมาย * (ดอกจัน) หมายความว่า "ทุกๆ"  เช่น ผมตั้งว่า

5 * * * * Command to be executed
ความหมายก็คือ ผมให้ คำสั่งที่ถูกระบุในบรรทัดนี้ ถูกเรียกให้มาทำงาน ในนาที ที่ 5  ทุกๆชั่วโมง ทุกๆวันของเดือน ทุกๆสัปดาห์ ทุกๆวันของสัปดาห์

แล้วถ้าเป็นแบบนี้หล่ะ
* 1,2,3,4 * * * Command to be executed
ความหมายก็คือ ผมให้ คำสั่งที่ถูกระบุในบรรทัดนี้ ถูกเรียกให้มาทำงาน ใน ทุกๆนาที  ชั่วโมงที่ 1,2,3,4 ทุกๆวันของเดือน ทุกๆสัปดาห์ ทุกๆวันของสัปดาห์  ซึ่งในชั่วโมงที่ 1,2,3,4 นั่นคือ ตีหนึ่ง ถึง ตีสี่ นั่นเอง

     เอาหล่ะ ที่นี้ เรามาลองสร้าง crontab กันดูนะครับ สำหรับ user pi หลังจาก login แล้ว ให้เรียกคำสั่ง crontab -e จากนั้น เพิ่มบรรทัด ล่างสุด โดยไม่มีเครื่องหมาย # นำหน้านะครับ เพราะมันเป็นการ comment ในโปรแกรม

ผมเพิ่ม คำสั่งนี้ลงไป ใน crond service ของ pi

* * * * * /bin/date >> /home/pi/date.txt

ผมลองให้ shell เรียกคำสั่ง date ซึ่งถ้าเราลองเรียกคำสั่งนี้ ที่ console มันจะแสดงวัน เวลา ออกมาทางหน้าจอ

แต่เมื่อเรามาเขียนสั่งใน crontab มันไม่รู้ว่าจะไปแสดงหน้าจอไหน ผมก็เลย สั่งเปลี่ยนทิศทางการแสดงผล ให้ไปออกที่ text file ที่อยู่ใน /home/pi ชื่อ date.txt โดยให้เขียนต่อกันไปเรื่อยๆ ในไฟล์ date.txt สังเกต ผมใช้ >> แสดงว่าเป็นการเขียนต่อจากข้อความเก่า 

/bin/date >> /home/pi/date.txt

จากนั้นทำการบันทึก crond service ด้วยการออกจากโปรแกรม editor ซึ่งในที่นี้ เจ้า raspian ของเรามันใช้โปรแกรม nano ในการเป็น editor ซึ่งวิธีการออกจากโปรแกรมก็แค่ กด Ctrl+x แล้วกด y เพื่อยืนยันการเปลี่ยนแปลงสิ่งที่เราแก้ไข จากนั้น ไม่ต้องทำอะไรครับ รอดูผลที่เปลี่ยนแปลงใน /home/pi จะปรากฏไฟล์ date.txt เกิดขึ้น หลังจากเราได้บันทึกไปแล้ว ลองให้แสดงรายละเอียดข้างในไฟล์ด้วยคำสั่ง
cat /home/pi/date.txt ดูครับ จะเห็นว่า มีการเขียน วันเวลา ลงในไฟล์นี้

ถ้าเราอยากจะคอยตรวจดูว่า crond service เราได้ทำงานหรือเปล่า สามารถเช็คได้ด้วยคำสั่ง

tail -f /var/log/syslog ได้ครับ

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

      คำถามก็คือ เราใช้ crontab ตอนไหน คำตอบก็คือ งานใดๆ ก็ตาม ที่ต้องทำเป็นประจำ เช่น backup ฐานข้อมูล, ลบไฟล์ที่ไม่จำเป็น, หรือแม้แต่สั่งเปิดปิด GPIO ตามเวลา ที่เรารู้อยู่แล้ว และต้องการให้เกิดเป็นประจำ เราก็ควรที่จะเอางานนั้นๆ เขียนลงไปในสคริปต์ แล้วมาฝากไว้ที่ crond service ครับ เพราะนอกจากเราไม่จำเป็นต้องเขียนโค๊ดให้วนรอบค้างไปเรื่อยๆ แล้วให้ทำงานตามที่เรากำหนดแล้ว ยังมั่นใจได้ว่า หากระบบเราถูกรีเซตแล้ว crond service จะกลับมาทำงานได้เหมือนเดิม และคำสั่งที่ถูกเขียนลงไป นั้น จะถูกเรียกทำงานได้ตามปกติอีกด้วย

      ในตอนต่อไป ผมจะให้เจ้า crontab ทำการเรียก script python เพื่อดูค่า ip router ที่เป็นระดับ WAN เพื่อที่เราจะได้ทราบว่า ip router ของเราหมายเลขอะไร เพื่อจะได้ทำการรีโมทจากภายนอกบ้าน เข้ามาจัดการบอร์ด Raspberry pi ของเรานะครับ คอยติดตามชมหล่ะกัน ว่าผมจะทำยังงัย ^_^ 

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

How to backup and restore Raspian

ในกรณีที่เราต้องการที่จะติดตั้งเวอร์ชั่นใหม่ของ Raspian ซึ่ง ณ ตอนนี้อยู่ที่เวอร์ชั่น 2012-10-28-wheezy-raspbian.zip ซึ่งของผม ก็เก่ามากแหละ จะมีปัญหากับพวก USB wifi dongle อย่างหลีกเลี่ยงไม่ได้ จำเป็นที่จะต้องอัพเกรด ก็ต้องทำแล้วหล่ะ แล้วตอนติดตั้งลงไป แล้วถ้ามันไม่เวิร์กหล่ะ งานที่เคยทำไว้ อยากจะกลับมาใช้ตัวเก่าไปก่อน จะทำงัย????

จากตอนแรกๆ เลย ที่เราใช้โปรแกรม USB Image Tool Backup Raspian จากเครื่อง PC เราใส่ลงไปที่ Sd-Card ในทางตรงกันข้าม เราก็สามารถที่จะทำการ Restore จาก Sd-Card กลับมาลงที่เครือง PC เราได้เช่นกัน

เราจะมาลองทำดูกันนะครับ ทำการถอด Sd-Card ออกจากบอร์ด Raspberry Pi แล้วใส่เข้าไปที่ช่องเสียบ Sd-Card ที่ PC ของเรา จากนั้น เปิดโปรแกรม USB Image Tool ทำการเลือก Drive ที่ตรงกับ Drive ปัจจุบันของ Sd-card ของเรา จากนั้น ทำการเลือก Backup ให้เรา เลือกตำแหน่งที่จะเก็บไฟล์ และกำหนดชื่อไฟล์ที่จะทำการเก็บไว้ ในทีนี้ ไฟล์ที่ถูกเก็บจาก Sd-card ลงมาที่เครื่อง PC เราจะกลายเป็นไฟล์ .img หรือ .ima ก็ได้  รอสักครู่ จนโปรแกรมทำการ Backup ให้เรียบร้อย

ทีนี้ ผมก็ลอง Reastore Raspian เวอร์ชั่น 2012-10-28-wheezy-raspbian.zip ลงไปที่ Sd-card ทำตามขั้นตอนแรกๆ ที่เราเคยทำกันครับ (คลิก) เสร็จแล้วให้สังเกตไฟล์ี่ปรากฏใน Sd-card จะมีวันที่เป็น 10/28/2012 ซึ่งควรจะสัมพันธ์กันกับเวอร์ชั่นของไฟล์ใหม่

แล้วก็เอา Sd-card กลับไปเสียบที่บอร์ด Raspberry Pi จะเห็นว่า ตอนบูทขึ้นมา จะกลับเข้าสู่หน้า Raspi-config แสดงว่า เราสามารถที่จะ Reastore สำเร็จแล้ว

ทีนี้ ผมก็ถอดสาย power board Raspberry Pi ออกทันที แล้วถอด Sd-card กลับมา เพื่อทำการ Restore Raspian ตัวเก่าของเรากลับเข้าไปคืน ทำเหมือนเดิมทุกอย่างครับ (เลือกไปที่ไฟล์ที่เราได้ Backup เก็บไว้)

ปรากฏว่าใช้ได้ปกติ แสดงว่า เราสามารถที่จะสำรองตัวเก่าไว้ได้ หากเกิดเหตุการณ์ไม่ปกติกับเวอร์ชั่นใหม่ จะทำให้เราสามารถกลับมาใช้ตัวเก่าไปก่อน งานที่เคยทำไว้ จะได้ไม่สะดุดครับ

ปล.จะให้ดี ก็น่าจะซื้อ Sd-card มาเพิ่ม น่าจะดีไม่น้อย จะได้ไม่ต้อง Backup Restore Backup Restore กันไปมา งง ตายพอดี :P

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