Thursday, December 27

THE DEBIAN ADMINISTRATOR'S HANDBOOK

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 ประเภทไฟล์ครับ ต้องการรูปแบบไหน ก็เข้าไปเลือกดาวน์โหลดกันได้เลยครับ ..... คลิก

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

Monday, December 24

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 ขึ้นมาเลยครับ

Debian on VirtualBox

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
รอสักครู่ จะปรากฏข้อความรายงานผล 

nmap result

ในที่นี้ ผมได้รับรายงาน มา  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 หนังเรื่องนี้ สาระเยอะจริงๆ ถ้าตามเก็บรายละเอียดทั้งหมด จะพบว่า เราได้อะไรมากกว่า ฉากบู๊ที่ตื่นเต้น อีก

trinity uses nmap, shouldn't you?

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

Saturday, December 22

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 Checking Router's IP Address Project

     จริงๆ หลักการ ก็ไม่ได้ยากอะไร เราจะให้บอร์ด 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

Email alert from raspberry pi

เราลองลบไฟล์ 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

crond service checking router's ip address

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

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

Friday, December 21

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

crontab -e

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

image

แต่เมื่อเรามาเขียนสั่งใน 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 ได้ครับ

raspberry pi crontab

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

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

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

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

Sunday, November 18

How to install Debian on Oracle VM VirtualBox Manager

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

แน่นอนว่า Linux ตัวหนึ่งที่จะมาแนะนำก็ต้องเป็นเหมือน Linux ตระกูลเดียวกันกับที่ติดตั้งอยู่บนบอร์ด Raspberry Pi นั่นก็คือ Debian ครับ วันนี้เราจะมาติดตั้ง Debian บนโปรแกรม Virtual Machine สำหรับ Windows ครับ

Debian on VirtualBox Manager

