มาทำการ์ดอวยพรปีใหม่กันเถอะ

มาทำการ์ดอวยพรปีใหม่กันเถอะ

         ช่วงนี้เป็นช่วงส่งท้ายปีเก่าต้อนรับปีใหม่ ซึ่งหลายคนคงมองการ์ดอวยพรปีใหม่ให้คนสำคัญ วันนี้ก็เลยมีไอเดียทำการ์ดอวยพรปีใหม่มาฝากกันครับ คร่าวๆ ก็จะเป็นการ์ดอวยพรปีใหม่ที่มีเสียงเพลงอวยพรปีใหม่เมื่อผู้รับทำการหยิบการ์ดอวยพรขึ้นมา (อาจจะมีไฟกระพริบด้วยก็ได้นะครับ)
        โดยจะใช้เทคนิคของ Capacitive Touch ในการเล่นไฟล์เสียง โดยจะทำงานเมื่อมีการสัมผัสโดนการ์ดอวยพรที่ติดตั้ง Arduino ที่สามารถเล่นไฟล์เสียงได้ ซึ่ง Arduino Pro Mini จะเล่นไฟล์ .wav ที่บันทึกไว้ใน SD Card ซึ่งไฟล์ .wav นี้จะเก็บข้อมูลที่เป็น Digital โดยมีชื่อว่า Pulse-Coded Modulation (PCM) หลายคนคงเคยคุ้นหูหรืออาจจะเคยรู้จักกับไฟล์ประเภทนี้มาบ้างแล้ว และเจ้า Arduino สามารถแปลง ข้อมูลที่เป็น Digital กลับไปเป็นสัญญาณ Analog (Digital to Analog Converter) หรือเรียกสั้นๆว่า DAC และส่งกลับไปยังลำโพงกลายเป็นเสียงได้ โดยใน Arduino Pro Mini มีวงจรประเภทนี้อยู่แล้วด้วย โดยมีชื่อว่า Pulse Width Modulation (PWM) แต่ด้วยข้อจำกัดที่ว่า Arduino Pro Mini เป็น MCU 8 bit และมีสัญญาณนาฬิกาแค่ 16 MHz จึงทำให้เล่นไฟล์เสียงที่มีคุณภาพแค่ 8 bit Mono ที่ sample rate ไม่เกิน 22 KHz
เท่านั้น

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

                 1. Arduino Pro Mini ATMega328

                 2. การ์ดอวยพร

                 3. สายไฟเชื่อมต่อวงจร

                 4.คลิปหนีบกระดาษ
                 5. Resistor    1 ~ 10 Mega ohm   1    ตัว (ค่ายิ่งเยอะขอบเขตของช่วงข้อมูลยิ่งกว้าง)

                 6. แบตเตอรี่  AAA 1.5V 2 ก้อน ( 3.0 V Arduino สามารถทำงานได้ )

                 7. ลำโพงขนาดเล็ก

                 8. SD Card Module for Arduino

                 9. SD Card Class 4 ฟอร์แมตแบบ Fat32 และใส่ไฟล์เสียง .wav @sample rate 22 KHz 8 bit Mono (เป็นเพลงหรือข้อความเสียงก็ตามแต่แนวความคิดของแต่ละคนเลยครับ)

          (แต่ถ้าใคร อยากให้ถูกต้องตามหลักจริงๆ รายการอุปกรณ์จะเยอะกว่านี้มาก ดูตามในเว็บอ้างอิงเลยครับ และแหล่งจ่ายไฟอาจจะใช้เป็นถ่าน 9V แล้วใช้ Regulator แปลงให้เป็น 5V กับ 3.3V หรือจะใช้ Arduino UNO แทนก็ได้นะครับเพราะมีวงจรแปลงไฟให้ในตัวแล้ว)

          จากนั้นก็ต่อวงจรตามรูปด้านล่างได้เลยครับ (วิธี upload program ดูจากบทความที่ผ่านมานะครับ)

         หลังจากนั้นก็ใส่โค๊ดให้กับ Arduino Pro Mini ของเรากัน ด้วยโค๊ดด้านล่าง

#include <SD.h>
#include <TMRpcm.h>
#include <CapacitiveSensor.h>

TMRpcm tmrpcm;

CapacitiveSensor cs_7_4 = CapacitiveSensor(7, 4);

int errLED = 3;
int chipSelect = 10;
long capVal = 0;

void setup() {
  Serial.begin(9600);
  pinMode(chipSelect, OUTPUT);
  pinMode(errLED, OUTPUT);
  if (!SD.begin(chipSelect, SPI_QUARTER_SPEED)) {
    // if SD Card error Red Led is on
    digitalWrite(errLED, HIGH);
    return;
  }
  // set speaker pin to pin 9
  tmrpcm.speakerPin = 9;
}

void loop(void) {
  // connect pin 7 and pin 4 for capacitive sensor
  capVal = cs_7_4.capacitiveSensor(10);
  if(!tmrpcm.isPlaying() && capVal > 100) {
    tmrpcm.stopPlayback();
    // your wave file name
    tmrpcm.play("/newyear.wav"); 
  }
}

         เมื่อจ่ายไฟให้กับ Arduino Pro Mini เรียบร้อยแล้วก็พร้อมที่จะเล่นเพลงได้แล้วครับ
ดังวีดีโอด้านล่าง

         ปีใหม่นี้ ก็ขอให้ท่านผู้อ่านลองคิดไอเดียร์ทำการ์ดอวยพรกันดูนะครับ อาจจะเป็นวาระอื่นๆ เช่น
วาเลนไทน์ วันเกิด หรืออาจจะทำเป็นวงจรเสียงอื่นๆ ก็ตามแต่จะประยุกต์ใช้กันนะครับ แต่คุณภาพเสียงว่ากันว่าเสียงดีกว่าวิทยุ AM นะครับ และถ้าหากใครมีโปรเจคที่น่าสนใจก็สามารถแชร์ความรู้กันทาง gtalk หรือทางเมลล์ได้นะครับ olekhanchai@gmail.com หรือสนใจอุปกรณ์สามารถเข้าสั่งซื้อได้ในเว็บ http://www.hobbyembshop.biz หรือที่ https://www.facebook.com/hobbyembedded  

          ขอให้มีความสุขในวันปีใหม่นะครับ เวอร์ชันนี้ยังมีปัญหาเรื่องค่าที่อ่านได้จาก Capacitive Sensor ยังไม่เสถียร ค่าค่อนข้างแกว่งมาก สื่อนำต่างกันค่าจะต่างกัน ต้องลองใช้สาย USB to Serial ดูค่าการเปลี่ยนแปลงและลองปรับค่า capacitiveSensor(samples rate)  และค่าเช็ค capVal กันดูนะครับ ไว้คราวหน้าจะปรับปรุงโค๊ดให้ดีขึ้น หรือถ้าใครมีวิธีแก้ไขปัญหาดังกล่าวก็แชร์กันได้นะครับ เจอกันปีหน้า สุขสันต์วันปีใหม่ครับ...
      

อ้างอิง   

http://playground.arduino.cc//Main/CapacitiveSensor?from=Main.CapSense

http://apcmag.com/arduino-project-5-digital-audio-player.htm

จับ Raspberry Pi มาเป็น PlayStation

        หลังจากที่นั่งดู Youtube เพลินๆ หันไปเจอที่โชว์ Emulator ของเครื่อง Playstation เห็นการ Render ภาพถือว่าลื่นไหลดีมาก ก็เลยอยากจะลองทำเล่นเองที่บ้านเองบ้าง  เนื่องจากสถาปัตยกรรมของ Raspberry Pi นั้นเป็น ARM และ PlayStation เป็น MIPS สองสถาปัตยกรรมนี้มีความแตกต่างกัน จึงต้องมีการทำเป็น Emulator ของ PS1 บน Rpi ซึ่งแน่นอนว่าความลื่นไหลสู้ PS1 ตัวจริงไม่ได้แน่นอน  แต่ถือว่าประสิทธิภาพการทำงานของ Emulator ตัวที่นำมาเสนอในวันนี้ถือว่าดีที่สุดแล้วซึ่ง Emulator
