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

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

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

Friday, October 12

How to setup WebServer, DatabaseServer on Raspberry Pi

    ในตอนนี้ เรากำลังเข้าใกล้การควบคุม Raspberry Pi ผ่าน network แล้ว อีกหนึ่ง package ที่น่าสนใจ ก็คือ การทำให้บอร์ด Raspberry Pi ของเรากลายเป็น Server ย่อมๆ ที่กินไฟน้อยที่สุดในโลกเลยก็ว่าได้ โดยในตอนนี้ เราจะมาทำให้กลายเป็น Web server (ที่ให้บริการเกี่ยวกับเว็บเพจ) และ Database Server (ให้บริการเกี่ยวกับฐานข้อมูล)

    แน่นอนว่า ถ้าเป็นระบบปฏิบัติการ Linux แล้วหล่ะก็ เรามักนิยมใช้โปรแกรม Apache ซึ่งจะทำให้เครื่องคอมพิวเตอร์เครื่องใดๆ ก็ได้ที่ลงโปรแกรมนี้ จะกลายเป็น Web server ทันที เพียงแค่เราอ้างอิงหมายเลขไอพี ผ่านโปรโตคอล http หน้าเว็บบราวเซอร์  เช่น http://192.168.2.111 ก็จะทำให้บอร์ด Raspberry Pi ของผมกลายเป็น Web server แล้วส่งหน้าเว็บเพจที่ชื่อ index.php หรือ index.html กลับไปที่บราวเซอร์ที่เรียกมาทันที  ส่วนฐานข้อมูลที่นิยมกัน ได้แก่ Mysql , sqlite, PostgreSQL และอื่นๆ อีกหลายตัว  นอกจากนี้ เรายังสามารถที่จะเพิ่มตัวแปรภาษาสคริปต์ เพื่อทำให้ web server ของเรามีความสามารถมากขึ้นนอกจากจะเป็นเพียงแค่ เว็บให้บริการหน้าเว็บเพจ อาจจะมีการเพิ่มการเก็บข้อมูล การเรียกดูข้อมูล จากฐานข้อมูลได้อีกด้วย พวกภาษาสคริปต์ ก็มีหลายตัว แล้วแต่เราจะถนัด และชอบ ได้แก่ ภาษา PHP , Perl , Python ซึ่งสามารถเข้ากันได้ดีกับตัวฐานข้อมูลที่ได้กล่าวไปแล้วข้างต้น 

เอาหล่ะ มัดมือชก เลยหล่ะกัน :P เราจะมาติดตั้ง

- Apache2 เพื่อทำให้ Raspberry Pi ของเรากลายเป็น Web server
- MySQL Server เพื่อทำให้ Raspberry Pi ของเรากลายเป็น Database Server
- PHP5 เพื่อให้ Raspberry Pi ของเรามีตัวแปลภาษาสคริปต์ เพื่อติดต่อกับ Database Server และเขียนภาษาสคริปต์ได้

หลังจากที่ login ผ่าน SSH เข้ามาแล้ว ก็ให้อัพเดท package ที่เคยติดตั้งไว้แล้ว ว่ามีอะไรอัพเดทใหม่บ้าง

sudo apt-get update

จากนั้นทำการโหลด package apache2,php5,ibapache2-mod-php5   เข้ามาต่อเลย ด้วยคำสั่ง

sudo apt-get install apache2 php5 libapache2-mod-php5

แต่โดยปกติแล้ว ผมจะโหลดทีละ package เพราะดูเหมือนโหลดพร้อมๆ กันแล้วมันจะ Error บ่อย  U_U

sudo apt-get install apache2
sudo apt-get install php5
sudo apt-get install libapache2-mod-php5

sudo apt-get install apache2

ติดตั้งเสร็จแล้ว ตัว apache เองจะทำการ restart apache service อาจจะมีการแจ้งเตือน Fail ขึ้นมา

sudo groupadd www-data ให้เราทำการแก้ไขด้วย
sudo groupadd www-data
และ
sudo usermod -g www-data www-data