อันดับแรก ให้ไปดาวน์โหลด
VirtualBox 4.2.4 for Windows hosts  x86/amd64 เพื่อทำสร้าง Virtual Machine
- ต่อมาก็ให้ไปดาวน์โหลดไฟล์ image จาก http://www.debian.org/ แล้วเลือก network install
จากนั้นมองหา Smaller CDs แล้วเลือก i386 (สำหรับ CPU intel) หรือจะเลือกจากลิ้งค์ตรงก็ได้ครับ i386
(http://cdimage.debian.org/debian-cd/6.0.6/i386/iso-cd/debian-6.0.6-i386-businesscard.iso)


เมื่อดาวน์โหลดมาเสร็จแล้ว ให้ติดตั้งไฟล์ VirtualBox 4.2.4 for Windows ก่อน เสร็จแล้วกำหนดค่า กำหนดพื้นที่ ที่จะจำลองเครื่องเสมือน แล้วก็ทำการ mount ไฟล์ image ของ debian เข้าไป แล้วก็เข้าสู่ขั้นตอนการติดตั้งเหมือนติดตั้ง linux ตัวอื่นๆ ทำตามขั้นตอน VDO เลยครับ

แต่ที่จะแนะนำอย่างหนึ่งก็คือ ตอนที่เลือก server สำหรับที่จะเอาไว้ดึงไฟล์อื่นๆ ผมแนะนำให้เลือก server http://mirror.kku.ac.th/ เวลาติดตั้ง package อื่นๆ จะได้เร็วหน่อย ไม่ต้องไปดึงไฟล์จาก server เมืองนอก

อย่าลืม username / password ที่เราสร้างไว้ที่ขั้นตอนการติดตั้ง Debian ด้วยนะครับ เพราะเราต้องใช้มัน login

โดยปกติแล้วโปรแกรม Virtual Machine จะตั้งค่า network ไว้เป็นแบบ NAT ซึ่งจะทำให้ Debian บน Virutal Machine ของเราสามารถต่อออก internet ได้เหมือนกับ windows ของเราครับ ถ้าหาก Debian ใครต่อออกอินเตอร์เนตไม่ได้ก็ให้ลองเช็คตัวนี้ดูครับ สำหรบข้อมูลการปรับแต่ Virtual Machine สามารถหาอ่านได้ตามอินเตอร์เนตครับ ข้อมูลค่อนข้างเยอะอยู่

ทีนี้ก็เหลือแต่ การทดลองใช้งาน แล้วก็ค้นคว้าหาความรู้เพิ่มเติมแล้วครับ ขอให้สนุกกับ Debian ครับ ^^’

ปล. ขอขอบคุณ Liam สำหรับขั้นตอนการติดตั้ง Debian บน Oracle VirtualBox Manager

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

Wednesday, November 14

Tips : change title bar terminal linux

วันนี้ มากันแบบสั้นๆ ได้น้ำได้เนื้อ ปกติเวลาเรารีโมทไปเครื่อง Linux ผ่านโปรแกรมพวก Putty ซึ่งถ้าหากเราต้องเปิดหน้า terminal หลายๆ หน้าต่าง และแต่ละหน้าต่าง ก็คนละ Server มันคง งง ไม่น้อย เพราะแต่ละ terminal ก็มีแต่ตัวหนังสือเต็มไปหมด ยิ่งถ้าเดินไปกินข้าว หรือกลับมาจากห้องน้ำ มีหวังได้ลืมกันแน่ ว่าหน้าต่างไหน เป็นของ Server ไหน

วันนี้ ผมได้นำเอาเทคนิคดีๆ มาฝากจากอินเตอร์เนตครับ เค้าใช้วิธีรัน shell script แล้วส่งค่า Process, runtime , user login มาแสดงที่ title bar ของโปรแกรม putty เรามาดูกัน

เริ่มแรกก็เปิด terminal ขึ้นมา แล้วพิมพ์คำสั่งนี้ (หรือจะก๊อปปี้ แล้ววางก็ได้ครับ)

while sleep 1;do echo -ne '\033]2;'$USER@$HOSTNAME' '$(uptime)'\007';done &

linux bash tip : change title bar terminal windows

ดูผลลัพธ์ที่ title bar ของ Putty ครับ แล้วลองเทียบค่าที่ปรากฏ กับค่าจากใช้งานคำสั่ง top ดูครับ

ง่ายๆ และมีประโยชน์ด้วยครับ วันนี้ มาสั้นๆ แค่นี้หล่ะ ไปศึกษา Linux ต่อ :P

เครดิต http://www.cyberciti.biz/

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

Monday, November 12

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 ให้เรียบร้อย

save image raspian

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

file datetime of new raspian

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

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

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

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

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

Saturday, November 3

Raspberry Pi and Arduino experiment

จากครั้งที่แล้ว เราได้เปิดการใช้งาน Serial Port ของ Raspberry Pi ไปแล้ว วันนี้เราจะมาลองเพิ่มประสิทธิภาพของ Raspberry Pi ด้วยการเพิ่ม Arduino ให้สื่อสารกับ Raspberry Pi ผ่านทาง Serial Communication โดยจะมีการรับส่ง คำสั่งและส่งค่ากลับผ่านทาง Serial Port ของ Raspberry Pi และ Serial Port ของ Arduino เพื่อเป็นแนวทางในการนำ Arduino มาใช้เป็น I/O ของ Raspberry Pi ซึ่งเราจะได้ I/O ที่เป็นดิจิตอล และ ได้ Analog input เพิ่มจาก Arduino นั่นก็แปลว่า Raspberry Pi เราจะมีความสามารถมากขึ้นไปอีก

ปล. สำหรับมือใหม่ Arduino คือไมโครคอนโทรลเลอร์ ที่มีการอ้างไปหาตำแหน่งหน่วย Input/output ของไมโครคอนโทรลเลอร์ ด้วยรูปแบบที่เหมือนๆ กัน มาใส่ไว้ที่ Bootloader ไม่ว่าจะเอาไมโครคอนโทรลเลอร์ตระกูลใด(ที่สามารถทำได้) ให้มาอยู่ใน Platform ของ Arduino แล้วหล่ะก็ ชื่อของ Input / Output ก็จะเหมือนๆ กัน ทำให้เง่ายต่อการศึกษา และป็นที่นิยมมาก

หลักการ ก็คือ Arduino และ Raspberry Pi เองจะต้องมีการเขียนโปรแกรมเพื่อรอรับค่า และส่งค่า ผ่านทาง Serial Comm เมื่อได้รับคำสั่ง (ที่เราเองเป็นคนกำหนดแล้ว) ก็จะให้แต่ละบอร์ด ไปทำตามคำสั่งนั้น แล้วส่งผลลัพธ์กลับไป ผ่านทาง Serial Comm เหมือนเดิม นั่นก็แปลว่า ทั้งทางฝั่ง Arduino และทางฝั่ง Raspberry Pi จะต้องมีโปรแกรมรองรับเป็นของตัวเอง แต่คุยกันด้วยรูปแบบการสื่อสาร UART  นั่นเป็นหลักการ เปรียบได้กับ ไม่ว่าบอร์ดนั้นจะมาจากไหน ตระกูลใด Platform ใดก็ตาม แต่ถ้าต้องการคุยกันให้รู้เรื่อง ต้องคุยกันเป็นแบบมาตรฐาน เช่น คุยกันรูปแบบ UART  สิ่งที่แต่ละบอร์ดต้องทำนั้นก็คือ ทำให้สัญญาณที่ต้องการจะสื่อสารกันนั้น อยู่ในรูปแบบภาษากลาง เป็นมาตรฐาน (ในที่นี่คือ UART) นั่นเอง เหมือนกันกับ แต่ละชาติ แต่ละภาษา หากต้องการสื่อสารกัน เราจะใช้ภาษาอังกฤษ เป็นตัวกลางในการสื่อสารนั่นเอง

ที่นี่ เรามาลองทำโจทย์กันง่ายๆ ก่อน เพื่อให้เกิดความเข้าใจ ระหว่างการเขียนโปรแกรมให้ Raspberry Pi และ Arduino ให้สื่อสารกันได้ โดยเราจะให้  Raspberry Pi ทำการอ่านค่าการกดสวิทช์ที่ต่ออยู่กับช่องดิจิตอลของ  Raspberry Pi ช่องที่ 24 และ 26 เมื่อมีการกดสวิทช์เกิดขึ้น  Raspberry Pi จะส่งค่าคำขอไปที่ Arduino เพื่อให้ทำการอ่านค่าสัญญาณอะนาล๊อก (ซึ่งอาจจะเป็นค่าจากเซนเซอร์แบบใดๆก็ได้) ในที่นี้ เราจะให้ R ปรับค่าได้เป็นตัวสร้างสัญญาณอะนาล๊อก ที่ช่องสัญญาณ AN0 และ AN1 ของบอร์ด Arduino แล้วให้ Arduino ทำการส่งค่ากลับไปบอก Raspberry Pi ส่วน Raspberry Pi เมื่อได้ค่ามาแล้วให้แสดงผลผ่านทาง Console ต่อไป

ในด้านฮาร์ดแวร์นั้น เนื่องจาก Arduino เองสามารถส่งสัญญาณแรงดันออกมาได้ถึง 5 V เพราะฉะนั้น ที่ด้านส่งข้อมูลออกของ Arduino จะต้องทำการปรับแรงดันให้เหลือ ในระดับที่ปลอดภัยสำหรับ Raspberry Pi เสียก่อน ส่วนทางด้านรับข้อมูลเข้าของ Arduino ไม่จำเป็นต้องปรับแรงดัน เพราะแรงดันจากขาออก 3.3V จาก Raspberry Pi นั้น เป็นระดับที่ Arduino เข้าใจได้

Arduino                                                  Raspberry Pi
   Rx<--------------------------------------------->Tx
   Tx (ปรับลงเหลือ 3.3 V ก่อน)<---------------> Rx
   GND<----------------------------------------->GND

ในการแปลงแรงดันจาก 5V ให้ลดลงเหลือ 3.3V เราใช้วิธี Voltage Divider โดยเราจะใช้ตัวต้านทานค่า 10k ทำการแบ่งแรงดัน  (ผมลองวัดค่าดูแล้ว ค่าไม่เกิน 3.3V และอยู่ในช่วงที่ Raspberry Pi เข้าใจระดับสัญญาณได้)

Raspberry Pi and Arduino Experiment

คำเตือน : ระวังเรื่องของระดับสัญญาณด้วยนะครับ อย่าให้เกิน 3.3V สำหรับตำแหน่งใดๆ ก็ตามที่จะต่อเข้า GPIO ของ Raspberry Pi

การพัฒนาโปรแกรมทางฝั่ง Arduino
สามารถเริ่มต้นศึกษาได้จากตัวอย่างที่ผมได้ทำไว้แล้ว จากที่นี่ http://mechacity.blogspot.com/2011/03/arduino.html  ทำการเขียนโค๊ดบน ARDUINO IDE แล้วทำการโปรแกรมลงบนบอร์ด Arduino
ด้วยโค๊ด

const int analogInPin0 = A0;    // Analog input pin that the potentiometer is attached to
const int analogInPin1 = A1;    // Analog input pin that the potentiometer is attached to

void setup() {
  // initialize serial communications at 115200 bps:
  Serial.begin(115200);
}

void loop() {
  unsigned int cmd;
  unsigned int sensorValue = 0;        // value read from the pot
  if(Serial.available() > 0){
    cmd = int(Serial.read()) - 48;
    switch(cmd){
      case 1:
        sensorValue = analogRead(analogInPin0);
        Serial.print("A0=" );
        Serial.print(sensorValue,DEC);
        Serial.print("|" );
        Serial.flush();
        break;     
      case 2:
        sensorValue = analogRead(analogInPin1);
        Serial.print("A1=" );
        Serial.print(sensorValue,DEC);
        Serial.print("|" );
        Serial.flush();
        break;   
    }
  }   
}

Arduino Firmware

หมายเหตุ : ในระหว่างการทำการโปรแกรมลงบอร์ด Arduino เราต้องไม่ให้ pin RX ของ Arduino ต่ออยู่กับอะไรในวงจร เพราะวงจรในบอร์ด Arduino ต้องใช้ pin RX ในการโปรแกรม (Burn) ลงชิพ

การพัฒนาโปรแกรมทางฝั่ง Raspberry Pi
เรายังคงใช้ภาษา Python แล้วโมดูล Python-serial ในการพัฒนาโปรแกรม โดยนำโค๊ดจากตัวอย่างที่แล้ว มาทำการดัดแปลงให้เข้ากับโจทย์ที่เราจะทดลอง บันทึกชื่อไฟล์ arduinoProj1.py
โค๊ด

#! /usr/bin/python
import serial
import time
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BOARD)
GPIO.setup(24,GPIO.IN,pull_up_down=GPIO.PUD_UP)
GPIO.setup(26,GPIO.IN,pull_up_down=GPIO.PUD_UP)