ตัวนั้นมีชื่อว่า PCSX_ReARMed และก่อนที่จะทำการติดตั้งเจ้า PCSX เรามาเตรียมอุปกรณ์ต่างๆ ให้ครบก่อนดังนี้ครับ

        1. ชุดเซ็ตของ Raspberry Pi 

     

        2. USB Joy Stick รุ่นไดก็ได้

        จากนั้นมาเริ่มทำการลงโปรแกรมกันเลย การลงโปรแกรมของ Raspbian ถือว่าทุกคนลงเป็นแล้วจะไม่ขอกล่าวถึงในบทความนี้นะครับ (สามารถกลับไปดูได้ในบทความของเดือน มกรา 2013)
        เมื่อทำการติดตั้ง Raspbian สามารถเชื่อมต่อกับ Network ได้แล้วเราจะทำการ clone project ของ PCSX_ReARMed ลงมาไว้ที่ home folder (~ default folder เมื่อเข้าสู่ Terminal) โดยใช้คำสั่ง 

        sudo git clone https://github.com/notaz/pcsx_rearmed

        ถ้าหากว่า clone project ได้สำเร็จจะเห็นข้อความดังรูปภาพที่แสดงด้านล่าง

        จากนั้นเข้าไปใน Folder ของ pcsx_rearmed โดยใช้คำสั่ง

        cd pcsx_rearmed

        ดังแสดงในรูปด้านล่าง

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

        sudo git submodule init && sudo git submodule update

        ถ้าหากทำการ Update ได้สมบูรณ์จะแสดงข้อความตามรูปด้านล่าง

       หลังจากนั้นเราจะทำการติดตั้ง Library ของ png และ sdl  ซึ่ง pcsx จำเป็นต้องใช้ในการ compile โดยใช้คำสั่งดังนี้

       sudo apt-get -y install libpng-dev libsdl1.2-dev

       หากทำการติดตั้ง Library ของทั้งสองอันเสร็จเรียบร้อยแล้วจะปรากฏข้อความตามรูปด้านล่าง

      จากนั้นทำการ config ค่า Environment ของโปรแกรมก่อนทำการ make โดยใช้คำสั่ง

       sudo ./configure 

       เมื่อ configure ค่า Environment เสร็จเรียบร้อยแล้วจะแสดงข้อความตามภาพด้านล่าง

        หลังจากนั้นก็ใช้คำสั่ง sudo make เพื่อทำการ compile โปรแกรมตามรูปด้านล่าง

        หากขั้นตอนทุกอย่างเสร็จเรียบร้อยก็จะได้ไฟล์ชื่อ pcsx ตามรูปด้านล่างครับ

        ก่อนที่จะทำการรันโปรแกรมจริงจำเป็นต้องมี bios ของ PS1 ให้กับ emu ของเราก่อน โดย download จาก http://www.4shared.com/zip/w4HkES5-ba/pcsx_rearmed_bios.html  แยกไฟล์ลงใน folder bios ของ flash drive ในที่นี้จะใช้วิธี copy ผ่าน flash drive ไปยัง raspberry pi โดยใช้คำสั่ง

        sudo cp -R /media/2A41-309B/bios/ ~/pcsx_rearmed/bios/

        (2A41-309B เป็นชื่อของ Flash Drive แต่ละเครื่องจะแตกต่างกัน หรือจะใช้วิธีการ copy ผ่านทางหน้าจอ File Manager ของ raspberry pi ก็ได้นะครับ)

        ท้ายสุดเรามาทำการลง Driver ของ Joy Stick กันก่อน เพื่อจะได้สัมผัสกับอารมณ์ของการเล่นเกม PS1 โดยการใช้คำสั่ง
 
        sudo apt-get install -y joystick

        เมื่อเสร็จขั้นตอนทุกอย่างแล้วเรามาทดสอบรันโปรแกรม pcsx ซึ่งในที่นี้ผมจะใช้เกม final fantasy 7 (copy ไฟล์แบบเดียวกับ bios แต่วางไว้ที่ home folder) มาลองให้ชมกัน ขั้นแรกเข้าโปรแกรมโดยการใช้คำสั่ง

      ./pcsx

       หากเข้าไปในโปรแกรมแล้วสามารถเปลี่ยนแปลงค่า config ได้จากตัว pcsx เองโดยจะสามารถเปลี่ยนอุปกรณ์ควบคุมให้เป็น JoyStick แทนได้ ตัวอย่างเกม final fantasy เมื่อทำการรันโปรแกรม pcsx
จะเป็นแสดงดัง video ด้านล่าง

      ลองทำเล่นดูนะครับ ภาพเต็มจอถือว่าพอรับได้ ในระดับของ PS1 หากว่าใครมี Emulator ของ PS2 ที่ใช้กับ RPI ที่ประสิทธิภาพใกล้เคียงกับ Emulator ตัวนี้ก็อย่าลืมแชร์กันบ้างนะครับ ถ้ามีปัญหาอะไรก็สามารถสอบถามผมได้ทาง olekhanchai@gmail.com หรือสนใจอุปกรณ์ต่างๆ สามารถเข้าไปเยี่ยมชมได้ที่ http://www.hobbyembshop.biz หรือทาง facebook ที่ https://www.faceboo.com/hobbyembedded

      สุดท้ายนี้ก็ขอให้สนุกกับการเล่นเกม PS1 นะครับ ไว้เจอกันโอกาสหน้าครับ

มาทำ Home Automation กันเถอะ

        หลังจากห่างหายไปเป็นเวลาสามเดือน ก็ขอสวัสดีปีใหม่ไทยท่านผู้อ่านทุกๆ ท่านในช่วงสงกรานต์และขอกลับมาเขียนบล็อกให้ทุกท่านได้อ่านกันอีกครั้งนะครับ จากในหัวข้อที่กล่าวไว้ข้างต้นว่า
Home Automation คือการควบคุมอุปกรณ์ภายในบ้าน วันนี้ขอหยิบยกการทำอุปกรณ์ควบคุมภายในบ้านโดยใช้ Raspberry Pi และ Arduino มาให้ลองทำที่บ้านเล่นๆ กันนะครับ แต่ขอเตือนว่าโปรเจคนี้ค่อนข้างจะอันตราย หากไม่มีความรู้ด้านไฟฟ้าควรหาที่ปรึกษาด้านไฟฟ้าไว้นะครับ เพราะว่าโปรเจคนี้เล่นกับไฟฟ้าในบ้านที่มีแรงดัน 220 V หากไม่ระมัดระวังอาจเกิดอันตรายถึงชีวิตได้ โดยหากเกิดอะไรขึ้น ทางผู้เขียนจะไม่รับผิดชอบใดๆ เพราะถือว่าได้เตือนแล้ว  อาจจะฟังดูน่ากลัวไปหน่อย แต่คิดว่าคนที่สามารถทำวงจรนี้ได้คงมีความรู้ด้านไฟฟ้าอิเล็กทรอนิกส์พอตัวเหมือนกัน    เรามาเริ่มเตรียมอุปกรณ์กันเลยนะครับ รายการอุปกรณ์ที่จำเป็นจะต้องใช้ตามรายการด้านล่างเลยครับ

1.  Raspberry Pi Model B 512 MB	1	ตัว
2.  SD Card  4 GB ขึ้นไป	1	ตัว
3.  Arduino Pro Mini 16 MHz 5v	2	ตัว
4.  เต้าเสียบไฟฟ้าตัวเมีย	1	ตัว
5.  หม้อแปลง 5V 2A	1	ตัว
6.  Wireless RF Transmitter & Receiver 433 MHz	1	ชุด
7.  Optoisolator TLP560J	1	ตัว
8.  เสาอากาศ	2	อัน
9.  LED สีแดง	1	ตัว
10.  LED สีเขียว	1	ตัว
11.  PCB อเนกประสงค์	1	แผ่น
12.  Resistor 1.6 K Ohm	1	ตัว
13.  Resistor 3.3 K Ohm	1	ตัว

        เมื่อได้อุปกรณ์ครบทั้งหมดตามรายการเรียบร้อยแล้ว ขั้นตอนต่อไป เราจะแยกรายการอุปกรณ์
ดังกล่าวออกเป็นสองส่วนซึ่งรายละเอียดจะแยกอธิบายเป็นส่วนๆ ดังนี้ครับ

Wireless Plug

 

        ส่วนของ Wireless Plug จะเป็นส่วนของเต้าเสียบไฟฟ้าที่ใช้ Arduino Pro Mini ในการเปิดปิดเต้าเสียบเพื่อจ่ายไฟหรือหยุดการจ่ายไฟให้กับอุปกรณ์ที่เสียบกับเต้าเสียบนัันๆ โดยจะมี Opto เป็นตัวเปิดปิดแรงดันไฟฟ้าจากปลั๊กไฟไปยังเต้าเสียบไฟฟ้า ซึ่งจะควบคุมโดย Arduino Pro Mini ผ่านทาง