เพื่อเพิ่ม กรุ๊ปใหม่ และทำการโมดิฟายกรุ๊ปนั้น จากนั้น เราจะต้องทำการกำหนดสิทธิ์ให้ผู้ใช้สามารถเข้าถึง director ใดได้บ้างใน path ที่เก็บเกี่ยวกับหน้าเว็บเพจ ตรงนี้ ถ้าสนใจ ให้หาข้อมูลเพิ่มเติมเกี่ยวกับ htaccess file ทำการแก้ไขไฟล์ 000-default ด้วยคำสั่ง

sudo nano /etc/apache2/sites-enabled/000-default

จากนั้น มองหาบรรทัดที่เขียนว่า AllowOverride None ให้แก้เป็น AllowOverride ALL แล้วทำการบันทึกไฟล์ และออกจากโปรแกรม nano

sudo nano /etc/apache2/sites-enabled/000-default

ทำการรีสตาร์ทเซอร์วิส ของ Apache2 อีกครั้งเพื่อให้เซอร์วิส นี้นำค่าใหม่ไปใช้

sudo service apache2 restart

ในส่วนของการติดตั้ง package เพื่อให้ Raspberry Pi ของเราเสร็จเรียบร้อยแล้ว หากต้องการเพียงแค่ให้ Raspberry Pi แสดงข้อความหน้าเว็บเพจ เราก็ทำได้เลย โดยการใส่ไฟล์ที่เขียนด้วยภาษา HTML แล้วเราไปวางที่ /var/www/ (ด้วยวิธีการ FTP จากตอนที่แล้ว) จากนั้น ลองทำการเรียกดูข้อมูลผ่านหน้าเว็บบราวเซอร์ ที่เครื่องคอมพิวเตอร์ของเรา โดยอ้างอิงไปที่ IP ของบอร์ด Raspberry Pi เช่น  http://192.168.2.111/ไฟล์.html  ก็จะปรากฏเนื้อหาที่เราเขียนลงไปในไฟล์ html นั้น 

http://192.168.2.111


ต่อมาเราจะทำให้ php5 ของเราที่ได้ติดตั้งไว้แล้ว สามารถเรียกข้อมูลจฐานข้อมูลที่เราจะติดตั้งต่อไปนี้ได้ 

ทำการติดตั้ง  mysql-server, mysql-client และ php5-mysql  ด้วยคำสั่ง

sudo apt-get install mysql-server mysql-client php5-mysql

sudo apt-get install mysql-server mysql-client php5-mysql

ในระหว่างขั้นตอนนี้ จะมีการให้ตั้งค่า password ของ root ที่จะ login เข้าในฐานข้อมูล Mysql ซึ่งเราอาจจะตั้ง password ใหม่ ที่ไม่เหมือนกับ password ของ root ที่ login เข้าใช้ raspberry pi ก็ได้ หรือจะให้เหมือนกันก็ไม่เป็นไร แล้วแต่สะดวกหล่ะกัน

root password for MySQL

เมื่อติดตั้งเรียบร้อยแล้ว ให้ทดสอบ login ใช้ฐานข้อมูล Mysql  เพื่อความแน่ใจ ให้ลองรีสตาร์ทเซอร์วิส Mysql ดูสักครั้งก่อน

sudo service mysql restart

จากนั้น ให้พิมพ์คำสั่งเข้าใช้ MySQL ด้วยคำสั่ง

sudo service mysql restart

รอจนเซอร์วิสสตาร์ทเรียบร้อยให้ใช้คำสั่ง

mysql -u root -p

แล้วทำการใส่ password ของ root ที่เราได้กำหนดไปเมื่อสักครู่ (อย่าบอกว่า ลืมนะ!!!  งานเข้าแน่ๆ หล่ะ)

เมื่อเข้ามาได้แล้ว prompt จะเปลี่ยนไปเป็น mysql>  ให้เราใช้ภาษา SQL (ต้องเรียนรู้เพิ่มอีกแหละ U_U ) เพื่อขอดู database ที่มีอยู่ตอนนี้

mysql> show databases;   จะปรากฏดังภาพ (เป็นค่ามาตรฐานที่ติดตั้งมา)

Mysql database on Raspberry Pi