ser = serial.Serial('/dev/ttyAMA0',115200,timeout=1)
ser.open()
time.sleep(2)

def readLine(ser):
    str = ""
    while 1:
        ch = ser.read(1)
        if(ch == '|'):
            break
        str += ch
    return str

while True:
    line = ''
    if(GPIO.input(24) == False):
        ser.write('1')
        print 'button1 pressed'
        line = readLine(ser)
    elif(GPIO.input(26) == False):
        ser.write('2')
        print 'button2 pressed'
        line = readLine(ser)
    try:
        if line <> '':
            data = line.split('=')
            print 'Analog channel ' + data[0] + ' value = ' + data[1]
    except KeyboardInterrupt:
        pass
        GPIO.cleanup()
        ser.close()
        print 'Good bye!!!'

Raspberry Pi Firmware

ทดสอบการทำงาน ด้วยการรันโปรแกรมผ่าน Console ด้วยคำสั่ง (ภายใน directory ที่เก็บไฟล์ arduinoProj1.py) ด้วยคำสั่ง sudo ./arduinoProj1.py  จากนั้นทำการกดปุ่มที่ต่ออยู่กับ GPIO 24 และ 26 ของ Raspberry Pi สังเกตผลลัพธ์บนหน้าจอ Console แล้วทดลองปรับค่าความต้านทาน สังเกตการเปลี่ยนแปลง

