อย่างแรกเลย เตรียมอุปกรณ์ต่างๆ ให้เรียบร้อย Raspberry Pi + ลำโพง + ไมโครโฟน

ก่อนลงมือทำอย่างอื่นให้ทำการอัพเดทระบบก่อนครับ

sudo apt-get update
sudo apt-get upgrade

จากนั้นทำการติดตั้ง Node.js และติดตั้ง developer tools ต่างๆ ให้พร้อมใช้งาน

curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
sudo apt-get install nodejs
sudo apt-get install sox libmagic-dev libatlas-base-dev
sudo apt-get install build-essential

กำหนด NODE_PATH เพื่อให้เรียกใช้งานโมดูลของ Node.js ที่ติดตั้งแบบ global ได้ เพราะเดียวเราจะติดตั้งโมดูทั้งหมดเป็นแบบ global

export NODE_PATH=/usr/lib/node_modules

เมื่อติดตั้งเสร็จแล้ว ลองเช็คดูก่อนว่าสามารถเรียกใช้คำสั่ง node และ npm ได้ปกติแล้ว ง่ายๆ ก็ลองสั่งให้แสดง version ขึ้นมาดูก่อนเลย

node -v
npm -v

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

ตรวจสอบหมายเลข card id และ device id ของลำโพง

aplay -l

จากรูปจะเห็นว่ามี card อยู่หลายใบ ให้สั่งเกตุหมายเลข card id และ device id ที่ผมไฮไลท์เอาไว้ด้วยนะครับ ให้เลือกใช้ card id และ device id อันที่ลำโพงเราต่ออยู่ (ข้างหลังมันมีชื่อรุ่นบอก น่าจะพอเดาได้อยู่)

ตรวจสอบหมายเลข card id และ device id ของไมโครโฟน

arecord -l

ทำการสร้างไฟล์ ~/.asoundrc เพื่อกำหนดค่า default ของลำโพงและไมโครโฟนให้ระบบ

nano ~/.asoundrc

โดยให้พิมพ์คำสั่งตามนี้ลงไป จะเห็นว่าในช่องของ playback.pcm ซึ่งก็คือลำโพงของเรา ให้เราใส่ hw:1,0 ซึ่งเป็นหมายเลข card id , device id ในที่นี้ก็คือ card 1, device 0 และสำหรับ capture.pcm ซึ่งเป็นไมโครโฟน ให้เราใส่เป็น hw:1,0 ซึ่งก็คือไมโครโฟนจาก card 1, device 0 (ถ้าหาก card id และ device id ของท่านแตกต่างจากนี้ก็ให้ใส่ให้ตรงกับของตัวเองด้วยนะครับ)

pcm.!default {
  type asym
   playback.pcm {
     type plug
     slave.pcm "hw:1,0"
   }
   capture.pcm {
     type plug
     slave.pcm "hw:1,0"
   }
}

เราสามารถปรับความดังของลำโพงและไมโครโฟนได้โดยใช้คำสั่ง alsamixer (ถ้าท่านใช้ตัวแปลง USB To Sound Adapter เพื่อทำการแปลงสาย USB เป็น 3.5mm เพื่อใช้เสียบลำโพงกับไมโครโฟนแบบผม ก็ให้กด F6 เพื่อเลือก device ก่อนนะครับ)

alsamixer

ทำการทดสอบการบันทึกเสียงจากไมโครโฟน ให้สั่ง rec test.wav และพูดใส่ไมโครโฟนและถ้าต้องการหยุดให้กด CTRL+C

rec test.wav

ลองสั่ง play เสียงที่เราบันทึกไว้เมื่อสักครู่นี้

aplay test.wav

ขั้นตอนถัดไปให้ทำการติดตั้ง snowboy และโมดูลต่างๆ ที่ต้องใช้งาน โดยเราจะติดตั้งทั้งหมดเป็นแบบ global ไปเลยนะครับ

sudo npm install -S -g snowboy
sudo npm install -S -g node-record-lpcm16
sudo npm install -S -g play-sound

ต่อไปเป็นการสร้างโมเดลเสียงของคำที่ต้องการ โดยให้เข้าไปที่ https://snowboy.kitt.ai/dashboard จะเห็นปุ่ม Create Hotword คลิกเลยครับ

ทำการตั้งชื่อและเลือกภาษาให้เรียบร้อย แต่ระบบยังไม่มีภาษาไทยให้เลือกนะ ให้เราเลือกเป็น Other ไปก่อนนะ ผมลองแล้วก็ได้เหมือนกัน

ขั้นตอนถัดไปเป็นการบันทึกเสียง ให้เราบันทึกเสียงของคำที่เราต้องการลงไป 3 ครั้ง