ขาที่ 7 อีกที โดยมีการรับคำสั่งจาก RF Receiver และมี LED แสดงสถานะการจ่ายไฟให้กับเต้าเสียบไฟฟ้า  ซึ่งการทำงานที่อธิบายข้างต้นสามารถต่อวงจรได้ตามรูปด้านล่างครับ

        หลังจากประกอบวงจรเสร็จเรียบร้อยแล้ว จำเป็นจะต้องมีการเขียนโปรแกรมให้กับ Arduino Pro Mini เพื่อที่จะให้วงจรสามารถสื่อสารกับ Wireless Server ได้ โดยโปรแกรมดังกล่าว จะขอหยิบยกเอาบทความของเดือน ตุลาคม 2013 มาดัดแปลง โดยโค๊ดดังกล่าวจะทำงานตามหลักการข้างต้น ส่วนการ Upload Program สามารถดูได้จากบทความของเดือน พฤศจิกายน 2013 ได้นะครับ ซึ่งรายละเอียดของโค๊ดตามข้อความข้างล่างเลยครับ

#define NETWORK_SIG_SIZE    3
#define VAL_SIZE                         2
#define CHECKSUM_SIZE          1
#define PACKET_SIZE      (NETWORK_SIG_SIZE + VAL_SIZE + CHECKSUM_SIZE)

#define NET_ADDR 5

const byte g_network_sig[NETWORK_SIG_SIZE] = {0x8F, 0xAA, NET_ADDR};  // Few bytes used to initiate a transfer
char c;
#define LED_ON        5
#define LED_OFF      6 
#define LELAY_ON   7
void setup()
{
  pinMode(LED_ON, OUTPUT);
  pinMode(LED_OFF, OUTPUT);
  pinMode(LELAY_ON, OUTPUT);
  digitalWrite(LED_ON, LOW);
  digitalWrite(LED_OFF, HIGH);
  digitalWrite(LELAY_ON, LOW);
  Serial.begin(1200);
}

void loop()
{
  Serial.write(readUInt(true));
}

void plugOn()
{
  digitalWrite(LED_ON, HIGH);
  digitalWrite(LELAY_ON, HIGH);
  digitalWrite(LED_OFF, LOW);
}

void plugOff()
{
  digitalWrite(LED_ON, LOW);
  digitalWrite(LELAY_ON, LOW);
  digitalWrite(LED_OFF, HIGH);
}

unsigned int readUInt(bool wait)
{
  int pos = 0;          // Position in the network signature
  unsigned int val;     // Value of the unsigned int
  byte c = 0;           // Current byte

  if((Serial.available() < PACKET_SIZE) && (wait == false))
  {
    return 0xFFFF;
  }

  while(pos < NETWORK_SIG_SIZE)
  {
    while(Serial.available() == 0); // Wait until something is avalible
    c = Serial.read();

    if (c == g_network_sig[pos])
    {
      if (pos == NETWORK_SIG_SIZE-1)
      {
        byte checksum;

        while(Serial.available() < VAL_SIZE + CHECKSUM_SIZE); // Wait until something is avalible
        val      =  Serial.read();
        val      += ((unsigned int)Serial.read())*256;
        checksum =  Serial.read();
      
        if (checksum != ((val/256) ^ (val&0xFF)))
        {
          // Checksum failed
          pos = -1;
        }
      }
      ++pos;
    }
    else if (c == g_network_sig[0])
    {
      pos = 1;
    }
    else
    {
      pos = 0;
      if (!wait)
      {
        return 0xFFFF;
      }
    }
  }
  return val;
}

        เท่านี้เราก็ได้ Wireless Plug ที่พร้อมใช้งานได้แล้วครับ หากนำวงจรข้างต้นมาประกอบลงเต้าเสียบไฟฟ้า จะได้หน้าตาของ Wireless Plug ประมาณนี้ครับ

 

Wireless RPI Server

 

        ส่วนของ Wireless RPI Server นี้จะเป็นศูนย์สั่งการให้กับเต้าเสียบต่างๆ ที่เชื่อมต่อกับ Server ด้วย Wireless RF Module โดยจะทำหน้าที่ในการรับคำสั่งผ่านเว็บ Interface ซึ่งอาจจะใช้ Android, IPhone หรือ Notebook ในการเข้าหน้าเว็บดังกล่าวเพื่อควบคุมก็แล้วแต่ความสะดวกของแต่ละท่านนะครับ
ส่วนของ Server นี้จะมีความซับซ้อนในการติดตั้งนิดนึง โดยสามารถทำตามขั้นตอนต่อไปนี้ได้เลยครับ

        Raspbian Setup

        ขั้นตอนการติดตั้ง Raspbian ขอละไว้ในฐานที่เข้าใจนะครับ ซึ่งสามารถกลับไปดูบทความแรกของ
ปี 2013 ในการติดตั้งได้ หน้าตาของการติดตั้งอาจจะเปลี่ยนแปลงไปตามการอัพเดทของแต่ละเวอร์ชันของ Raspbian แต่ขั้นตอนยังเหมือนเดิมครับ

        LAMP Setup 

        ขั้นตอนการติดตั้ง LAMP ก็ขอละไว้ในฐานที่เข้าใจด้วยเช่นกัน ซึ่งสามารถย้อนกลับไปดูบทความของเดือนมิถุนายนของปี 2013 ได้ครับ

        Serial Port (UART) Setup 

        Raspberry Pi จะทำการส่งข้อมูลการแสดงผลออกทาง Serial Port ตั้งแต่เริ่มทำงาน ด้วย getty
ดังนั้นหากเราจะใช้งาน Serial Port ดังกล่าว เราจะต้องทำการตัดการทำงานของ getty ทิ้งไป โดยทำตามขั้นตอนดังนี้

        1. ทำการแก้ไขไฟล์ /etc/inittab โดยให้ค้นหาข้อความดังนี้

                T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

        และใส่ comment ให้กับบรรทัดดังกล่าว เพื่อปิดการทำงานของ getty ดังนี้

                #T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

        2. แก้ไขไฟล์ /boot/cmdline.txt โดยหาข้อความดังนี้

                console=ttyAMA0, 115200 kgdboc=ttyAMA0, 115200 

        จากนั้นให้ลบข้อความข้างต้นทิ้งไป เพื่อไม่ให้ Raspberry Pi ส่งการแสดงผลออกทาง Serial Port

        3. ติดตั้ง Py-Serial ให้กับ Raspbian ซึ่งเป็น Library ของ Python ที่ใช้ติดต่อ Port Serial  นั่นเอง โดยใช้คำสั่งดังนี้

                sudo apt-get install python-serial

        4. เปิดให้ Browser สามารถเข้าใช้งานใช้งาน Serial Port โดยการเปิดสิทธิ์การเข้าถึงของ Serial ไว้ที่ Startup เพื่อให้มีการกำหนดสิทธิ์ทุกครั้งเมื่อมีการบูทระบบใหม่ ซึ่งจะต้องสร้างไฟล์ชื่อ freeAMA0 ไว้ที่ /etc/init.d/ โดยมีเนื้อหาดังนี้

                sudo chmod 777 /dev/ttyAMA0

        ซึ่งเมื่อสร้างไฟล์ freeAMA0 ที่มีเนื้อหาข้างบนเสร็จเรียบร้อยแล้ว ให้สั่งคำสั่ง

                sudo update-rc.d freeAMA0 defaults

        เพื่อสั่งให้ freeAMA0 ทำการกำหนดสิทธิ์การเข้าถึงอัตโนมัติเมื่อมีการบูท Raspberry ทุกครั้ง

        เมื่อเสร็จขั้นตอนข้างต้นเรียบร้อยแล้ว ก็ถือว่าในส่วนของการเตรียม Serial Port ของ Raspberry Pi เสร็จสมบูรณ์

        ก่อนที่จะทำการต่อวงจรให้ Arduino Pro Mini กับ Raspberry Pi เพื่อให้สื่อสารกันนั้น ก็มาทำการเขียนโปรแกรมให้กับ Arduino Pro Mini ฝั่ง Transmitter และ Upload Program ให้กับ Arduino Pro Mini กันก่อน โดยปรแกรมจะเขียนตามโค๊ดด้านล่างเลยครับ