Arduino and Raspberry Pi

จริงๆ แล้วเราควรที่จะเลือกใช้ Arduino Firmware ที่ยืดหยุ่นกว่านี้ ผมหมายถึง เราไม่ควรทำการแก้ไขโค๊ดที่ฝั่ง Arduino มากนัก แต่ควรจะมีโค๊ดที่สามารถปรับเปลี่ยนการทำงานตั้งแต่ฝั่ง Raspberry Pi เพื่อกำหนดการทำงานของ Arduino แทน ซึ่งในอินเตอร์เนตมี Library ประเภทนี้ อยู่ ตอนต่อไป ผมอาจจะนำมาสาธิตให้ดูนะครับ

สวัสดีครับ

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

Friday, November 2

minicom - friendly serial communication program

ถ้าหากเราจะมองว่า Hyper Terminal คือโปรแกรมสำหรับ รับ-ส่งค่า ทาง Serial Port คอมพิวเตอร์ ของ Windows แล้วหล่ะก็ โปรแกรม minicom คือโปรแกรมที่ทำหน้าที่คล้ายกันกับ Hyper Terminal ที่สามารถรับส่งค่าผ่านทาง Serial Port ของ Raspberry Pi ที่รันผ่าน Console ของ Linux ได้เช่นกัน

ก่อนอื่น ทำการติดตั้งโปรแกรม minicom ผ่านทาง Console Linux ของเราเสียก่อนครับ ด้วยคำสั่ง