ขั้นตอนสุดท้ายเป็นการทดสอบและดาวน์โหลดโมเดลเสียงของเรา โดยเราจะได้มาเป็นไฟล์ .pmdl ดาวน์โหลดมาเก็บไว้ให้เรียบร้อยครับ

หลังจากติดตั้งโปรแกรมและสร้างไฟล์โมเดลของเสียงเรียบร้อยแล้วให้ทำการดาวน์โหลดโค้ดที่ผมเตรียมไว้ไปทดสอบรันได้เลยครับ Download Showboy Example โดยในโค้ดตัวอย่างจะมีไฟล์ snowboy.js ให้ทำการเปิดโค้ดขึ้นมาดูก่อนเลยครับ จะเห็นว่าในตัวอย่างผมมีโมเดลของคำสั่งเสียงอยู่ 2 ตัวคือ thai-hello.pmdl และ thai-what-is-your-name.pmdl ให้เอาโมเดลเสียงของตัวเองมาแทน 2 ไฟล์นี้นะครับ

snowboy.js

const record = require('node-record-lpcm16');
const Detector = require('snowboy').Detector;
const Models = require('snowboy').Models;
const player = require('play-sound')(opts = {})


const models = new Models();

models.add({
    file: 'thai-hello.pmdl',
    sensitivity: '0.5',
    hotwords: 'Hello'
});

models.add({
    file: 'thai-what-is-your-name.pmdl',
    sensitivity: '0.5',
    hotwords: 'What\'s your name'
});

const detector = new Detector({
    resource: "common.res",
    models: models,
    audioGain: 2.0
});

detector.on('silence', function() {
    //console.log('silence');
});

detector.on('sound', function() {
    //console.log('sound');
});

detector.on('error', function() {
    //console.log('error');
});

detector.on('hotword', function(index, hotword) {
    console.log('Index='+index+', Hotword='+hotword);

    if(index == 1){
      player.play('sound-hello.wav', function(err){
        //console.log('play sound');
      });
    }else if(index == 2){
      player.play('sound-my-name.wav', function(err){
        //console.log('play sound');
      });
    }
});

const mic = record.start({
    threshold: 0,
    verbose: false
});

mic.pipe(detector);

เรียบร้อยแล้วครับ ให้สั่งรัน node snowboy.js และพูดคำสั่งที่เราตั้งไว้ได้เลยครับ

node snowboy.js

หากติดขัดปัญหาใดค้นหาข้อมูลเพิ่มเติมจาก Google และอ่านรายละเอียดได้จากแหล่งอ้างอิงครับ

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

อ้างอิง :
https://snowboy.kitt.ai/
http://docs.kitt.ai/snowboy/
https://github.com/kitt-ai/snowboy
https://www.npmjs.com/package/snowboy

หลังจากไปหาซื้อมาแล้วก็แกะกล่อง ใช้ไขขวงดันๆ เดียวมันก็หลุดออกมาครับ (หลุดพร้อมประกัน)

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

GPIO14
GND
TX
RX
VCC 3.3V

เมื่อบัดกรีขาต่างๆ เรียบร้อยแล้ว ให้ทำการต่อ Sonoff กับ USB To UART เพื่อทำการเขียนโปรแรกมลงไป โดยให้ต่อขาต่างๆ ดังนี้

[Sonoff] --> [USB To UART]
VCC --> VCC (3.3V)
RX --> TX
TX --> RX
GND -->GND

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

โดยให้ใส่ SSID และ Password ของ WI-FI ของเราลงไป และเราจะเขียนโปรแรกมให้ฟิกค่า IP ของอุปกรณ์เอาไว้เพื่อความสะดวกในการเรียกใช้งาน (คงไม่สะดวกแน่ๆ ถ้าจะให้มันรับ DHCP เข้ามา) ดาวน์โหลดโค้ดตัวอย่าง

const char* ssid = "WIFI_SSID";
const char* password = "WIFI_PASSWORD";

const IPAddress ip(192, 168, 1, 100); // IP ของอุปกรณ์ตัวนี้ 192.168.1.100
const IPAddress subnet(255, 255, 255, 0);
const IPAddress gt(192, 168, 1, 1);

#include 
#include 

const char* ssid = "WIFI_SSID";
const char* password = "WIFI_PASSWORD";

const IPAddress ip(192, 168, 1, 100);
const IPAddress subnet(255, 255, 255, 0);
const IPAddress gt(192, 168, 1, 1);

const int SwitchPin = 12; // GPIO12
int SwitchValue = HIGH;