ในตอนหน้า ผมจะแนะนำโปรแกรม MySQL Front ที่ใช้สำหรับรีโมทจากเครื่องคอมพิวเตอร์ของเรา เพื่อเข้าถึงฐานข้อมูลที่อยู่บน Raspberry Pi เพื่อให้การใช้งาน สร้าง แก้ไข ปรับปรุง เพิ่ม ลบ ข้อมูล ในดาต้าเบสเกิดความง่ายดายขึ้น ไม่ต้องมาพิมพ์ภาษา SQL ทั้งหมด (แต่รู้ไว้บ้างก็ดี :P )  และการแก้ไข หากเพื่อนๆ ลืม password ของ root ที่ใช้เข้า login mysql

ขอบคุณรูปประกอบบางส่วนจาก http://www.instructables.com

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

Reset root password mysql of Rasberry pi

     พอดี ผมเจอปัญหาที่เกิดจากความขี้หลงขี้ลืม ของตัวเอง หลังจากติดตั้ง mysql package ลงบนบอร์ด Raspberry pi ก็ปรากฏว่า ลืม Password root ซะอย่างงั้นจะเดาให้ตาย ก็ไม่เจอ จำไม่ได้จริงๆว่าตั้ง password ไว้อะไร ได้ลองลบ mysql package ออกแล้ว แต่พอลงใหม่ เจ้าบอร์ด Raspberry Pi ก็ดันไปเอาค่าเก่ามาซะอย่างนั้น ให้ตายสิ!!!!

forgot root password mysql on raspberry Pi

เห็นทีต้อง reset password root บน Mysql ซะแล้วแบบนี้ ค้นหาข้อมูลในเนต ก็เจอนะ แต่ งง ฉิบ โดยเฉพาะเว็บหลัก Mysql เข้าไปอ่านแล้ว งง จริงๆ มันให้ทำอะไรของมันก็ไม่รู้ (จริงๆ มันก็บอกถูกแหละ แต่ผมไม่เข้าใจเอง :P )

อาการเวลาเราเรียกใช้ Mysql จะโชว์ข้อความ

#mysql -u root -p
Enter Password:

ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: NO)

ให้ทำการหยุด service mysql ก่อน ถ้ายังไม่ได้เป็น root ให้เปลี่ยนตัวเองให้เป็น root ก่อนครับ ด้วยคำสั่ง

sudo su