sudo apt-get install minicom

ตอบ y เพื่อยืนยัน รอสักครู่จนติดตั้งโปรแกรมเสร็จ จากนั้น ทดลอง เรียกโปรแกรม โดยเราจะอาศัย UCON-UART ที่ผมได้สาธิตไว้ครั้งก่อนหน้านี้ (ดูวงจรการต่อ) ต่อวงจรเหมือนเดิม แล้วทดลองกับโปรแกรม Serial Port ของ Arduino ครับ ตั้งค่า BaudRate ของ Serial Port ของ Arduino เท่ากับ 115200

จากนั้น พิมพคำสั่ง  minicom -b 115200 -o -D /dev/ttyAMA0  โดยเราจะติดต่อกับ Serial Port ของ Raspberry Pi ซึ่งมองเห็น Device อันนี้เป็น ttyAMA0

หลังจากพิมพคำสั่งแล้ว หน้าต่าง cosole linux ของเราจะเข้าสู่โหมดของ minicom เราสามารถส่งค่าจาก windows ของเรามาที่บอร์ด Raspberry Pi ได้เลย จะปรากฏข้อมูลที่ส่งมาทาง console linux ดังรูปครับ

minicom program

สนใจ parameter เพิ่มเติมของ minicom เราสามารถใช้คำสั่ง man minicom เพื่อดูรายละเอียดเพิ่มเติมได้

ปล. ผมไม่สามารถออกจากหน้าต่าง minicom ได้ แม้ว่าจะได้ทดลองกด Ctrl-A ถึง Z แล้วก็ตาม ในที่นี้ ผมก็เลยต้องเปิดหน้าต่าง putty ขึ้นมาอีกอัน แล้วมองหา process ของ minicom ด้วยคำสั่ง ps aux | grep minicom แล้วทำการ kill -9 process_id_minicom ซะเลย ถึงจะออกจากโหมด minicom ได้

kill process minicom

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

Sunday, October 28

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

 /etc/inittab

ทำการบันทึกไฟล์ และ 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)

import 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 ได้จริง ทำการต่อวงจรเหมือนเดิมครับ

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

rs232.py
บันทึกไฟล์แล้วแล้วเปลี่ยนโหมดให้สามารถ 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 ได้

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

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

Thursday, October 25

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 ได้เช่นกัน

MAX3232CPE connect Raspberry Pi

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

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

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

Remote Rasbperry Pi via Serial Communication

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

Putty setting serial communication

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

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

Putty setting serial communication

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

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

 Boot Raspian

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

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

สวัสดีครับ

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

Wednesday, October 24

htop - interactive process viewer for monitoring RPi

    อย่างที่เรารู้กันว่า เจ้าบอร์ด Raspberry Pi มันไม่ได้มี memory มากมายก่ายกอง และเจ้า CPU เอง ก็ไม่แรงมากมาย ทุกครั้งที่เราติดตั้ง package เพิ่ม บางครั้งเราควรทำการประเมินด้วยว่า คุ้มค่าต่อการติดตั้งลงไปที่บอร์ด Raspberry Pi ของเราไหม

เดิมทีผมมักจะใช้คำสั่ง top ในการตรวจดู process ต่างๆ ที่ทำงานอยู่ foreground/background process เพื่อทำการเช็คดู package ที่ติดตั้งลงไปใหม่ ว่าทำงานเป็นอย่างไรบ้าง กิน memory เยอะไหม , CPU ทำงานหนักไหม แต่วันนี้ ผมจะแนะนำ htop ซึ่งเป็น package อีกตัวหนึ่งที่ทำหน้าที่คล้ายคำสั่ง top ของเรา แต่ มันดีกว่า ตรงที่มันตอบสนองต่อ mouse ที่เราคลิกลงไปด้วย ไม่ว่าจะเป็นการ sort ข้อมูล การเลื่อนดูแต่ละแถวก็จะมีสีไฮไลท์แต่ละบรรทัด ทำให้สะดวกกว่า คำสั่ง top ตัวเก่ามาก

เรามาติดตั้งกันเลย

sudo apt-get install htop

รอสักครู่ แล้วเรียกคำสั่ง htop จะปรากฏการแสดงผลการทำงานแต่ละโปรเซส ว่าทำงานใช้หน่วยความจำไปเท่าไหร่ และใช้ CPU ไปเท่าไหร่ ดูมีสีสัน น่าสนใจกว่าเก่าเยอะเลยใช่ไหมครับ (ลองเปรียบเทียบกับคำสั่ง top ดู )

  htop - interactive process viewer