ESP8266WebServer server(80);

void handleNotFound(){
  //server.send(404, "text/plain", "404 Not Found");

  if(SwitchValue == HIGH) {
    server.send(200, "text/plain", "ON");
  }else{
    server.send(200, "text/plain", "OFF");
  }

  delay(1000);
}

void setup(void){

  // Set Output PIN
  pinMode(SwitchPin, OUTPUT);
  digitalWrite(SwitchPin, SwitchValue);

  // Connect WiFi
  WiFi.mode(WIFI_STA);
  WiFi.config(ip, gt, subnet);
  WiFi.begin(ssid, password);

  // Wait for connection
  while(WiFi.status() != WL_CONNECTED){
    delay(1000);
  }

  server.on("/", [](){
    if(SwitchValue == HIGH) {
      server.send(200, "text/plain", "ON");
    }else{
      server.send(200, "text/plain", "OFF");
    }

    delay(1000);
  });

  server.on("/ON", [](){
    SwitchValue = HIGH;

    server.send(200, "text/plain", "ON");
    digitalWrite(SwitchPin, SwitchValue);
    delay(1000);
  });

  server.on("/OFF", [](){
    SwitchValue = LOW;

    server.send(200, "text/plain", "OFF");
    digitalWrite(SwitchPin, SwitchValue);
    delay(1000);
  });

  server.onNotFound(handleNotFound);

  server.begin();
}

void loop(void){
  server.handleClient();
}

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

หลังจากอัพโหลดโปรแกรมเรียบร้อยแล้ว ให้ทำการประกอบทุกอย่างลงกล่องให้เหมือนเดิมและนำไปใช้งานได้ (ที่สำคัญให้ต่อสาย L กับ N ให้ถูกทั้งขาเข้าและขาออกด้วยนะครับ)

ทดสอบสั่งเปิดปิดไฟ โดยเปิดบราวเซอร์และพิมพ์ IP ของ Sonoff WiFi Smart Switch ที่เราคอนฟิกไว้ตอนเขียนโปรแกรม ดังนี้

http://192.168.1.100/ON
http://192.168.1.100/OFF

ก่อนจบ: ข้อเสียอย่างหนึ่งของ Sonoff Smart Switch คือว่ามันใช้ Relay ธรรมดา ทำให้เวลาเปิดปิดวงจรจะมีเสียงนิดหน่อย ถ้าเป็นไปได้ผมว่าจะหา Solid State Relay มาเปลี่ยนอยู่ //แต่ก็แพง

ขั้นตอนการทำก็แบ่งออกเป็น 2 ขั้นตอนใหญ่ๆ คือ
1. สร้าง Telegram Bot
2. เขียนโปรแกรมบน ESP8266 เพื่อส่งข้อความมายัง Telegram ของเรา (ในบทความนี้จะใช้ ESP-01 และใช้สวิตซ์เป็นอินพุต ในการใช้งานจริงให้เปลี่ยนจากสวิตซ์ไปเป็น PIR Sensor หรือหากว่าต้องการรับอินพุตที่เป็น Analog ให้เปลี่ยนไปใช้ ESP-07 หรือ ESP-12 ที่มีขา ADC มาให้นะครับ)

สำหรับการสร้าง Telegram Bot ให้เราทำการเพิ่ม @BotFather เป็นเพื่อนกับเราก่อน ซึ่งเราจะต้องสั่งให้ @BotFather สร้างบอทให้เรา (ไม่เข้าใจเหมือนกันว่าทำไมเขาไม่ให้ทำผ่านหน้าเว็บ แต่เขาให้ทำในนี้ก็ทำไปครับ)

เมื่อเพิ่ม @BotFather เป็นเพื่อนแล้ว เราจะเห็นคำสั่งต่างๆ ขึ้นมาให้เราใช้งาน ลองพิมพ์ /help ระบบจะแสดงคำสั่งต่างๆ ขึ้นมาให้

ทีนี้ให้เราสร้าง Bot โดยใช้คำสั่ง /newbot ซึ่งระบบจะให้เราใส่ชื่อที่จะใช้เรียกบอทของเรา และให้ใส่ username ของบอท ซึ่งตรง username นี้จะต้องไม่ซ้ำกับคนอื่นและจะต้องลงท้ายด้วย bot เท่านั้น (ตัวอย่างผมจะใช้ชื่อบอทว่า SmartHomeABC123 และใช้ username ว่า SmartHomeABC123Bot) เมื่อสร้างเสร็จแล้วระบบจะแสดง Access Token ขึ้นมาให้เรา Token ตัวนี้จะใช้สำหรับการส่งข้อความนะครับ จดไว้ๆ