#include <SoftwareSerial.h>
#define NET_ADDR                   5
#define NETWORK_SIG_SIZE 3
#define VAL_SIZE                      2

SoftwareSerial swSerial(9, 10);
const byte g_network_sig[NETWORK_SIG_SIZE] = {0x8F, 0xAA, NET_ADDR};
// Few bytes used to initiate a transfer
int i = 0;
boolean turnon = false;

void setup()
{
  swSerial.begin(9600);
  Serial.begin(1200);
}

void loop()
{
  if (swSerial.available())
  {
    char buf = swSerial.read();
    if (buf == 48) {       // check for number 0
      turnon = false;
    }
    if (buf == 49) {      // check for number 1
      turnon = true;
    }
  }
  if (turnon)
  {
    writeUInt('1');
  }
  else
  {
    writeUInt('0');
  }
}

void writeUInt(unsigned int val)
{
  byte checksum = (val/256) ^ (val&0xFF);
  Serial.write(0xF0);  // This gets reciever in sync with transmitter
  Serial.write(g_network_sig, NETWORK_SIG_SIZE);
  Serial.write((byte*)&val, VAL_SIZE);
  Serial.write(checksum); //CHECKSUM_SIZE
}

        หลังจากนั้นเราก็จะมาเตรียมการในส่วนของวงจรฝั่ง Wireless RPI Server ที่สื่อสารกันระหว่าง Raspberry Pi กับ Arduino กันบ้าง  โดยต่อวงจรตามรูปเลยครับ

   

        ในส่วนของ Serial Port นั้นจะใช้ส่วนของ GPIO ขาที่ 8 และ ขาที่ 10  ในการสื่อสารระหว่าง Raspberry Pi และ Arduino Pro Mini  ขา 9 และ ขา 10 ซึ่งในที่นี้คือ Software Serial โดย Port Serial จริงของ Arduino นั้นจะใช้ในการสื่อสารกับ Wireless Module จึงต้องสื่อสารกับ Raspberry Pi โดยใช้ Port Serial เสมือนในการติดต่อสื่อสาร (ซึ่งก็คือ Software Serial นั่นเอง) และเนื่องจาก Raspberry Pi วงจรสื่อสารภายในเป็น 3.3 V ส่วน Arduino Pro Mini นั้นจะเป็น 5 V เพื่อป้องกันความเสียหายในการติดต่อสื่อสารระหว่างทั้งสองบอร์ดจึงต้องมี Resistor สองตัวที่ต่อวงจรเป็น Voltage Divider เพื่อที่จะทำการลดแรงดันจาก Arduino Pro Mini ให้กับ Raspberry Pi ไว้ด้วย

        จากวงจรข้างต้นเราสามารถนำมาประกอบเป็นวงจร Wireless RPI Server โดยติดตั้ง Raspberry Pi กับ RF Module Socket ได้ตามรูปด้านล่างครับ

 

        Control Web Page

 

        มาถึงขั้นตอนสุดท้ายซึ่งจะเป็นหน้าเว็บที่ใช้ติดต่อกันระหว่างผู้ใช้งานและ Server โดยจะเป็นการสั่งให้ Serial Port ทำการเปิดหรือปิด Wireless Plug ที่ปลายทาง ซึ่งหน้าเว็บดังกล่าวสามารถเขียนเป็นไฟล์แยกกันได้ดังนี้

สร้างไฟล์  index.php โดยมีเนื้อหาดังนี้

        ก่อนที่จะทำการสร้างไฟล์ index ให้ดาวน์โหลด JQuery มาลงไว้ที่ /var/www เสียก่อน โดยสามารถดาวน์โหลดได้จาก http://code.jquery.com/jquery-2.1.0.min.js จากนั้นค่อนสร้างไฟล์ index.php ไว้ที่ folder เดียวกัน ซึ่งมีเนื้อหาไฟล์ดังนี้

<html>
<head>
<title> Enable / Disable Wireless Plug Demo </title>
<script src="jquery-2.1.0.min.js"></script>
<script type="text/javascript">
function onPlug(){
        $.ajax("on.php");
}
function offPlug(){
        $.ajax("off.php");
}
</script>
</head>
<body>
        <button onclick="onPlug();"> ON </button>
        <button onclick="offPlug();"> OFF </button>
</body>
</html>

สร้างไฟล์ on.php ที่มีเนื้อตามข้อความด้านล่าง

<?
echo exec("python serialTest.py 1 2>&1");
?>

สร้างไฟล์ off.php ที่มีเนื้อตามข้อความด้านล่าง

<?
echo exec("python serialTest.py 0 2>&1");
?>

และสุดท้ายสร้างไฟล์ serialTest.py ซึ่งเป็นไฟล์ส่งข้อมูลการปิดเปิดของ Wireless Plug
โดยมีเนื้อหาดังนี้

import serial
import sys

ser = serial.Serial('/dev/ttyAMA0', 9600, timeout=1)
ser.open()

print("'" + sys.argv[1] + "'")
ser.write("'" + sys.argv[1] + "'")

จากนั้นสามารถลองทดสอบโปรแกรมได้เลย โดยใช้ Web Browser เข้าไปที่หน้า index.php ซึ่งในที่นี้จะใช้มือถือ Android ในการทดสอบ  โดยหน้าตาเว็บใน Android จะเป็นหน้าตาประมาณนี้ครับ

เราลองมาทดสอบการใช้งาน Home Automation ของเรากันครับ

         สุดท้ายนี้ก็หวังเป็นอย่างยิ่งว่า บทความนี้จะเป็นจุดประกายให้กับหลายๆ คนที่กำลังคิดจะทำ Home Automation เองในบ้าน ซึ่งอาจจะสร้าง Wireless Plug ขึ้นมาเพิ่มอีกหลายๆ ตัวก็ย่อมทำได้ โดยเปลี่ยนแปลงโค๊ดนิดหน่อย หรือจะเปลี่ยนการสื่อสารจาก RF ให้เป็น Wireless Module อื่นๆ เช่น XBee, Wifi Module หรือ Bluetooh หรืออุปกรณ์ไร้สายอื่นๆ ที่มีความแม่นยำมากกว่านี้ หรือเก็บสถานะ
Wireless Plug ไว้เพื่อแสดงสถานะบนหน้าเว็บว่ากำลังอยู่ในสถานะว่ากำลังเปิดหรือปิดอยู่ ก็สามารถทำได้ครับ ในตอนนี้เชื่อว่าหลายๆ คนคงเกิดไอเดียต่างๆ มากมายขึ้นมาแล้ว ถ้าหากใครมีโปรเจคที่น่าสนใจก็สามารถ แชร์ความรู้กันทาง gtalk หรือทางเมลล์ได้นะครับ olekhanchai@gmail.com หรือสนใจอุปกรณ์สามารถเข้าสั่งซื้อได้ในเว็บ http://www.hobbyembshop.biz หรือสินค้าโปรโมชั่นที่ https://www.facebook.com/hobbyembedded
        ขอให้สนุกกับการใช้งาน Wireless Plug นะครับ เจอกันคราวหน้าครับ...


อ้างอิง  http://blog.oscarliang.net/raspberry-pi-and-arduino-connected-serial-gpio/

RetroBSD บน Max32

RetroBSD บน Max32

        ถ้าจะกล่าวถึง Open-Source Electronics Board ก็คงจะมีหลายตัวเหมือนกันที่น่าเอามาลองเล่น
ลองศึกษา ก่อนที่จะปีใหม่กันจึงอยากขอแนะนำระบบปฏิบัติการและ MCU อีกหนึ่งตัวที่น่าลองเล่นอยู่ไม่น้อย ในบทความนี้จึงขอหยิบยก Board Max32 มาลองเล่นกัน ซึ่งในที่นี้ Board ดังกล่าวจะใช้  PIC32 เบอร์ PIC32MX795 มาเป็นตัวประมวลผล ถ้าเทียบราคากับประสิทธิภาพแล้ว
อาจจะสู้ Raspberry Pi ไม่ได้ แต่ผู้อ่านสามารถทำใช้เองได้โดยมีอุปกรณ์เพียงไม่กี่ชิ้นโดยสามารถดูได้จาก Schematic ที่อยู่ในเว็บซึ่งหาได้ไม่ยาก

        ปกติแล้ว MCU ตระกูล PIC โปรแกรมเมอร์ส่วนมากจะใช้ MPLAB ของ Microchip เขียนโปรแกรมแล้วทำการ Compile ให้เป็น .HEX จากนั้นก็ทำการเขียนลงในหน่วยความจำของ MCU เบอร์นั้นๆ

        ในบทความนี้ผมจะเปลี่ยนแนวลงระบบปฏิบัติการลงใน Max32 ดูบ้าง แต่อย่างไรก็ตามต้องทำการ Flash เพื่อติดตั้ง Hex File ที่เป็น Bootloader ของระบบปฏิบัติการนี้เช่นกัน โดยระบบปฏิบัติการตัวนี้