ลองไปติดตั้งกันดูนะครบ สวัสดีครับ

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

Simple Home Security System By Raspberry Pi

วันนี้ เรามาลองสร้างระบบเตือนภัยจากผู้บุกรุก โดยเราจะให้เจ้าบอร์ด Raspberry Pi ของเราทำการส่งเมล์ไปหาเรา ถ้ามีใครสักคนพยายามงัดแงะหน้าต่าง หรือประตูของเรา หรือจะเช็คจุดไหนก็ได้ ที่สามารถต่อสวิทช์ หรืออุปกรณ์ตรวจสอบใดๆ ก็ได้ที่ทำให้เกิดการเปลี่ยนแปลง logic จาก Low ไป High เพื่อที่เราจะได้ต่อเข้ากับ GPIO ของบอร์ด Raspberry Pi เมื่อเกิดการเปลี่ยนแปลงสถานะ logic ณ จุดใดๆ ที่ต่ออยู่กับ GPIO ของ Raspberry Pi แล้ว ให้เจ้าบอร์ด Raspberry Pi ของเราส่งเมล์มาบอกเรา เพียงเท่านี้ เราก็จะได้ระบบรักษาความปลอดภัย ที่กินไฟน้อยที่สุดในโลกแล้ว (อาจจะฟังดูเวอร์ไปเล็กน้อย :P )
อันนี้ เป็นวงจรการทำงานพื้นฐานนะครับ แน่นอน ถ้าจะทำจริงๆ ก็ต้องดัดแปลง ปรับปรุงให้เกิดความเสถียรภาพมากกว่านี้ ไม่ว่าจะเป็นระบบสำรองไฟฟ้า หากเกิดกรณีไฟฟ้าดับ และระบบป้องกันไฟเกิน และอื่นๆ อีกที่ควรจะใส่เข้าไป เพื่อให้ระบบเราทำงานได้ แม้ในสภาวะที่ไม่ปกติด้วยนะครับ ก็ลองไปคิดๆ กันดูว่าต้องมีอะไรบ้าง
Raspberry Pi Home Security System
ในที่นี้ ผมจะสมมติให้ push button ทำหน้าที่เป็นสวิทช์ประตู เมื่อมีการเปลี่ยน logic จาก high เป็น low ให้ raspberry Pi ทำการเริ่มส่งเมล์ มาตามที่กำหนดไว้ในโค๊ด
Raspberry Pi simple Circuit
ด้วยความสามารถของ 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
Python sending mail to Gmail server 
ถ้าทุกอย่างถูกต้อง เราจะพบเมล์ในกล่องขาเข้าของจดหมาย จาก raspberry security system
จากตัวอย่างที่นำเสนอนี้ เป็นรูปแบบอย่างง่าย นะครับ หากจะนำไปใช้จริงๆ เพื่อนต้องปรับแต่งให้ระบบของเพื่อนๆ สามารถที่จะตรวจสอบได้ตลอดเวลา ว่ายังทำงานอยู่หรือเปล่า และเมื่อเวลาเกิดเหตุการณ์ขึ้นแล้ว จะให้ Email ส่งมาเตือนกี่ครั้ง และจะรีเซตระบบกลับเหมือนเดิมได้อย่างไร นั่นเป็นสิ่งที่ต้องนำกลับไปคิดกันต่อนะครับ ลองๆ เอาไปประยุกต์กันดูนะครับ หวังว่าคงเริ่มสนุกกับ Raspberry Pi แล้วนะครับ
อ่านเพิ่มเติม...

Monday, October 22

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 เลย
Raspberry Pi with LCD 16x2 circuit diagram
จากนั้น ทำการเขียนโค๊ด ตามนี้  จะเขียนที่ 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 ครับ
RPi.GPIO control LCD 16x2
เราจะเห็นแนวทางการพัฒนา library สำหรับการติดต่อกับอุปกรณ์อื่นๆ โดยใช้ความสามารถของ RPi.GPIO บวกกับการจัดลำดับสัญญาณไฟฟ้าให้เป็นไปตาม data sheet ของอุปกรณ์แต่ละตัว เราก็จะสามารถควบคุมอุปกรณ์ตัวนั้นได้แล้วครับ เพื่อนๆ ลองนำไปประยุกต์ใช้กันดูนะครับ
ปล.ขอบคุณภาพประกอบบางส่วน และโค๊ดจาก http://www.raspberrypi-spy.co.uk
อ่านเพิ่มเติม...