จากนั้นให้เราทำการเพิ่มบอท @SmartHomeABC123Bot เป็นเพื่อนของเราก่อน และลองทักมันไปสัก 1 ครั้ง จะเห็นว่าไม่มีอะไรขึ้นมา ไม่ต้องตกใจ อ่านข้อต่อไปครับ สิ่งที่เราต้องการไม่ได้ให้มันตอบกลับ แต่เราต้องการ ID ของเราเอง เพื่อใช้ในการส่งข้อความกลับ

จากนั้นให้พิมพ์คำสั่งนี้ที่ browser หรือหากใครใช้ CURL เป็นก็ตามสะดวก ออ อย่าลืมเปลี่ยนตรงคำว่า <ACCESS_TOKEN> เป็น Access Token ของบอทตัวเองด้วยนะครับ

https://api.telegram.org/bot<ACCESS_TOKEN>/getUpdates

สำหรับฟอร์แมตของคำสั่งจะเป็น https://api.telegram.org/bot<ACCESS_TOKEN>/API_COMMAND นะครับ สามารถอ่านข้อมูลเพิ่มเติมได้ว่าเราสามารถสั่งอะไรได้บ้างจาก Link นี้ครับ https://core.telegram.org/bots/api

หลังจากสั่ง /getUpdates เราจะได้ข้อมูลของข้อความและ id ของผู้ส่ง ซึ่งเดียวเราจะใช้ id ตรงนี้ในการนำไปใช้ในการส่งข้อความจาก ESP8266 ต่อไป (ถ้าสั่ง /getUpdates แล้วไม่มีข้อมูลอะไรขึ้น ให้ลองพิมพ์ข้อความทักบอทของเราไปอีกรอบ บาททีเราอาจจะเว้นช่วงนานไปจนข้อความนั้นหมดอายุไปก่อน)

หลังจากนั้นลองทำการส่งข้อความจากบอทของเรากลับมาหาเราหน่อยโดยใช้คำสั่ง CURL ถ้าใครใช้ CURL ไม่เป็นหรือไม่ได้ลงไว้ก็ข้ามไปเลยครับ อันนี้ผมทำให้ดูเฉยๆ โดยเราจะส่งเป็นพารามิเตอร์ text และ chat_id เป็น method post เข้าไป

curl -X POST https://api.telegram.org/bot/sendMessage -d text="test test" -d chat_id="" -k

เย้ๆ ส่งข้อความได้แล้ว

ขั้นตอนถัดไป เรามาเขียนโปรแกรมเพื่อส่งข้อความบน ESP8266 กันต่อ โดยผมจะใช้ ESP-01 เป็นตัวทดสอบ โดยจะให้กดสวิตซ์บนบอร์ตแล้วให้ส่งข้อความออกไป อันนี้ไม่ยากลอกโค้ดแล้วไปทำความเข้าใจกันเอา

อย่ากแรกต่อวงจรตามนี้ก่อน โดยให้ต่อ ESP-01 เข้ากับ USB To UART เพื่อทำการเขียนโปรแกรมลงไป และต่อสวิตซ์แบบ pull-up เข้ากับขา GPIO-2 ส่วนรายละเอียดอื่นๆ ตามนี้ครับ

[ESP-01] --> [USB To UART]
RX --> TX
TX --> RX
VCC --> VCC (3.3v)
CH_PD --> VCC (3.3v)
GNC --> GND
GPIO-0 --> GND
GPIO-2 --> ต่อ pull-up กับสวิตซ์

เขียนโค้ดบน Arduino และทำการ upload sketch เข้าไปที่ ESP-01 ที่เราต่อวงจรเตรียมเอาไว้ เมื่อเรียบร้อยแล้วก็ทดสอบกดสวิตซ์ ระบบจะทำการส่งข้อความมาหาเราที่ Telegram ของเราแล้วครับ (Download Source Code)

โดยจากโค้ดให้แก้บรรทัดดังต่อไปนี้ โดยให้ใส่ค่าต่างๆ ตามที่เราได้มาจากขั้นตอนก่อนหน้านี้นะครับ

const char* ssid = "WIFI_SSID";
const char* password = "PASSWORD123";
const String AccessToken = "";
String PostData = "text=แจ้งเตือน: สวิตซ์บน ESP8266 ถูกกด&chat_id=";

#include 
#include 

// WIFI SSID & Password
const char* ssid = "WIFI_SSID";
const char* password = "PASSWORD123";

// Telegram Server API
const int httpsPort = 443;
const char* host = "api.telegram.org";
const String AccessToken = "";