มีชื่อว่าRetroBSD ครับ

        ก่อนที่จะมาลองเล่นกันต้องเตรียมอุปกรณ์ดังต่อไปนี้ครับ

        1. (chipKIT) Max32 Board ซึ่งมีหน้าตาประมาณนี้ครับ

        2. Arduino Ethernet Shield หน้าตาก็ประมาณนี้ครับ

        3. Micro SD Card ขนาด 1 GB ขึ้นไป

        บอร์ด Max32 ถูกออกแบบมาให้สามารถใช้กับอุปกรณ์ของ Arduino ได้ ดังนั้นสามารถประกอบ Max32 เข้ากับ Ethernet Shield ของ Arduino ได้เลย ซึ่งประกอบเสร็จเรียบร้อยแล้ว จะมีหน้าตาประมาณนี้ครับ

        จากนั้นมาหาไฟเลี้ยงให้กับ Max32 กัน โดยอาจจะใช้เป็น MicroUSB ต่อพ่วงกับคอมพิวเตอร์หรือจะใช้ DC Adapter ประมาณ 5 - 15 V 500 mA ขึ้นไปก็แล้วแต่สะดวกแล้วกันนะครับ
(ในที่นี้ขอใช้เป็น MicroUSB)
       
        เมื่อได้อุปกรณ์ครบทั้งหมดเรียบร้อยแล้ว ประกอบกันเสร็จจะได้หน้าตาประมาณนี้ครับ

        คราวนี้เราจะมาทำการลงระบบปฏิบัติการให้กับ Max32 กัน โดยจะแยกออกเป็น 3 ระบบปฏิบัติการเช่นเคย ดังนี้ครับ

สำหรับระบบปฏิบัติการ Windows

        หลังจากประกอบบอร์ด Max32 กับ Ethernet Shield เรียบร้อยแล้ว ก็ใช้สาย Mini USB ต่อเข้ากับบอร์ดเพื่อเป็นไฟเลี้ยง แต่ Computer ของเรายังไม่รู้จักกับ Max32 ซึ่งถ้าหากว่าเข้าไปที่
Device Manager ก็จะแสดงรูปดังนี้ครับ

         เราจะทำการติดตั้ง Driver ให้กับ Max32 นี้โดยการโหลด Driver
จากเว็บ http://www.ftdichip.com/Drivers/VCP.htm  ในที่นี้ผู้เขียนใช้ Windows 7 (32 bit) จึงดาวน์โหลด version 2.08.28 จากนั้นให้ทำการแยกไฟล์ zip ออกมา แล้วคลิกที่ Update Driver

       จากนั้นเลือก Browse my computer for device software ตามที่แสดงในรูปครับ

        จากนั้นจะปรากฏหน้าต่างค้นหา Driver ให้คลิกที่ Browse แล้วเลือก Folder ที่แยกไฟล์ไว้ในข้างต้น

       คลิกที่ปุ่ม Next จากนั้นระบบจะทำการติดตั้ง Driver ของ FTDI ที่เหมาะสมที่สุดให้ จากนั้นคลิก Close เพื่อปิดหน้าต่าง

       จากนั้นจะขึ้นอุปกรณ์ใหม่ซึ่งเป็น USB Serial Port แทน ในเครื่องของผู้เขียนจะเป็น USB Serial Port (COM7) ดังที่แสดงในรูปครับ

         เมื่อติดต่อกับ Max32 ได้แล้ว ต่อไปเราจะทำการติดตั้ง Bootloader ให้กับ Max32 กัน เพื่อเป็นตัว Loader ให้กับระบบปฏิบัติการ RetroBSD โดยดาวน์โหลดไฟล์ตามลิงค์นี้เลยครับ

http://code.google.com/p/retrobsd/downloads/detail?name=retrobsd-max32-r511.zip

        หลังจากได้ไฟล์มาเรียบร้อยแล้วให้ทำการแยกไฟล์ลงใน Folder ที่ต้องการ ในที่นี้ขอลงไว้ที่หน้าจอ Desktop แล้วก็พักเอาไว้ก่อน

         จากนั้นเราจะมาติดตั้งโปรแกรมที่ใช้ในการ Flash Hex File ลงใน Max32 กันต่อ ซึ่งโปรแกรมนี้มีชื่อว่า Avrdude โดยสามารถดาวโหลดได้ที่ http://sourceforge.net/projects/winavr/?source=dlp
และทำการติดตั้งในเครื่องโดย double click ที่โปรแกรมที่โหลดมา แล้วทำตามขั้นตอนดังนี้เลยครับ

          1. เลือกภาษาให้กับตัวโปรแกรมแล้วก็คลิก OK
          2. จะปรากฏหน้าจอ Welcome ดังรูปด้านล่าง ให้คลิก Next เพื่อดำเนินการต่อไป

            3. จากนั้นจะแสดงหน้า License Agreement ให้คลิก I Agree เพื่อรับทราบลิขสิทธิ์

            4. เมื่อยอมรับเสร็จแล้วจะขึ้นหน้าจอเพื่อให้เลือก Location ที่จะลงโปรแกรมดังรูป

            5. ในที่นี้จะลงไว้ที่ C:\WinAVR จากนั้นคลิก Next เพื่อเข้าสู่หน้าจอเลือกส่วนประกอบโปรแกรม

            6. จากนั้นก็ทำการกดปุ่ม Install เพื่อติดตั้งโปรแกรม จากนั้นระบบจะทำการติดตั้งสำเร็จ โดยจะมีหน้าจอดังรูป จากนั้นให้กด Finish เพื่อปิดหน้าต่างการติดตั้งไป

        เมื่อทำการติดตั้งเสร็จเรียบร้อยแล้ว WinAVR จะยังไม่สามารถใช้งานกับ PIC32 ได้เลย เพราะว่าโปรแกรมได้ออกแบบมาเพื่อใช้งานกับ MCU ตระกูล AVR โดยเฉพาะ จึงต้องมีไฟล์ avrdude.conf ที่สามารถใช้งานกับ PIC32 ได้โดยทำการ Download ไฟล์ดังกล่าวได้จาก link ด้านล่าง

http://pic32-examples.googlecode.com/svn-history/r33/trunk/showroom/retro_bsd/avrdude/avrdude.conf 

        ให้บันทึกไฟล์ avrdude.conf นี้ไว้ใน C:\WinAVR\bin\avrdude.conf โดยทำการแทนที่ไฟล์เดิม

        หลังจากเสร็จขั้นตอนดังกล่าว จากนั้นจะเริ่มการ Flash Bootloader ให้กับ Max32 โดยใช้คำสั่ง avrdude ผ่าน Console มีขั้นตอนดังนี้ครับ

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

        จากนั้นใช้คำสั่ง avrdude ทำการ Flash ไฟล์ unix.hex ลงใน Max32 โดยพิมพ์คำสั่งดังนี้

        เมื่อเสร็จขั้นตอนการ Flash Bootloader จะแสดงหน้าจอดังนี้

        เมื่อเสร็จขั้นตอน Bootloader เรียบร้อยแล้ว ต่อไปจะทำการติดตั้ง File System ให้กับ Max32 กัน
ซึ่งในที่นี้อาจจะใช้ SD Card ระดับเป็น MB ก็ได้ครับ เพราะว่าไฟล์มีนิดเดียว ในที่นี้ขอใช้ 8GB
โดยทำตามขั้นตอนดังนี้เลยครับ

        เปิดโปรแกรม Win32Diskimager (วิธีการติดตั้งดูในบทความแรก) จากนั้นเลือกโฟล์เดอร์สีน้ำเงิน เพื่อทำการ Browse ไฟล์ filesys.img ดังแสดงในรูป

         จากนั้นคลิกที่ Write เพื่อทำการเขียนไฟล์ลงใน SD Card ซึ่งจะฟ้องข้อความขี้นมาดังนี้

          คลิกที่ Yes จากนั้นระบบจะทำการ format และสามารถลงได้ และเมื่อข้อความเสร็จแล้วจะมีหน้าตาแบบนี้ช่วยได้หรือเปล่า
          เมื่อเสร็จขั้นตอนดังกล่าวก็นำ SD Card ไปเสียบในช่อง Ethernet จากนั้นก็เสียบ USB เพื่อจ่ายไฟให้กับ Max32 และสื่อสารกับ Max32 ด้วย Putty โดยสามารถดาวน์โหลดที่ http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html