How to config MySQL Front connect with Raspberry Pi

        หลังจากที่เราได้ติดตั้ง MySQL Server ลง Raspberry Pi แล้ว หากใครยังไม่ติดตั้งดูวิธีติดตั้งย้อนหลังที่นี่ (คลิก)  อย่างที่เรารู้กัน หากต้องการเข้าไปค้นหาข้อมูลในฐานข้อมูล หรือการแก้ไข แทรก ลบ หรือกระทำการใดๆ กับฐานข้อมูล MySQL แล้วหล่ะก็ เราจะต้องกระทำผ่าน console ของ MySQL แล้วใช้คำสั่ง ซึ่งเป็นภาษา SQL ทั้งหมด หากคนที่ยังไม่ค่อยสันทัดภาษานี้แล้วหล่ะก็ ลำบากอยู่พอสมควร หรือแม้ แต่คนที่ใช้ SQL คล่องแล้วก็ตาม หากต้องใช้ console ที่เป็น MySQL หล่ะก็ ก็ต้องพบกับความลำบากในการใช้งานอยู่ไม่น้อยเลย งั้นเรามามองหา Third Party ที่เป็น GUI ในการติดต่อกับฐานข้อมูล MySQL ของ Raspberry Pi กันเหอะ น่าจะทำให้งานเรื่องฐานข้อมูล ง่ายไม่น้อยเลย

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

โปรแกรม MySQL Front เป็นโปรแกรมสำหรับ ติดต่อกับฐานข้อมูล MySQL ซึ่งแตกต่างกับ phpmyadmin (ที่ผมไม่ได้ติดตั้งไว้) ตรงที่ phpmyadmin จะกระทำผ่านเว็บบราวเซอร์ แต่ MySQL Front กระทำบนเครื่อง PC ที่เป็น windows (ที่รีโมทเข้าไปใช้งานฐานข้อมูล) เรียกกว่าได้เป็นโปรแกรมที่รันบน windows หล่ะกัน 