const int SwitchPin = 2; // GPIO2
int SwitchOldStatus = HIGH;
int SwitchNewStatus = HIGH;

void setup(void){
  Serial.begin(9600);

  pinMode(SwitchPin, INPUT);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  // Wait for connection
  while(WiFi.status() != WL_CONNECTED){
    delay(500);
  }
}

void loop(void){

  // Read Data From Switch
  SwitchNewStatus = digitalRead(SwitchPin);

  if(SwitchNewStatus == LOW && SwitchNewStatus != SwitchOldStatus){

    String PostData = "text=แจ้งเตือน: สวิตซ์บน ESP8266 ถูกกด&chat_id=";

    WiFiClientSecure client;
    Serial.print("connecting to ");
    Serial.println(host);

    if (!client.connect(host, httpsPort)) {
      Serial.println("connection failed");
      return;
    }

    // POST
    client.print(String("POST ") + "/bot" + AccessToken + "/sendMessage HTTP/1.1\r\n" +
             "Host: " + host + "\r\n" +
             "User-Agent: ESP8266-Notification\r\n" +
             "Content-Type: application/x-www-form-urlencoded\r\n" +
             "Cache-Control: no-cache\r\n" +
             "Content-Length: " + String(PostData.length()) + "\r\n" +
             "\r\n" +
             PostData);

    // Header
    Serial.println("-------Response Header-------");
    while (client.connected()) {
      String line = client.readStringUntil('\n');
      if (line == "\r") {
        break;
      }

      Serial.println(line);
    }

    // Body
    Serial.println("-------Response Body-------");
    String body = client.readStringUntil('\n');
    Serial.println(body);

  }

  SwitchOldStatus = SwitchNewStatus;
  delay(500);
}

หลังจากทำการ upload sketch ให้ลองเปิด Serial Monitor ขึ้นมาดู Log และทดสอบกดสวิตซ์ดูได้เลยครับ จะเห็นว่ามีข้อมูลถูกส่งออกไปยัง API ของ Telegram แล้ว

ขั้นต่อไปก็เอาไปใช้งานจริง ให้ถอดตัว USB To UART ที่เราใช้ upload sketch ออกและต่อวงจรดังรูป

[ESP-01] --> [Battery]
VCC --> VCC (3.3v)
CH_PD --> VCC (3.3v)
GNC --> GND
GPIO-2 --> ต่อ pull-up กับสวิตซ์

หมายเหตุ: ปกติผมจะส่งข้อมูลจากเซ็นเซอร์ไปยัง Raspberry Pi ที่ทำหน้าที่ควบคุมทั้งระบบก่อน แล้วค่อยส่งจาก Raspberry Pi ออกไปยัง service อื่นๆ ข้างนอกอีกทีนะครับ เพราะถ้าต้องมาแก้ไขข้อความหรือเปลียน Access Token ผมคงแก้ไขจากฝั่งของ Raspberry Pi น่าจะง่ายกว่ามานั้ง upload sketch ใหม่

Bluetooth Keyboard ของ rapoo รุ่น e6500 และ Bluetooth dongle (ต่อจอเสียบสายแลนให้เรียบร้อย)

เปลี่ยนสิทธิเป็น root กันก่อน โดยทั้งหมดนี้ทำผ่าน SSH

sudo su

จากนั้นทำการ enable dbus ซึ่งมันคืออะไรก็ไม่ทราบ อ่านต่อเองครับ dbus

update-rc.d -f dbus defaults

restart สักหนึ่งรอบ

shutdown -r now

จากนั้นทำการ install bluez, python-gobject

apt-get install bluez python-gobject

ใช้คำสั่ง hcitool scan เพื่อดู MAC Address ของ Bluetooth Keyboard โดยให้กดปุ่ม connect ที่ keyboard เมื่อเห็นว่ามีไฟสถานะเตรียม connect ขึ้นให้พิมพ์คำสั่ง hcitool scan

hcitool scan

ทำการ Pairing และกำหนด PIN เป็น 0000 เมื่อพิมพ์คำสั่งเสร็จ ให้กด 0000 และกด enter ที่ keyboard เพื่อทำการ pairing ครับ

echo 0000|bluez-simple-agent hci0 6C:5D:63:51:15:49

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

bluez-test-device trusted 6C:5D:63:51:15:49 yes

ทำการเชื่อมต่อกับ Bluetooth Keyboard และทดลองพิมพ์ได้เลยครับ

bluez-test-input connect 6C:5D:63:51:15:49

ขั้นตอนถัดไปให้ทำการแก้ไข /etc/rc.local เพื่อเพิ่มคำสั่งให้ connect กับ Bluetooth Keyboard ทุกครั้งที่เปิดเครื่อง