จากนั้นรันโปรแกรม Putty เลือกการสื่อสารผ่านทาง Serial COM7 และตั้ง Speed ที่ 11520 (buad rate) ตามรูปด้านล่างเลยครับ

         หลังจาก Connect ผ่านทาง Serial Port ระบบปฏิบัติการก็จะทำงาน โดยใส่ Login User เป็น root รหัสผ่านให้ enter ผ่านไป จากนั้นก็จะได้หน้าตาประมาณนี้ครับ

       
        เมื่อถึงขั้นตอนนี้แล้ว ก็จะสามารถใช้คำสั่งของ Linux ได้เหมือนระบบปฏิบัติการ Linux ทั่วไป
สำหรับคนที่ชอบระบบปฏิบัติการในอุปกรณ์ที่มีหน่วยความจำน้อยๆ เจ้า RetroBSD นี้ก็ถือว่าเป็นระบบปฏิบัติการที่น่าลองใช้อยู่ไม่น้อยเหมือนกัน
        ใครมีโปรเจคที่น่าสนใจก็สามารถแชร์ความรู้กันทาง gtalk หรือทางเมลล์ได้นะครับ
olekhanchai@gmail.com หรือสนใจอุปกรณ์สามารถเข้าสั่งซื้อได้ในเว็บ http://www.hobbyembshop.biz หรือสินค้าโปรโมชั่นที่ https://www.facebook.com/hobbyembedded
        สุดท้ายนี้ขอให้สนุกสนานกับการเคาท์ดาวน์ปีใหม่นะครับ สิ่งไหนที่ไม่ดีก็ขอให้ผ่านพ้นไปกับท้ายปี และขอให้มีสิ่งดีๆเข้ามาในปีใหม่นะครับ แล้วพบกันใหม่ปีหน้าครับ

อ้างอิง

http://www.ladyada.net/learn/avr/setup-win.html
http://retrobsd.org

มาทำความรู้จักกับ Arduino Pro Mini กัน

มาทำความรู้จักกับ Arduino Pro Mini กัน

        หลังจากที่เคย ศึกษา Arduino UNO R3 และ Shield ของ UNO ไปแล้ว วันนี้เราจะมารู้จักกับ Arduino กันอีกตัว ซึ่งเจ้า Arduino Pro Mini นี้ก็จะมีหลายรุ่นแยกออกมา โดยแต่ละรุ่นจะใช้ MCU
ต่างกัน ไฟเลี้ยงต่างกัน และสัญญาณนาฬิกาต่างกันด้วย ซึ่งจะมีรุ่นที่ใช้ MCU เบอร์ ATmega168
และ ATmega328, ไฟเลี้ยง 3.3V และ 5V สัญญาณนาฬิกา 16Mhz และ 8Mhz ราคาและประสิทธิภาพของแต่ละรุ่นจะขึ้นอยู่กับ องค์ประกอบที่กล่าวมาข้างต้น

        ในที่นี้เราจะมาศึกษา Arduino Pro Mini ATmega328 5V 16Mhz กัน โดยจะมีรูปร่างหน้าตาประมาณนี้ครับ

        แต่เจ้าตัว Pro Mini นี้ไม่มี USB Port ที่จะสามารถทำการ Upload โปรแกรมจาก Arduino IDE ได้โดยตรง ดังนั้นจึงต้องมีสาย TTL to USB เพื่อที่ใช้สำหรับการติดต่อกับ Board ตัวนี้กัน โดยจะมีรูปร่างหน้าตาประมาณนี้ครับ

        เจ้าสายตัวนี้จะทำหน้าที่แปลงสาย USB ให้กลายเป็นสายสัญญาณ 6 เส้น ซึ่งจะประกอบไปด้วย GND, CTS, VCC, TX, RX และ DTR  โดยขา VCC จะมีแรงดัน 5V
        ก่อนที่เราจะทำการเชื่อมต่อสายระหว่าง TTL to USB กับ Arduino Pro Mini  เราจะมารู้จักกับ
รายละเอียดต่างๆของเจ้า Arduino ตัวที่เราจะเอามาเล่นกัน ซึ่งจะมีรายละเอียดดังต่อไปนี้ครับ

Features:

• ATmega328 running at 16MHz with external resonator (0.5% tolerance)
• 0.8mm Thin PCB
• USB connection off board
• Supports auto-reset
• 5V regulator
• Max 150mA output
• Over current protected
• Weighs less than 2 grams!
• DC input 5V up to 12V
• On board Power and Status LEDs
• Analog Pins: 8
• Digital I/Os: 14

        อ้างอิงจาก https://www.sparkfun.com/products/11113

        หลังจากที่ได้ทราบรายละเอียดคร่าวๆ ของบอร์ดนี้แล้ว เราจะมาทำการเชื่อมต่อสาย TTLtoUSB กับ Arduino กัน โดยจะต้องเตรียมอุปกรณ์ดังนี้ครับ

1.  Arduino Pro Mini 328 5v 16MHz	1	ตัว
2.  สาย TTLtoUSB	1	เส้น
3.  Resistor  10K Ohm	1	ตัว
4. Capacitor  4.7uF 16V	1	ตัว

         ก่อนที่เราจะต่อวงจร เรามาทำการติดตั้ง Driver ของ TTLtoUSB กันก่อนดีกว่าครับ โดยสามารถ Download Driver ของสายได้ที่
http://support.lenovo.com/en_US/downloads/detail.page?DocID=DS034089

ซึ่งในที่นี้สายที่ผู้เขียนได้เอามาทดลองใช้ Chip ของ PL2303 ครับ
จากนั้น เราทำการต่ออุปกรณ์ในรายการตามรูปด้านล่างได้เลยครับ

          เมื่อต่อวงจรกันเสร็จเรียบร้อยแล้ว เราก็มาทดสอบโดยใช้ Arduino IDE ซึ่งผมจะไม่ขออธิบายรายละเอียดการติดตั้งนะครับ (สามารถย้อนกลับไปอ่านบทความก่อนหน้านี้ได้)
ส่วนของ Board ให้เลือกเป็น Arduino Pro or Pro Mini

         ในส่วนของ Port ให้เลือก Port Com ของสายที่ลง Driver ไว้

           หลังจากนั้นเรามาลองทดสอบ Burn Program กันโดยเลือกไฟล์ตัวอย่างโปรแกรม จาก Example => Basic => Blink โดย Pin 13 ของ Arduino Pro Mini จะต่อกับ LED อยู่แล้ว

          IDE จะแสดงหน้าจอของ Code Arduino จากนั้นก็ทำการ Upload โปรแกรมลง Arduino Pro Mini โดยตัวอย่างการ Burn Arduino Pro Mini แบบไม่มี Pin จะเป็นดังนี้

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

          หวังว่าบทความนี้คงจะเป็นแนวทางการผลิตนวัตกรรมใหม่ๆ ที่สามารถทำเองที่บ้านได้
โดยไม่ต้องใช้ความรู้ที่เชี่ยวชาญ ลองประยุกต์ใช้ดูนะครับ
          ใครมีโปรเจคที่น่าสนใจก็สามารถแชร์ความรู้กันทาง gtalk หรือทางเมลล์ได้นะครับ
olekhanchai@gmail.com หรือสนใจอุปกรณ์สามารถเข้าสั่งซื้อได้ในเว็บ http://www.hobbyembshop.biz หรือสินค้าโปรโมชั่นที่ https://www.facebook.com/hobbyembedded
ไว้เจอกันคราวหน้าครับ

สื่อสารไร้สายด้วยคลื่น RF กับ Arduino UNO

สื่อสารไร้สายด้วยคลื่น RF กับ Arduino UNO

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