อันดับแรกให้เราไปดาวน์โหลดโปรแกรม MySQL Front มาก่อน ผมแนะนำว่าเป็นเวอร์ชั่น 5.2 ขึ้นไป (เข้าไปที่นี่ http://www.mysqlfront.de/) จากนั้นก็ติดตั้งบน windows ตามปกติ

จากนั้นให้เราทำการอัพโหลดไฟล์ C:\Program Files\MySQL-Front\libMySQL.php ด้วยโปรแกรม Filezila จากตอนที่แล้ว (คลิก) เข้าไปไว้ที่โฟวเดอร์ /var/www ของ Rapsberry Pi (เนื่องจากเราต้องติดต่อ MySQL Server ของ Raspberry Pi ผ่าน "HTTP tunnel" )

ทำการแก้ไขโหมดของไฟล์นี้ ให้สามารถ execute ได้ ด้วยคำสั่ง (รู้อยู่ใช่ไหม ขั้นตอนนี้เราต้อง remote ผ่าน SSH เข้าไปทำที่ Raspberry Pi คงไม่ลืมกันนะ)

cd /var/www/

sudo chmod 744 libMySQL.php

ls –la

sudo chmod 744 libMySQL.php

จากนั้น เราจะต้องทำการแก้ไขให้ user root ให้สามารถ login มาจากคอมพิวเตอร์เครื่องใดก็ได้ ให้สามารถเชื่อมต่อฐานข้อมูล MySQL ของ Raspberry Pi ได้ ด้วยการเข้าสร้าง user root  ใน MySQL ด้วยการ login เข้าใช้ MySQL ก่อน ด้วยคำสั่ง

mysql -u root -p เคาะ Enter 1 ครั้ง แล้วใส่ password (หวังว่าคงไม่ลืมเองนะ)

ทำการเช็คดูก่อนว่ามี user root ที่ Host เท่ากับ '%' ไหม ด้วยการค้นหาข้อมูลในฐานข้อมูล mysql  ด้วยคำสั่ง

use mysql;  // เพื่อการย้ายตำแหน่งการทำงานเข้าไปอยู่ที่ตารางข้อมูล mysql

แล้วตามด้วยคำสั่ง

select Host,User,Password from user;

จะพบว่าตอนนี้เรายังไม่มี root ที่ช่อง user และ % ที่ช่อง Host

select Host,User,Password from user;

สมมติว่าไม่มี root ในช่อง User และ '%' ในช่อง Host (ซึ่งสองเงื่อนไขนี้ เป็นตัวบอกว่า root สามารถถูก login จากเครื่องใดๆ ก็ได้)  แต่ถ้าหากว่ามีอยู่แล้ว ก็อาจจะลองลบแล้วสร้างใหม่ก็ได้ โดยใช้คำสั่งลบทิ้งไปก่อน
DELETE FROM mysql.user WHERE User = 'root' AND Host = '%';
FLUSH PRIVILEGES;

จากนั้นเราจะทำการสร้าง user root ให้สามารถ login จากเครื่องใดๆ ก็ได้ ด้วยคำสั่ง

GRANT ALL PRIVILEGES ON *.* TO root@"%" IDENTIFIED BY 'พาสเวิร์ดตามใจเลยครับ';
FLUSH PRIVILEGES;

ลองดูที่ฐานข้อมูลอีกทีจะพบ user root ที่มีค่า Host = '%' เรียบร้อยแล้ว

GRANT ALL PRIVILEGES ON *.* TO root@"%" IDENTIFIED BY 'พาสเวิร์ดตามใจเลยครับ';

กลับมาที่เครื่อง PC windows ของเราที่ได้ติดตั้งโปรแกรม MySQL Front ไว้แล้ว เราจะทำการกำหนดค่าเริ่มต้นในการเชื่อมต่อกับฐานข้อมูลของ Raspberry Pi โดยการกำหนดค่า connect ไว้ดังนี้

เปิดโปรแกรม MySQL Front ขึ้นมา แล้วกด F12 จากนั้นให้คลิกที่ New...

ตั้งชื่อ Name ที่ Description ตามใจชอบ

ที่ส่วน Connection ให้กำหนดดังนี้

Server : localhost
Port : 3306
Connection Type : HTTP Tunnel
HTTP Tunnel URI : http://192.168.2.111/libMySQL.php

ในส่วนของ Login Information กำหนดดังนี้

User : root
Password : ที่ตั้งไว้แล้วจากขั้นตอนข้างบน

แล้วกด OK

MySQL Front HTTP Tunnel

จากนั้นกด Open  รอสักครู่ โปรแกรมจะทำการเชื่อมต่อกับฐานข้อมูล MySQL ของ Raspberry Pi (นานหน่อย เพราะ RAM น้อย ) 

จะปรากฏหน้าต่างของฐานข้อมูลบน Raspberry Pi จะเห็นได้ว่า เมื่อดูผ่านโปรแกรม MySQL Front จะเห็นเป็นรูปแบบกราฟฟิค ซึ่งสะดวกกว่าการใช้คำสั่ง SQL พิมพ์บน mysql console  ซึ่งสะดวกกว่ามาก

ลองๆ ไปทำกันดูครับ ส่วนการใช้งาน MySQL Front ผมไม่ขออธิบายมากหล่ะกัน คลิกๆ ไป เดี๋ยวก็ทำเป็นครับ แต่ให้ระวังเรื่องการลบข้อมูลด้วยนะครับ ว่าแต่ละครั้งที่เราจะทำการลบอะไรก็ตาม ต้องมั่นใจว่าเราต้องการลบข้อมูลที่ต้องการจะลบจริงๆ เพราะเมื่อคลิกไปแล้ว ข้อมูลหายจริงๆ ครับ ตรงนี้ให้ระมัดระวังในการใช้คำสั่งลบให้ดีๆ

MySQL Front + Raspberry Pi

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

Monday, October 15

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

image 

ทำการเสียบเจ้า 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

image 

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

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

sudo umount /media/usbdisk

image

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

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

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

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

แจกฟรี พื้นที่ฝากไฟล์ 15 GB

ติดตามข่าวสารผ่าน Twitter

ติดตาม Blog นี้

About Me

My photo

สวัสดีครับ ชื่อเปิ้ลนะครับ ถ้ามีอะไรให้ช่วยเหลือได้ ก็จะช่วยครับ
ผมได้สร้างบล๊อกไว้ เพื่อเก็บรวบรวมความรู้ และประสบการณ์ในการทำงานครับ แวะไปเยี่ยมชมกันได้ครับ http://mechacity.blogspot.com และบล๊อก http://faker-programmer.blogspot.com ครับ

Blog อื่นๆของฉัน

Microcontroller Electronics update

สถิติเยี่ยมชมบล๊อก