nano /etc/rc.local

เพิ่มบรรทัดนี้เข้าไปก่อนคำสั่ง exit 0 ครับ

bluez-test-input connect 6C:5D:63:51:15:49

โดยทุกครั้งที่เปิดเครื่องขึ้นมาเราต้องกดปุ่ม connect บนตัว keyboard เพื่อเตรียม connect เท่านี้เราก็จะได้ใช้ Bluetooth Keyboard ทุกครั้งที่เปิดเครื่องแล้วครับ

เริ่มจากการต่อวงจรกันก่อน โดยให้ต่อสายไฟและกราวด์ของ Servo Motor เข้ากับแหล่งจ่ายไฟภายนอกที่สามารถจ่ายไฟได้ประมาณ 3-5V แล้วแต่ขนาดของ Servo นะครับ (ผมลองต่อเข้ากับขา 5V ของ R-Pi แต่ไม่สามารถใช้งานได้ เครื่องจะ restart เวลาสั่งให้ Servo ทำงาน เข้าใจว่ากระแสไฟที่ R-Pi จ่ายให้น่าจะไม่พอ) และให้ต่อขากราวด์ของ R-Pi เข้ากับกราวด์ของแหล่งจ่ายไฟภายนอกอันนี้ด้วย จากนั้นก็เสียบขาสัญญานของ Servo เข้ากับขา GPIO 4

ต่อเสร็จแล้วได้ออกมาหน้าตาประมาณนี้ครับ (Servo ของผมตัวเล็กนิดเดียว)

จากนั้นทำการติดตั้งโปรแกรม GIT หากใครติดตั้งแล้วก็ข้ามไปขั้นตอนถัดไปเลยครับ

sudo apt-get install git-core

ทำการโคลน PiBits จาก github.com และทำการติดตั้ง

git clone https://github.com/richardghirst/PiBits.git
cd PiBits/ServoBlaster/user 
make 
sudo make install 

เมื่อติดตั้งเรียบร้อยแล้ว เราสามารถใช้ขาต่างๆ ทั้ง 8 ขาดังนี้ครับ โดย Servo หมายเลข 0 คือ GPIO 4 และไล่ไปเรื่อยจนถึง Servo หมายเลข 7 ตามตาราง

Servo number    GPIO number   Pin in P1 header
     0               4             P1-7
     1              17             P1-11
     2              18             P1-12
     3             21/27           P1-13
     4              22             P1-15
     5              23             P1-16
     6              24             P1-18
     7              25             P1-22

คราวนี้มาทดสอบกันดูว่าสามารถสั่งให้ Servo หมุนได้ไหม โดยเราต้องกำหนดความกว้างของพัลส์เพื่อควบคุมให้ Servo หมุนไปยังมุมต่างๆ ตั้งแต่ 0° – 180° ซึ่งปกติก็จะอยู่ที่ในช่วง 500us – 2000us แต่ผมมักใช้ 1000us ถึง 2000us มากกว่า ซึ่งจะหมุนได้ไม่ครบ 180° แต่ก็ปลอดภัยกับเฟืองในมอเตอร์มากกว่า และถ้าเรากำหนดความกว้างของพัลส์ที่ 1500us ก็จะถือว่าหมุนมาอยู่ตรงกลาง (อันนี้ขึ้นอยู่กับสเปกของ Servo แต่ละตัวด้วยนะครับ แต่ปกติจะประมาณนี้) จากตัวอย่างเราได้ต่อขาสัญญานของ Servo ไว้ที่ขา GPIO 4 ฉะนั้นเวลาสั่ง เราก็จะสั่งไปที่ Servo หมายเลข 0 ตามตัวอย่าง

echo 0=1000us > /dev/servoblaster
echo 0=1500us > /dev/servoblaster
echo 0=2000us > /dev/servoblaster

เพียงเท่านี้เราก็สามารถควบคุมให้ Servo Motor หมุนในมุมต่างๆ ได้แล้วครับ อันนี้เราอาจจะเอาไปประยุกต์ใช้ในการควบคุมการหมุนของกล้องผ่านเว็บก็สามารถที่จะทำได้เช่นกัน ลองนำไปต่อยอดกันดูครับ

ทดสอบการหมุน Servo Motor ในมุมต่างๆ

ดูข้อมูลเพิ่มเติมได้ที่ : https://github.com/richardghirst/PiBits/tree/master/ServoBlaster

ทำการตรวจสอบหมายเลขไอดีและค่าของดีไวซ์ จากรูปจะเห็นว่าค่าของ Mic Capture Volume มี Values=0