1.  Arduino UNO	2	ตัว
2.  RF TRANSMITTER MODULE	1	ตัว
3.  RF RECEIVER MODULE	1	ตัว
4.  LED สี เขียว	3	หลอด
5.  สวิตช์กดติดปล่อยดับ	3	ตัว
6.  Resistor 10 K ohm	3	ตัว
7.  โพรโตบอร์ด	2	อัน
8.  สายไฟสำหรับเชื่อมต่ออุปกรณ์

 

     โมดูลการส่งสัญญาณ (RF Transmitter) 

       เตรียมอุปกรณ์เสร็จเรียบร้อยให้ประกอบวงจรตามรูปเลยครับ
 

 

      โมดูลการรับสัญญาณ (RF Receiver)

        ประกอบวงจรตามรูปด้านล่างได้เลยครับ

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

       โปรแกรมส่วนของการส่งข้อมูล (RF Transmitter)

#define NET_ADDR 5
#define NETWORK_SIG_SIZE 3

#define VAL_SIZE         2
#define BTN_A            5
#define BTN_B            6
#define BTN_C            7

#define BTN_PRESSED      LOW

const byte g_network_sig[NETWORK_SIG_SIZE] = {0x8F, 0xAA, NET_ADDR};  // Few bytes used to initiate a transfer
int i = 0;

void setup()
{
  pinMode(BTN_A, INPUT);
  pinMode(BTN_B, INPUT);
  pinMode(BTN_C, INPUT);
  Serial.begin(1200);
}

void loop()
{
  int btn_a;
  int btn_b;
  int btn_c;
 
  btn_a = digitalRead(BTN_A);
  btn_b = digitalRead(BTN_B);
  btn_c = digitalRead(BTN_C);
 
  if (btn_a == BTN_PRESSED) {
    writeUInt('A');
  }
  if (btn_b == BTN_PRESSED) {
    writeUInt('B');
  }
  if (btn_c == BTN_PRESSED) {
    writeUInt('C');
  }
  delay(50);
}

void writeUInt(unsigned int val)
{
  byte checksum = (val/256) ^ (val&0xFF);
  Serial.write(0xF0);  // This gets reciever in sync with transmitter
  Serial.write(g_network_sig, NETWORK_SIG_SIZE);
  Serial.write((byte*)&val, VAL_SIZE);
  Serial.write(checksum); //CHECKSUM_SIZE
}

       โปรแกรมส่วนของการรับข้อมูล (RF Receiver)

#define NETWORK_SIG_SIZE 3
#define VAL_SIZE         2
#define CHECKSUM_SIZE    1
#define PACKET_SIZE      (NETWORK_SIG_SIZE + VAL_SIZE + CHECKSUM_SIZE)

#define NET_ADDR 5

const byte g_network_sig[NETWORK_SIG_SIZE] = {0x8F, 0xAA, NET_ADDR};  // Few bytes used to initiate a transfer
char c;
#define LED_A    5
#define LED_B    6  
#define LED_C    7
void setup()
{
  pinMode(LED_A, OUTPUT);
  pinMode(LED_B, OUTPUT);
  pinMode(LED_C, OUTPUT);
  digitalWrite(LED_A, LOW);
  digitalWrite(LED_B, LOW);
  digitalWrite(LED_C, LOW);
  Serial.begin(1200);
}

void loop()
{
  switch(readUInt(true)) {
    case 'A' : ledOff();digitalWrite(LED_A, HIGH);break;
    case 'B' : ledOff();digitalWrite(LED_B, HIGH);break;
    case 'C' : ledOff();digitalWrite(LED_C, HIGH);break;
  }
}

void ledOff()
{
  digitalWrite(LED_A, LOW);
  digitalWrite(LED_B, LOW);
  digitalWrite(LED_C, LOW);
}

unsigned int readUInt(bool wait)
{
  int pos = 0;          // Position in the network signature
  unsigned int val;     // Value of the unsigned int
  byte c = 0;           // Current byte
 
  if((Serial.available() < PACKET_SIZE) && (wait == false))
  {
    return 0xFFFF;
  }
 
  while(pos < NETWORK_SIG_SIZE)
  {
    while(Serial.available() == 0); // Wait until something is avalible
    c = Serial.read();

    if (c == g_network_sig[pos])
    {
      if (pos == NETWORK_SIG_SIZE-1)
      {
        byte checksum;

        while(Serial.available() < VAL_SIZE + CHECKSUM_SIZE); // Wait until something is avalible
        val      =  Serial.read();
        val      += ((unsigned int)Serial.read())*256;
        checksum =  Serial.read();
       
        if (checksum != ((val/256) ^ (val&0xFF)))
        {
          // Checksum failed
          pos = -1;
        }
      }
      ++pos;
    }
    else if (c == g_network_sig[0])
    {
      pos = 1;
    }
    else
    {
      pos = 0;
      if (!wait)
      {
        return 0xFFFF;
      }
    }
  }
  return val;
}

        เมื่อทำการ upload โปรแกรมไปยัง Arduino UNO เรียบร้อยแล้ว ทำการทดสอบโปรแกรม 

จะได้ผลตาม video นี้เลยครับ

 

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

        ใครมีโปรเจคที่น่าสนใจก็สามารถแชร์ความรู้กันทาง gtalk หรือทางเมลล์ได้นะครับ
olekhanchai@gmail.com หรือสนใจอุปกรณ์สามารถเข้าสั่งซื้อได้ในเว็บ http://www.hobbyembshop.biz หรือสินค้าโปรโมชั่นที่ https://www.facebook.com/hobbyembedded  

        ขอให้สนุกกับการประยุกต์ใช้งานนะครับ เจอกันคราวหน้าครับ...

 อ้างอิง  http://www.glacialwanderer.com/hobbyrobotics/?p=291

Raspberry Pi 3G Wifi Hotspot

Raspberry Pi+3G Aircard+Wifi Dongle = RPi 3G Wifi Hotspot

        หลายคนมีโทรศัพท์ที่สามารถทำตัวเป็น Wifi Hotspot ได้ แต่การที่จะใช้โทรศัพท์มาทำเป็น Hotspot นั้นคงจะทำให้แบตเสื่อมในเร็ววันแน่นอน ยิ่งถ้าหากเป็นเครื่องโทรศัพท์ที่เป็นรุ่นที่ราคาแพงๆ ด้วยแล้ว การที่จะเปิดเป็น Hotspot ทิ้งไว้ทั้งวันทั้งคืน คงไม่ใช่เรื่องดีแน่ แต่ถ้าหากใครที่จะลงทุนซื้อโทรศัพท์เครื่องถูกๆ ที่สามารถเปิดเป็น Wifi Hotspot ไว้เพื่อเป็นตัวปล่อยสัญญาณ Wifi ก็ยังคงต้องมีปัญหาเรื่องแบตเสื่อมอยู่ดี ถ้าซื้อมาเพื่อที่จะใช้เป็น Hotspot โดยตรงแล้วอันนี้ก็ไม่ว่ากันครับ
        นอกจากนี้แล้ว ถ้าหากใครมี Router Internet ที่บ้าน ก็จะมีตัวกระจายสัญญาณ Wifi ในตัว
อยู่แล้ว แต่ถ้าหากเป็น Router รุ่นเก่าที่มีเฉพาะสาย Lan ก็สามารถใช้ Raspbery Pi 3G Wifi Hotspot ตัวนี้ได้ หรือจะประยุกต์เป็น Proxy Server ไปเลยก็ได้ครับ
       ก่อนอื่น เริ่มจากเตรียมอุปกรณ์ที่ต้องใช้ให้พร้อมกันก่อน ซึ่งมีรายการดังนี้ครับ

                  1. Raspberry Pi พร้อมลง Raspbian (No Enable Desktop)
                  2. Wifi Dongle
                  3. 3G หรือ 4G Aircard
                  4. Internet SIM (ค่ายไหนก็ได้ ที่สมัครและเปิดบริการ 3G ไว้แล้ว)
                  5. 5V 2A Adapter (จ่ายไฟให้กับ Raspberry Pi อาจจะใช้ Power Bank ก็ได้นะครับ)
                  6. USB HUB (เอาไว้ต่อ Keyboard ให้กับ Raspberry Pi หรืออาจติดตั้งผ่าน SSH ก็ได้)

        จากนั้นก็ทำการประกอบชิ้นส่วนต่างๆ ให้ได้ตามรูปเลยครับ

        เมื่อต่ออุปกรณ์เสร็จเรียบร้อยแล้ว ก็ทำการจ่ายไฟให้กับ Raspberry Pi ของเรากันได้เลยครับ