เมื่อกลายเป็น root แล้ว (จะพบว่า ที่ prompt จะกลายเป็น # ) ให้เราทำการหยุด service mysql ด้วยคำสั่ง

service mysql stop  หรือจะใช้คำสั่ง /etc/init.d/mysql stop ก็ได้ครับ

จากนั้น ให้เราทำการเข้าไปแก้ไขที่ไฟล์ /etc/init.d/mysql ด้วยคำสั่ง

nano /etc/init.d/mysql

มองหาบรรทัดที่เขียนว่า  /usr/bin/mysqld_safe  > /dev/null 2>&1 &
ให้ทำการเพิ่ม --skip-grant-tables ต่อท้าย mysqld_safe จะได้ว่า

nano /etc/init.d/mysql

/usr/bin/mysqld_safe --skip-grant-tables > /dev/null 2>&1 &

บันทึกไฟล์ Ctrl+x , กด Y , แล้วกด Enter

จากนั้น ให้เราทำการเริ่ม service mysql ใหม่อีกครั้ง ด้วยคำสั่ง

service mysql start หรือคำสั่ง /etc/init.d/mysql start ก็ได้เหมือนกัน

รอจนกว่า จะขึ้น

Starting MySQL.                                            [  OK  ]

ตอนนี้ เราจะทำการ login เข้า mysql ทันที โดยไม่ต้องใช้ password เมื่อเข้าไปได้แล้ว เราจะทำการกำหนด password ใหม่ ให้มัน

เข้า mysql ด้วยคำสั่ง

mysql -u root mysql 

จะได้

Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 1
Server version: 5.1.25-rc-community MySQL Community Server (GPL)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>
แสดงว่าเรา login เข้ามาได้แหละ ให้เราทำการเปลี่ยน password ให้ใหม่ทันที ด้วยคำสั่ง

mysql>UPDATE user SET password=PASSWORD('ตั้งพาสเวิร์ดใหม่') WHERE user='root';

แล้วก็ทำการ flush ข้อมูลซะ เพื่อให้มีผลบังคับใช้เดี่ยวนี้

mysql> flush privileges;

กด Ctrl+D เพื่อออกจาก mysql  พอออกมาแล้ว เราจะกลับไปแก้ไขที่ /etc/init.d/mysql อีกครั้ง เพื่อเอา --skip-grant-tables ออก

แต่ให้เราหยุด service mysql ก่อน ด้วยคำสั่ง

service mysql stop หรือ /etc/init.d/mysql stop ก็ได้

แล้วเข้าไปแก้ไขไฟล์ ด้วยคำสั่ง

nano /etc/init.d/mysql 

เอา --skip-grant-tables แล้วทำการบันทึก และออกจากโปรแกรม nano

จากนั้น ให้ทำการเปิด service mysql อีกครั้ง แล้ว login เข้า mysql ด้วย password ใหม่ ที่เราได้ตั้งไป (อย่าบอกว่า ลืมอีกนะ -_-" )

service mysql start 

แล้ว ก็ login เข้า mysql ด้วยคำสั่ง

mysql -u root -p
Enter Password: พาสเวิร์ดใหม่ที่ได้ตั้งไป

สังเกตว่า ถ้าเรา login ด้วย root จริง เราจะมองเห็น database ที่ชื่อ mysql ลองใช้คำสั่งแสดงฐานข้อมูล

mysql>show databases;

mysql>show databases;

วิธีการนี้ใช้ได้กับ Mysql บน Linux ตัวอื่นได้ด้วย

เครดิต http://www.thegeekstuff.com

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

Thursday, October 11

Raspberry Pi Play MP3 file

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

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

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

sudo apt-get install alsa-utils

sudo apt-get install alsa-utils

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

sudo apt-get install mpg321

sudo apt-get install mpg321

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

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

sudo modprobe snd-bcm2835

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

sudo amixer cset numid=3 1

sudo amixer cset numid=3 1 ปล. ขอบคุณรูปภาพประกอบจาก http://learn.adafruit.com

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

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

mpg321 song.mp3

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

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

Install VSFTP on Raspian for setting FTP server

     อย่างหนึ่งที่ขาดไม่ได้เลย กับการติดต่อกับ Server (เครื่องให้บริการ) ก็คือ ช่องทางในการติดต่อเรื่อง
การถ่ายโอนไฟล์ระยะไกล จากที่ผ่านมา เราได้ทำการกำหนดการติดต่อกับ Server นั่นคือบอร์ด Raspberry Pi ของเราทาง SSH แต่นั่นเป็นเพียงการขอเข้าใช้ทรัพยากรของเครื่องเท่านั้น เราไม่สามารถที่จะส่งไฟล์เข้าไป หรือรับไฟล์จากบอร์ด (ระยะทางไกล) ได้เลย หาเราไม่ได้ทำการเปิดใช้บริการ FTP หรือ File Transfer Protocol เว้นเสียแต่เราจะก๊อปปี้ไฟล์ใส่ CD หรือ Flash Drive แล้วนำไปใส่ที่เครื่องที่เรารีโมท

หลังจาก login ผ่าน SSH แล้ว ใช้คำสั่ง อย่าลืมหมั่นเช็คแพกเกจใหม่ๆ ด้วยนะครับ

sudo apt-get update

ส่วนโปรแกรมที่ใช้สำหรับเปิด service FTP นั้นก็มีหลายตัว ที่นิยมก็คือ vsftp เรามาเริ่มติดตั้งกันเลย โดยเราจะทำการโหลด VSFTP package มาใส่บอร์ด Raspberry Pi ด้วยคำสั่ง

sudo apt-get install vsftp

sudo apt-get install vsftp

เสร็จแล้ว เราต้องทำการแก้ไขไฟล์ vsftpd.conf ของมันสักหน่อย ด้วยคำสั่งต่อไปนี้

sudo nano /etc/vsftpd.conf

จะเปิดหน้าต่างโปรแกรม nano เพื่อทำการแก้ไข ค่าต่างๆ ของไฟล์ vsftpd.conf

มองหาบรรทัดที่เขียนว่า

anonymous_enable=YES ให้เปลี่ยนเป็น  anonymous_enable=NO

แล้วเอาสัญญลักษณ์ # (comment) ของบรรทัดเหล่านี้ออก
เอาคอมเม้นท์ออก  #local_enable=YES จะได้  local_enable=YES
เอาคอมเม้นท์ออก #write_enable=YES จะได้  write_enable=YES

sudo nano /etc/vsftpd.conf

แล้วเพิ่มข้อความนี้ที่บรรทัดท้ายสุดของไฟล์

force_dot_files=YES

กด Ctrl + X เพื่อขอออกจากโปรแกรม nano โปรแกรมจะถามว่าต้องการให้บันทึกการแก้ไขไฟล์ vsftpd.conf  ให้เราตอบ Y ไป

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

sudo service vsftpd restart

 

sudo service vsftpd restart

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

เมื่อติดตั้งเสร็จแล้ว เรามาทำการตั้งค่าโปรแกรม FileZilla เพื่อทำการกำหนดค่าในการเชื่อมต่อครั้งต่อๆ ไปด้วย โดยไปที่เมนู File --> Site Manager
แล้วทำการกำหนดค่าตามรูปเลยครับ

image

จากนั้นทำการกด OK เพื่อบันทึก แล้วทำการเลือก Connect อีกครั้งหนึ่ง รอสักครู่จะปรากฏหน้าต่างของ FileZilla โดยแบ่งหน้าต่างออกเป็น สองส่วนหลักๆ คือ ฝั่งที่เป็น PC ของเราที่ทำการเชื่อมต่อจะอยู่ด้านซ้ายมือ และส่วนทางขวามือเป็นของฝั่ง Raspberry pi ที่ถูกเราเชื่อมต่อผ่านทาง FTP เข้าไป

image

เพียงเท่านี้ เพื่อนๆ ก็สามารถที่จะทำการ Upload ไฟล์ (จากเครื่องเรา ไปที่เครื่องที่เรารีโมท) หรือทำการ Download ไฟล์ (จากเครื่องที่เรารีโมท กลับมาที่เครื่องของเรา) ได้อย่างง่ายดายแล้วครับ เราก็จะได้ FTP Server ย่อมๆ ไว้ใช้ในบ้างแล้วครับ ต่อไปเราคงได้นำเจ้า FTP ตัวนี้ ไปทำโปรเจคกันต่อไปครับ สวัสดีครับ

ปล.ขอบคุณรูปภาพประกอบบางส่วนจาก http://www.instructables.com

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

Tuesday, October 9

RPi.GPIO Python control GPIO of Raspberry Pi

     จากในตอนก่อนหน้านี้ เราสามารถที่จะควบคุม GPIO pin ของ Raspberry Pi ด้วย Shell ของ Linux ด้วยการเข้าไปอ่านและเขียนที่ sysfs ซึ่งสามารถมอง GPIO pin ของ Raspberry Pi เป็นเสมือนไฟล์ๆ หนึ่ง ที่เมื่อเราอ่าน และเขียนลงไปแล้ว ก็สามารถที่จะควบคุม GPIO ได้เช่นกัน ซึ่งวิธีนั้น เราก็แค่ทำการเขียน shell script ก็สามารถที่จะสร้างโปรแกรมควบคุม GPIO ได้แล้ว แต่ยังมีวิธีอื่นๆ อีกมากมายที่จะควบคุม GPIO ของ Raspberry Pi อีกวิธีหนึ่งก็คือ การใช้ Library ที่พัฒนามาจากภาษาต่างๆ  ซึ่งภาษาไพธอน เป็นอีกภาษาหนึ่งที่เป็นมิตรกับ Linux และได้มีการพัฒนา library ให้สามารถควบคุม GPIO ได้ โดยใช้ RPi.GPIO
เดิมที Debian Wheezy ที่ติดตั้งมานั้น จะมี Python 2.7.3 ติดมาด้วยอยู่แล้ว เพราะฉะนั้น เราก็แค่ ลง RPi.GPIO เพิ่มเข้าไป ก็สามารถที่จะเรียกใช้ไลบรารี่ชุดนี้ได้แล้ว
หลังจากที่ login ผ่าน SSH แล้ว ทำการโหลดไลบรารี่ชุดนี้ ซึ่งจะถูกบีบอัดไว้ ใน linux นั้น ไฟล์ที่ถูกบีบอัดจะมีนามสกุล .gz 
ดาวน์โหลดไฟล์ จากเว็บ http://pypi.python.org/pypi/RPi.GPIO โดยเราจะเข้าไปเอาลิ้งค์จากหน้าเว็บดังกล่าว
PRi.GPIO link
ใช้คำสั่งดาวน์โหลดไฟล์จากลิ้งค์ดังกล่าว
wget http://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.4.1a.tar.gz#md5=9acdb66290350aaa74b99de859ded153
wget RPi
จะได้ไฟล์ RPi.GPIO-0.4.1a.tar.gz  (ณ ตอนนี้ เวอร์ชั่น 0.4.1a)
ทำการแตกไฟล์ ด้วยคำสั่ง
tar zxvf RPi.GPIO-0.4.1a.tar.gz
เราจะได้โฟวเดอร์ RPi.GPIO-0.4.1a ทำการเข้าไปที่โฟวเดอร์นี้
cd RPi.GPIO-0.4.1a
แล้วทำการติดตั้ง ด้วยคำสั่ง
sudo python setup.py install
คำสั่ง setup.py จะทำการนำไฟล์ไปไว้ตาม path ของ package python ถ้าไม่มีอะไรผิดพลาด เราจะสามารถ import package ที่เราติดตั้งเข้าไปในโค๊ดของเราได้
เราจะทำการสร้างโค๊ด เพื่อทดสอบ RPi.GPIO ไลบรารี่ นี้
ทำการเขียนโด๊ดง่ายๆ ด้วย คำสั่งสร้างไฟล์
nano blink.py
เขียนโค๊ดตามที่ปรากฏข้างล่างนี้
simple code python control GPIO
หมายเหตุ : จากตอนที่แล้ว เราได้ทำการสั่งควบคุม GPIO7 ด้วย shell script แต่ในไลบรารี RPi.GPIO นั้น ได้ทำการ map pin ที่ไม่เหมือนเดิม เราจะต้องอ้างอิงตามไลบรารี่ ตาม RPi.GPIO ตามนี้
RPi.GPIO map pin
เมื่อเราต่อเข้ากับ GPIO7 จะตรงกับ map pin ที่ 26 ของ RPi.GPIO ซึ่งเมื่อพิจารณที่บอร์ดของ Raspberry Pi แล้ว จะตรงกับ PIN_26 เช่นกัน
ทำการเปลี่ยนโหมด เพื่อทำให้ไฟล์นี้สามารถที่จะ Execute ได้ ด้วยคำสั่ง
chmod +x blink.py
เราจะได้ไฟล์ที่สามารถ Execute ได้ (เหมือนกับไฟล์ exe ของ windows) 
เนื่องจากไฟล์นี้มีการเข้าถึงบางส่วนของ Hardware เพราะฉะนั้นจะต้องรันด้วยคำสั่ง sudo นำหน้าไฟล์ที่จะรัน
sudo ./blink.py 
จะเห็นไฟ LED กระพริบติด-ดับ สลับกัน โดยหน่วงเวลาครึ่งวินาที (  time.sleep(.5)  )  10 ครั้ง แล้วโปรแกรม ก็หยุดทำงาน
Raspberry Pi schematic
เท่านี้ เราก็สามารถที่จะควบคุม GPIO ของ Raspberry Pi ได้แล้ว ทีเหลือก็ขึ้นอยู่กับ Python Programming แล้วหล่ะ
อ่านเพิ่มเติม...
 

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

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

ติดตาม Blog นี้

About Me

My photo

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

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

Microcontroller Electronics update

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