amixer --card 1 contents

ทำการปรับระดับความดังของไมโครโฟนให้ดังสุด (หรือจะไม่สุดก็แล้วแต่) โดยใส่ค่าได้ตั้งแต่ 0 – 16

amixer -c 1 cset numid=2 16

ตรวจสอบไอดีของการ์ดที่จะใช้ในการบันทึกเสียง จากรูปเป็นการ์ดหมายเลข 1

arecord -l

ทำการบันทึกเสียงโดยใช้คำสั่ง arecord โดยมีพารามิเตอร์ดังนี้ -d 5 หมายถึงให้บันทึกเสียงเป็นเวลา 5 วินาทีแล้วหยุด, -D plughw:1 ให้ใช้การ์ดหมายเลข 1, และ test.wav ให้บันทึกเป็นไฟล์ test.wav

arecord -d 5 -f cd -t wav -D plughw:1 test.wav

เมื่อบันทึกเสร็จ ให้ทดสอบทำการเปิดเสียงที่บันทึกเมื่อสักครู่โดยใช้คำสั่ง aplay

aplay test.wav

เมื่อได้ไฟล์เสียง .wav มาแล้ว เราสามารถแปลงเป็นฟอร์แมตต่างๆ ได้โดยใช้คำสั่ง ffmpeg ตัวอย่างเราจะแปลงเป็นไฟล์ .mp3 ก็ใช้คำสั่งดังนี้

ffmpeg -i test.wav test.mp3

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

sudo apt-get install ffmpeg

ทำการติดตั้งโปรแกรม mpg321 เพื่อใช้เล่นไฟล์ mp3

sudo apt-get -y install mpg321

กำหนดให้สัญญานเสียงออกที่แจ๊คออดิโอ (ถ้ากำหนด amixer cset numid=3 2 เสียงจะออกทาง HDMI)

amixer cset numid=3 1

คอนฟิกต่างๆเรียบร้อย ก็มาลองสั่งรันคำสั่ง mpg321 filename.mp3 เพื่อเล่นเพลง

mpg321 filename.mp3

หากต้องการปรับระดับความดังของเสียงให้ดังขึ้นก็เพิ่ม -g เป็นระดับความดังของเสียงตั้งแต่ 1 ถึง 100 เข้าไปดังนี้

mpg321 -g 50 filename.mp3

และถ้าหากต้องการให้เล่นต่อเนื่องกันหลายเพลงก็สามารถกำหนดชื่อไฟล์ต่อๆ กันไปได้เลยครับ

mpg321 -g 50 filename1.mp3 filename2.mp3

เพียงเท่านี้ เราก็เปิดเพลง MP3 ได้โดยไม่ต้องเข้า X-Window แล้วครับ

ก่อนทำอย่างอื่น มาดูคอนฟิกที่ตัวเราเตอร์กันก่อนครับ ในการทดลองนี้ผมใช้เราเตอร์ของ TrendNET รุ่น TEW-652BRP โดยกำหนดค่าต่างๆ ที่สำคัญดังนี้ และให้เราเตอร์เป็นตัว DHCP จ่าย IP ให้กับ Client ที่คอนเน็คเข้ามา (การคอนฟิกของยี้ห้ออื่นก็น่าจะคล้ายๆ กันนะครับ)

SSID = LookHin-WiFi
Authentication Type = WPA2
PSK / EAP = TKIP 
Cipher Type = Auto
Passphrase  = PASSWORD //รหัสผ่านตั้งเองเลยนะครับ ผมตั้ง 12345678 ฮาาา

ทำการเสียบ TP-Link TL-WN725N เข้าไปที่พอร์ต USB ของ Raspberry Pi และเสียบสายแลนให้พร้อม

ทำการเพิ่ม Repository ของ repository.pi3g.com เข้ามาในระบบ

sudo wget -O /etc/apt/sources.list.d/repository.pi3g.com.list http://repository.pi3g.com/sources.list

ติดตั้ง public key

wget -O - http://repository.pi3g.com/pubkey | sudo apt-key add -

อัพเดทแพคเกจต่างๆ กันก่อน

sudo apt-get update
sudo apt-get upgrade

จากนั้นทำการติดตั้งไดรเวอร์ของ TP-Link TL-WN725N

sudo apt-get install rtl8188eu

หลังจากติดตั้งไดรเวอร์เสร็จเรียบร้อยแล้ว ให้ทำการแก้ไขไฟล์ /etc/network/interfaces

sudo nano /etc/network/interfaces