ให้ระบบทำงานไปจนถึงหน้า Login จากนั้นก็ทำการ Login เข้าระบบตามรหัสผ่านที่ตั้งเอาไว้ตอนติดตั้ง Raspbian (ย้อนกลับไปดูรายละเอียดบทความแรก)
        หลังจากนั้นทำการเชื่อมต่อ Internet กับบอร์ดเพื่อให้สามารถทำการติดตั้งโปรแกรมให้กับ Raspberry Pi เพื่อที่จะทำให้ Wifi Dongle กลายเป็น Access Point และ ติดตั้งโปรแกรม Sakis3g เพื่อใช้ Internet จาก Aircard
        ในที่นี้ขอต่อ Internet ทาง Wifi Dongle ที่ใช้ apt-get ในการ Install โดยแก้ไขไฟล์ตามขั้นตอนดังนี้
        เข้าไปแก้ไขไฟล์ interfaces โดยใช้คำสั่ง
 
        sudo nano /etc/network/interfaces

        จากนั้นแก้ไฟล์ตามนี้เลยครับ

ในกรณีที่ Access Point เป็น WPA

        auto wlan0
        iface lo inet loopback
        iface wlan0 inet dhcp
        wpa-ssid <ชื่อ access point ที่เชื่อมต่อ Internet>
        wpa-psk <รหัสผ่านของ access point>

ในกรณีที่ Access Point เป็น WEP

        auto wlan0
        iface lo inet loopback
        iface wlan0 inet dhcp
        wireless-essid <ชื่อ access point ที่เชื่อมต่อ Internet>
        wireless-key s:<รหัสผ่านของ access point>

       หลังจากนั้นก็กด Ctrl+O (บันทึก) และ Ctrl+X (ออกจากโปรแกรม) เสร็จขั้นตอนนี้แล้วก็ทำการ restart network โดยการใช้คำสั่ง

        sudo /etc/init.d/networking restart

       เมื่อเสร็จขั้นตอนนี้แล้ว ก็จะสามารถใช้งาน Internet ได้แล้วครับ (ขั้นตอนข้างต้นเป็นการติดตั้ง Wifi Dongle ให้ Raspberry Pi รู้จักและเชื่อมต่อระบบเครือข่าย ถ้าหากใช้สาย Lan ไฟล์ interfaces
ก็ไม่ต้องทำการแก้ไข)

       จากนั้นให้ทำการดาวน์โหลดไฟล์ sakis3g.tar.gz มาเพื่อทำการติดตั้งโดยใช้คำสั่ง

       จะได้ไฟล์ sakis3g.tar.gz ที่ directory ที่ใช้คำสั่งนั้น หากโหลดไฟล์ได้สำเร็จจะแสดงหน้าจอดังนี้

        เสร็จแล้วให้ทำการแตกไฟล์ โดยใช้คำสั่ง

     

        ก่อนที่จะทำการ Connect กับ Aircard นั้น จะต้องติดตั้ง usb_modeswitch ให้กับ Raspberry Pi
กันก่อน ซึ่งจะทำให้ Aircard สามารถสื่อสารได้ภายใต้ชื่อ ttyUSB โดยใช้คำสั่งดังนี้

     

        ตอบ Y หลังจากนั้นก็รอให้คำสั่งนั้นประมวลผลจนเสร็จจะได้หน้าจอดังนี้

        จากนั้นให้ reboot Raspberry Pi อีกครั้ง ด้วยคำสั่ง sudo reboot

       เมื่อเข้าสู่ระบบอีกรอบ ทำการติดตั้ง ppp (point to point protocol) ให้กับ Raspberry Pi โดยใช้คำสั่ง

        จากนั้นให้ตอบ Y เพื่อทำการติดตั้ง หากติดตั้งเสร็จเรียบร้อยจะแสดงข้อความดังรูป

       เสร็จขั้นตอนการติดตั้งแล้ว เราจะทำการ Connect 3G อัตโนมัติเมื่อ Raspberry Pi เริ่มทำงานกัน
โดยก่อนอื่น เราจะนำคำสั่ง sakis3g ไปไว้ยัง /usr/sbin เพื่อให้สามารถเรียกใช้ได้ทุกที่โดยไม่ต้องระบุ path โดยใช้คำสั่งดังนี้

        จากนั้นเราจะทำการ connect 3G ที่ startup โดยจะต้องไปแก้ไฟล์ /etc/rc.local โดยเพิ่มคำสั่งของ sakis3g พร้อม parameter ดังนี้

      แก้ไฟล์ตามรูปด้านล่าง โดย APN ของ AIS = internet, DTAC = www.dtac.co.th,
TRUE = hinternet ส่วน user และ pass ตั้งเป็นอะไรก็ได้ (ในที่นี้เป็นชื่อเครือข่าย)

       เมื่อทำการแก้ไขเสร็จเรียบร้อยแล้ว ให้บันทึกและออกจาก editor ได้เลยครับ จากนั้นเราจะมาทำการตั้งค่า Wifi Dongle ของเราให้สามารถทำตัวเป็น Hotspot โดยมีคำสั่งดังนี้
   

        จากนั้นตอบ Y เมื่อ install เสร็จเรียบร้อยแล้วจะมีหน้าจอดังนี้

        จากนั้นทำการแก้ไขไฟล์ /etc/default/udhcpd เพื่อเปิดการทำงานของ dhcp ดังนี้

       เปลี่ยน ip ของ Wifi ให้เป็น static เพื่อเป็น ip เริ่มต้นในการแจก ip โดยแก้ไขไฟล์ /etc/network/interfaces ให้เป็นดังนี้

        จากนั้นให้ทำการแก้ไขไฟล์ /etc/udhcpd.conf โดยกำหนดค่าต่างๆ ดังนี้

 

        ต่อไปก็ทำการแก้ไขไฟล์ /etc/hostapd/hostapd.conf (หากไม่มีให้สร้าง) โดยกำหนดค่าดังนี้

        สามารถตั้ง ssid ได้ตามใจชอบ และเปลี่ยน <yourpasskey> ให้เป็น passkey ของผู้อ่านเอง
        จากนั้นทำการตั้ง hostapd ให้อ่านค่าจาก hostapd.conf โดยแก้ไขไฟล์ /etc/default/hostapd ดังนี้

        หลังจากนั้นทำการตั้งค่า ip forward โดยแก้ไขไฟล์ /etc/sysctl.conf ให้เป็นค่าดังนี้

        เมื่อเสร็จขั้นตอน forward ip แล้ว ให้ตั้งค่า NAT (Network Address Translation) ดังนี้ (หากพิมพ์คำสั่งแล้วเกิด error ขึ้น ให้ใช้คำสั่ง sudo rpi-update แล้ว reboot ก่อนหนึ่งรอบ)

      เพื่อให้ตอน reboot เครื่องแล้วค่าไม่หายไป ทำการบันทึกค่า iptables ลงไฟล์ด้วยคำสั่ง

      เพิ่มคำสั่ง iptable-restore เพื่อทำการตั้งค่าที่บันทึกไว้ เมื่อ Network เริ่มทำงาน ลงในไฟล์ /etc/network/interfaces ดังนี้

        ขั้นตอนสุดท้าย เปิดการทำงานของ hostapd และ udhcpd เมื่อมีการเริ่มระบบ โดยใช้คำสั่งดังนี้

         จากนั้นทำการ reboot Raspberry Pi ด้วยคำสั่ง sudo reboot เท่านี้ก็ได้ Wifi Hotspot ไว้ใช้งานแล้วหล่ะครับ อาจจะมี Power Bank ซักตัว จ่ายไฟให้ จับ RPI เข้ากล่องเสียบ USB เฉพาะ Wifi Dongle และ 3G Aircard ก็เก๋ไปอีกแบบ ว่างๆ ลองทำเล่นดูนะครับ

        ใครมีโปรเจคที่น่าสนใจก็สามารถแชร์ความรู้กันทาง gtalk หรือทางเมลล์ได้นะครับ
olekhanchai@gmail.com หรือสนใจอุปกรณ์สามารถเข้าสั่งซื้อได้ในเว็บ http://www.hobbyembshop.biz หรือสินค้าโปรโมชั่นที่ https://www.facebook.com/hobbyembedded  
ไว้เจอกันคราวหน้าครับ

อ้างอิง:  http://elinux.org/RPI-Wireless-Hotspot