โดยให้ทำการแก้ไข iface wlan0 inet manual เป็น iface wlan0 inet dhcp และทำการกำหนด wpa-ssid และ wpa-psk ของ Wi-Fi และทำการคอมเม้นบรรทัด wpa-roam ไว้ด้วยนะครับ (ในตัวอย่าง wpa-ssid ของผมก็คือชื่อ SSID ของเราเตอร์ของผม ในที่นี้คือ LookHin-WiFi และ wpa-psk คือ Password 12345678)

เสร็จเรียบร้อยแล้วครับ สั่ง Restart และทำการถอดสายแลนออก เท่านี้เราก็สามารถต่ออินเตอร์เน็ตให้ Raspberry Pi ผ่าน Wi-Fi ได้แล้วครับ และหลังจาก Restart เรียบร้อยแล้ว ทดลองสั่ง ifconfig เพื่อดูค่า IP Address ของ Wi-Fi สักนิดหน่อย เท่านี้ก็เรียบร้อย

ifconfig

# เพิ่มเติมครับ

คำสั่งสำหรับ Scan หา Wi-Fi Hotspot

iwlist wlan0 scan

# Update 2014-07-11
ถ้าหากเราได้ทำการ Update Kernel และไม่สามารถใช้งาน WIFI ได้ ให้ทำการติดตั้งใหม่ตามขั้นตอนในเว็บนี้นะครับ http://www.raspberrypi.org/forums/viewtopic.php?p=462982

ขั้นตอนการเปิดใช้งานก็ไม่อยากครับ ให้เราเข้าไปที่ Google Account settings https://www.google.com/settings/account ในเมนูทางซ้ายมือเลือกไปที่ Security และคลิกที่ Manage your application specific passwords

จากนั้นทำการใส่ชื่อที่จะช่วยให้เราจำได้ว่ารหัสผ่านชุดนี้ใช้กับโปรแกรมอะไรลงไป (ในตัวอย่างของผมก็จะเป็น RaspberryPi-To-Youtube)

เมื่อกดที่ปุ่ม Generated application เราก็จะได้รหัสผ่านที่จะเอาไปใช้กับแอพพลิเคชันที่ไม่สามารถใช้งานระบบการล็อกอิน 2 ชั้นได้แล้วครับ

ถ้าหากว่าเราไม่ต้องการใช้งานรหัสผ่านชุดนี้แล้ว เราก็เพียงแค่เลือกไปที่ Revoke เพื่อลบรหัสผ่านชุดที่ต้องการ ก็เป็นอันเรียบร้อย

IOIO & Robot Arm
ทดสอบควบคุมแขนกลด้วยโปรแกรมจากมือถือแอนดรอยด์

Leap Motion & Robot Car
ทดสอบควบคุมรถหุ่นยนต์ด้วยการสั่งงานผ่านมือด้วย Leap Motion (โบกมือเพื่อสั่งให้รถเคลือนที่)

Leap Motion & Image Rotate 360° / Panorama
ทดสอบการควบคุมการหมุนของรูปที่หน้าเว็บบราวเซอร์โดยใช้ Leap Motion

IOIO_COLOR_RECOGNITION_SENSOR
ทดสอบการตรวจสอบสีของพื้นผิวโดยแสดงผลที่มือถือ
Source Code : https://github.com/LookHin/IOIO_COLOR_RECOGNITION_SENSOR

IOIO_LED
ทดสอบการควบคุมอุปกรณ์อิเล็กทรอนิกส์ด้วยมือถือ
Source Code : https://github.com/LookHin/IOIO_LED

IOIO_Servo_Normal
ทดสอบการควบคุมเซอร์โวมอเตอร์ด้วยมือถือ
Source Code : https://github.com/LookHin/IOIO_Servo_Normal

IOIO_SERVO_360
ทดสอบการควบคุมเซอร์โวมอเตอร์แบบหมุนต่อเนื่องด้วยมือถือ
Source Code : https://github.com/LookHin/IOIO_SERVO_360

IOIO_STEP_MOTOR
ทดสอบการควบคุมการหมุนของสเต็ปมอเตอร์ด้วยมือถือ
Source Code : https://github.com/LookHin/IOIO_STEP_MOTOR

IOIO_ULTRASONIC_SENSOR
ทดสอบการวัดระยะทางด้วยคลื่นเสียงอัลตราโซนิคและแสดงผลระยะทางที่มือถือ
Source Code : https://github.com/LookHin/IOIO_ULTRASONIC_SENSOR

IOIO_PIR_MOTION_SENSOR
ทดสอบการตรวจสอบการเคลื่อนไหวจากการตรวจจับรังสีอินฟราเรด
Source Code : https://github.com/LookHin/IOIO_PIR_MOTION_SENSOR