มั่ว, ไม่ธรรมดา

แจ้งเตือน จาก thingspeak

ถ้าจะส่งเข้า Line

สมัคร Line

สมัคร IFTTT

สมัครใช้งาน ThingSpeak

ขอ token จาก Line อ่านนี่ ( ข้ามไปอ่านตอนท้ายเลย )

https://medium.com/@visitwnk/%E0%B9%83%E0%B8%AA%E0%B9%88%E0%B9%83%E0%B8%88-6-%E0%B9%80%E0%B8%95%E0%B8%A3%E0%B8%B5%E0%B8%A2%E0%B8%A1%E0%B8%84%E0%B8%A7%E0%B8%B2%E0%B8%A1%E0%B8%9E%E0%B8%A3%E0%B9%89%E0%B8%AD%E0%B8%A1%E0%B8%81%E0%B9%88%E0%B8%AD%E0%B8%99%E0%B8%81%E0%B8%B2%E0%B8%A3%E0%B9%83%E0%B8%8A%E0%B9%89-line-notify-70f7b50b6aa1

IFTTT สร้าง Applet เลือก web hook ประมาณ if [web hook] then [Line]

อ่านทำตามในหน้านี้ https://www.mathworks.com/help/thingspeak/use-ifttt-to-send-text-message-notification.html

ง่ายมั้ย ha ha ตามนั้นแหละขี้เกียจเขียน

โฆษณา
มั่ว, ไม่ธรรมดา

การเชื่อมต่อ LoRaWAN ของ CAT Telecom ด้วย Lopy4, Sodaq One, TTGO

ส่ิงที่ต้องรู้ก่อนทำคือ

  • ใช้ Arduino IDE เป็น พอจะติดตั้ง Library แบบ manual ได้
  • รู้จักภาษา C, C++, Python (บ้าง)
  • ใช้ Atom หรือ Visual Studio และติดตั้ง plugin เป็น
  • รู้จักโครงสร้างไฟล์ใน github, รู้ directory ที่เก็บข้อมูลต่าง ๆ บนเครื่องของเรา
  • ค้นหาข้อมูลเป็น, อ่าน forum ที่มีคำถาม คำตอบ (ตรงบ้าง ไม่ตรงบ้าง ใกล้เคียงก็มี) รู้เรื่อง
  • จากนั้นคือลองและลอง ทำไม่ได้ก็ไปนอน, ไปกิน, ไปดูหนัง, หลับ ตื่นมาแล้วก็ค่อยลองใหม่ ทำไปเรื่อย แต่เชื่อเถอะผมลองมาให้เยอะละ อ่านจากตรงนี้ก็งมเองต่อไปได้เกินพอแล้วล่ะ (นี่งมก่อนสงกรานต์และช่วงสงกรานต์อีก 6 วัน ทำจริง อยู่น่าจะสอง สามวัน ที่เหลือกิน นอน ดูหนัง เล่นกีฬา ฮ่า ฮ่า)

บอร์ดแรกที่ง่ายที่สุด Lopy4 (จากที่ลองมาทั้งหมด) ง่ายตรงที่ พอติดตั้ง Library & Software ที่เกี่ยวข้อง ที่จำเป็นทั้งหมด ลองกับโปรแกรมตัวอย่าง (ถ้าเข้าใจ python) ก็สามารถใช้งานได้เลย แทบไม่ต้องซ่อมอะไรมาก

สั่งซื้อบอร์ดได้ที่นี่ https://pycom.io/product/lopy4/  แต่แนะนำให้ซื้อเป็นแบบ multipack จะดีกว่า เพราะมีสายอากาศมาให้ด้วย พร้อมกับเลือก shield เสริมที่ต้องการใช้ แต่จะซื้อแยกก็มีให้เลือก

เอกสารคู่มือให้อ่านเริ่มจากตรงนี้ https://docs.pycom.io/ แนะนำให้อ่านไปตั้งแต่เริ่มเป็นลำดับ สิ่งที่ขาดไม่ได้คือ Software https://docs.pycom.io/gettingstarted/installation/ ซึ่งจำเป็นต้องติดตั้ง Pymakr สำหรับใช้กับ IDE ได้สองตัวคือ Atom และ Visual Studio Code ถ้าอ่านตามคู่มือไปเรื่อย ในนั้นจะบอกวิธีติดตั้ง ทำตามคู่มือไป (เดี๋ยวก็ได้)

ถ้าซื้อพวกบอร์ดขยาย เช่น Pytrack หรือบอร์ดอื่นควรมีการปรับปรุง firmware ด้วย อ่านได้จาก https://docs.pycom.io/pytrackpysense/installation/

สำหรับตัวอย่างการเชื่อมต่อกับ LoRaWAN ในแบบ ABP ใช้ตัวอย่างจากนี่ได้เลย https://docs.pycom.io/tutorials/lora/lorawan-abp.html โดยเปลี่ยนค่า dev_addr จากตัวเลข 00000005 เป็นค่า Device Address ที่เราได้จาก  CAT (https://loraiot.cattelecom.com/portal/login)

dev_addr = struct.unpack(">l", ubinascii.unhexlify('00000005'))[0]

เช่นเดียวกัน ก็แทนค่า nwk_swkey  เป็นค่า Network Session Key และ app_swkey เป็นค่า Application Session Key ที่ได้จาก CAT มาเช่นกัน

nwk_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')
app_swkey = ubinascii.unhexlify('2B7E151628AED2A6ABF7158809CF4F3C')

จากนั้นก็ทดสอบ Run โปรแกรมได้ทันที ดูว่ามี error อะไรหรือไม่ หรือ ดูที่ Logger ใน Portal ของ CAT ว่ามีข้อมูลส่งขึ้นไปหรือไม่ อาจเพิ่มคำสั่ง print(lora.stats()) เข้าในในโปรแกรมเพื่อดูค่าสถิติต่าง ๆ ปกติถ้าเชื่อมต่อหรือส่งข้อมูลได้ ค่า rssi หรือค่าอื่น ๆ ก็จะมีตัวเลข (ที่ไม่ใช่ 0) ขึ้นมา

บอร์ดถัดมาได้แก่ Sodaq One รุ่นที่เป็น US RN2903 https://shop.sodaq.com/sodaq-one-us-rn2903-v3.html ซึ่งจะเป็นรุ่นที่ใช้ในไทยได้ ที่ความถี่ 923Mhz จากนั้นก็ไปเริ่มต้นที่นี่ https://support.sodaq.com/sodaq-one/arduino-ide-setup/ ทำการติดตั้ง Library และ Software ที่เกี่ยวข้องให้เรียบร้อยก่อน จากนั้นก็เริ่มจากตัวอย่างนี้ https://support.sodaq.com/sodaq-one/loraone-lora-basic-sketch/  ตัวอย่างแรกจะเป็นการสื่อสารผ่านช่องทางอนุกรมโดยการส่งคำสั่งไปยัง Chip RN2903 (ชุดคำสั่งดูได้จากที่นี่ http://ww1.microchip.com/downloads/en/DeviceDoc/40001784B.pdf)

แต่ ก่อนอื่นใด หลังจากที่ลองแล้วลองอีก ลองแล้วลองเล่า กับโปรแกรมตัวอย่างสารพัดตัวอย่าง ก็เชื่อมต่อใช้งานไม่ได้ ส่งข้อมูลก็ไม่ได้ หรือเชื่อมต่อได้ (มันขึ้นว่าได้) แต่จริงแล้วก็ยังไม่ได้ เกิดอะไรขึ้นส่ิงแรกที่ต้องแก้ไขคือทำการ update firmware บอร์ดให้รองรับการใช้งานความถี่ในบ้านเราคือ 923 MHz โดยการไป download โปรแกรมจากที่นี่ https://github.com/SodaqMoja/RN2483FirmwareUpdater จากนั้นทำการแก้ไขไฟล์ HexFileImage.h เอาเครื่องหมาย // ออกในบรรทัดที่ //#define HEXFILE_RN2903_AS923_105 เป็น #define HEXFILE_RN2903_AS923_105 จากนั้น save แล้ว upload โปรแกรม RN2483FirmwareUpdater.ino เพื่อทำการ update firmware รอจนโปรแกรม boot และ ตรวจสอบไฟล์เรียบร้อยก็กด c เพื่อ update จากนั้นรอจนบอร์ด restart ใหม่

ลอง upload โปรแกรมตัวอย่างอันแรก

/*
 * Compatible with:
 * SODAQ MBILI
 * SODAQ Autonomo
 * SODAQ ONE
 * SODAQ ONE BETA
 * SODAQ EXPLORER
 */

#include "Arduino.h"

#if defined(ARDUINO_AVR_SODAQ_MBILI)
#define debugSerial Serial 
#define loraSerial Serial1

#elif defined(ARDUINO_SODAQ_AUTONOMO) || defined(ARDUINO_SODAQ_ONE) || defined(ARDUINO_SODAQ_ONE_BETA)
#define debugSerial SerialUSB 
#define loraSerial Serial1

#elif defined(ARDUINO_SODAQ_EXPLORER)
#define debugSerial SerialUSB
#define loraSerial Serial2

#else
// please select a sodaq board
#endif

void setup() {
  // Enable LoRa module
  #if defined(ARDUINO_SODAQ_AUTONOMO)
  pinMode(BEE_VCC, OUTPUT);
  digitalWrite(BEE_VCC, HIGH); //set input power BEE high
  #elif defined(ARDUINO_AVR_SODAQ_MBILI)
  pinMode(20, OUTPUT);
  digitalWrite(20, HIGH); //set input power BEE high
  #endif

  // Hard reset the RN module
  #if defined(LORA_RESET)
  pinMode(LORA_RESET, OUTPUT);
  digitalWrite(LORA_RESET, LOW);
  delay(100);
  digitalWrite(LORA_RESET, HIGH);
  delay(100);
  #endif

  while ((!debugSerial) && (millis() < 10000)){
    // wait 10 seconds for serial monitor
  }
  
  debugSerial.begin(57600);
  loraSerial.begin(57600); 
  
  debugSerial.println("Please send command");
}

void loop() {  

    //send and receive data with serial
     if (debugSerial.available()){
      //debugSerial.print("SEND:    ");
      while (debugSerial.available()) {
        uint8_t inChar = debugSerial.read();
        //debugSerial.write(inChar);
        loraSerial.write(inChar);
      }
     }

     if (loraSerial.available()){
      //debugSerial.print("RECEIVE: ");
      while (loraSerial.available()) {
        uint8_t inChar = loraSerial.read();
        debugSerial.write(inChar);
      }
     }
}

พอโปรแกรมทำงานก็เปิด Serial Monitor ของ Arduino IDE ขึ้นมาแล้วพิมพ์คำสั่งต่าง ๆ ลงไปเช่น

sys reset
mac set nwkskey XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX //แทนค่าด้วย network session key
mac set appskey XXXXXX2B7E15D2A6XXXXXXXXXXXXXXXX //แทนค่าด้วย application session key
mac set devaddr XXXXXXXX //device address 
mac set adr off
mac set ar off
mac set pwridx 5
mac save
mac join abp
mac get ch status 0

เมื่อจะส่งข้อมูลก็ใช้คำสั่ง mac tx cnf 1 9999  (ส่งข้อมูลแบบมีการยืนยันไป port 1 ข้อมูลคือ 9999)

ซึ่งเราสามารถใช้คำสั่งเหล่านี้สั่งผ่านทางช่องสื่อสารอนุกรม (Serial1) ได้ (SerialUSB เป็นช่องสื่อสารอนุกรมระหว่างบอร์ดกับคอมพิวเตอร์ของเรา ที่ใช้สำหรับ monitor หรือ upload โปรแกรม) แต่ ทาง Sodaq ได้ทำ Library มาให้ใช้เพื่อที่จะได้รวดเร็วขึ้นในการใช้งาน โดยสามารถติดตั้งได้จาก Arduino IDE หรือ download จากที่นี่ https://github.com/SodaqMoja/Sodaq_RN2483 จากนั้นก็ทดลองโปรแกรมตัวอย่าง https://support.sodaq.com/sodaq-one/loraone-lora-basic-sketch/

Simple LoRa sketch

/*
 * Compatible with:
 * SODAQ MBILI
 * SODAQ Autonomo
 * SODAQ ONE
 * SODAQ ONE BETA
 * SODAQ EXPLORER
 */

#include "Arduino.h"
#include <Sodaq_RN2483.h>

#define debugSerial SERIAL_PORT_MONITOR

#if defined(ARDUINO_AVR_SODAQ_MBILI)
#define loraSerial Serial1
#define BEE_VCC 20

#elif defined(ARDUINO_SODAQ_AUTONOMO) || defined(ARDUINO_SODAQ_ONE) || defined(ARDUINO_SODAQ_ONE_BETA)
#define loraSerial Serial1

#elif defined(ARDUINO_SODAQ_EXPLORER)
#define loraSerial Serial2

#else
// please select a sodaq board
debugSerial.println("Please select a sodaq board!!");
#endif

// ABP
const uint8_t devAddr[4] = { 0x00, 0x00, 0x00, 0x00 };
const uint8_t appSKey[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
const uint8_t nwkSKey[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

// OTAA
uint8_t DevEUI[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t AppEUI[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t AppKey[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

void setupLoRaABP(){  
  if (LoRaBee.initABP(loraSerial, devAddr, appSKey, nwkSKey, false))
  {
    debugSerial.println("Communication to LoRaBEE successful.");
  }
  else
  {
    debugSerial.println("Communication to LoRaBEE failed!");
  }
}

void setupLoRaOTAA(){
  if (LoRaBee.initOTA(loraSerial, DevEUI, AppEUI, AppKey, false))
  {
    debugSerial.println("Communication to LoRaBEE successful.");
  }
  else
  {
    debugSerial.println("OTAA Setup failed!");
  }
}

void setup() {
  //Power up the LoRaBEE
  #if defined(ARDUINO_AVR_SODAQ_MBILI) || defined(ARDUINO_SODAQ_AUTONOMO)
  pinMode(BEE_VCC, OUTPUT);
  digitalWrite(BEE_VCC, HIGH);
  #endif
  delay(3000);

  while ((!SerialUSB) && (millis() < 10000)){
    // Wait 10 seconds for the Serial Monitor
  }

  //Set baud rate
  debugSerial.begin(57600);
  loraSerial.begin(LoRaBee.getDefaultBaudRate());

  // Debug output from LoRaBee
  // LoRaBee.setDiag(debugSerial); // optional

  //connect to the LoRa Network
  setupLoRa();
}

void setupLoRa(){
  // ABP
//  setupLoRaABP();
  // OTAA
  setupLoRaOTAA();
  LoRaBee.setSpreadingFactor(9);
}

void sendPacket(String packet){
  switch (LoRaBee.send(1, (uint8_t*)packet.c_str(), packet.length()))
    {
    case NoError:
      debugSerial.println("Successful transmission.");
      break;
    case NoResponse:
      debugSerial.println("There was no response from the device.");
      setupLoRa();
      break;
    case Timeout:
      debugSerial.println("Connection timed-out. Check your serial connection to the device! Sleeping for 20sec.");
      delay(20000);
      break;
    case PayloadSizeError:
      debugSerial.println("The size of the payload is greater than allowed. Transmission failed!");
      break;
    case InternalError:
      debugSerial.println("Oh No! This shouldn't happen. Something is really wrong! Try restarting the device!\r\nThe network connection will reset.");
      setupLoRa();
      break;
    case Busy:
      debugSerial.println("The device is busy. Sleeping for 10 extra seconds.");
      delay(10000);
      break;
    case NetworkFatalError:
      debugSerial.println("There is a non-recoverable error with the network connection. You should re-connect.\r\nThe network connection will reset.");
      setupLoRa();
      break;
    case NotConnected:
      debugSerial.println("The device is not connected to the network. Please connect to the network before attempting to send data.\r\nThe network connection will reset.");
      setupLoRa();
      break;
    case NoAcknowledgment:
      debugSerial.println("There was no acknowledgment sent back!");
      // When you this message you are probaly out of range of the network.
      break;
    default:
      break;
    }
}

void loop() {
  // put your main code here, to run repeatedly:
  String packet = "SODAQ";
  sendPacket(packet);

  delay(5000);
}

โดยให้เปลี่ยนค่า devAddr, appSKey, nwkSKey เป็น Device Address, Application Session Key, Network Session Key ที่ได้จาก CAT ก่อน

จากนั้นการทดลองโปรแกรมตัวอย่างต่อ ซึ่งก็พบว่ายังติดปัญหาอีก สิ่งที่ได้ทดลองต่อคือ เข้าไปแก้ไขในไฟล์ Sodaq_RN2483.cpp โดย uncomment บรรทัด #define DEBUG เอาเครื่องหมาย // ออก หรือ เพิ่มคำสั่งบรรทัดนี้เข้าไปด้านบน ตามรูป

เพื่อ debug ดูว่าเกิดอะไรขึ้นบ้าง ก็จะพบว่าเมื่อจะมีการเชื่อมต่อ LoRa จะมีการเรียก ตั้งค่า Frequency Sub-Band (FSB) ใน function setFsbChannels ซึ่งจากที่ดูปรากฏว่ามันจะตั้งค่าได้แค่สองช่องสัญญาณ คือ ch0, ch1 ซึ่งเข้าใจเองว่าในบ้านเราคงมีการให้บริการอยู่แค่สองช่องความถี่นี้ (มั้ง) คือ 923.20 MHz, 923.40 MHz ที่เหลือเมื่อตั้งค่าช่องสัญญาณไม่ได้ function setFsbChannels ก็จะ return ค่าเป็น false ทำให้ขึ้นว่าไม่สามารถเชื่อมต่อได้ ดังนั้นก็บังคับให้มันวนรอบทำแค่สองช่องสัญญาณพอ (เพราะเคยทดสอบ setFsbChannels โดยการส่งค่าไปให้แล้ว ปรากฏว่าโปรแกรมพัง เลยไม่ทำแบบนั้นละ)

 

// Enables all the channels that belong to the given Frequency Sub-Band (FSB)
// and disables the rest.
// fsb is [1, 8] or 0 to enable all channels.
// Returns true if all channels were set successfully.
bool Sodaq_RN2483::setFsbChannels(uint8_t fsb)
{
    debugPrintLn("[setFsbChannels]");

    uint8_t first125kHzChannel = fsb > 0 ? (fsb - 1) * 8 : 0;
    uint8_t last125kHzChannel = fsb > 0 ? first125kHzChannel + 7 : 71;
    uint8_t fsb500kHzChannel = fsb + 63;

    bool allOk = true;

    for (uint8_t i = 0; i < 2; i++) { // 72 ch <---- บรรทัดนี้
        print(STR_CMD_SET_CHANNEL_STATUS); 
        print(i); print(" "); 
        print(BOOL_TO_ONOFF(((i == fsb500kHzChannel) || (i >= first125kHzChannel && i <= last125kHzChannel))));
        println();

        allOk &= expectOK();
    }

    return allOk;
}

ตรง for loop ก็เปลี่ยนค่าจาก 72 มาเป็น 2 เพื่อให้วนรอบแค่สองช่องสัญญาณ นอกจากนี้ยังมีใน file Sodaq_RN2483.h แก้บรรทัด #define DEFAULT_FSB 1 <— กำหนดค่าเป็น 1

*** อยากรู้ว่ามันจะใช้ได้กี่ช่องสัญญาณต้องใช้คำสั่งตั้งค่าความถี่ mac set ch freq 2 922000000 และ mac set ch status 2 on (ตั้งค่าความถี่ ch. 2) ว่าช่องนั้นใช้ได้หรือไม่ล่าสุดที่ลองตอนนี้ใช้ได้ 3 ch.

ตารางความถี่ (MHz)

LoRa CAT Frequency

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

โดยฝั่งของ Network Server ให้เราตั้งค่า payload ตามที่เราส่งขึ้นไปคือมีให้เลือก Raw (byte), ASCII String, Cayenne LPP ในกรณีตัวอย่าง เป็นการส่งข้อความ “Hello, world!” หรือ “SODAQ” ซึ่งเป็นแบบ ASCII String เพื่อให้ Logger ถอดรหัสข้อมูลได้ถูกต้อง ก็ต้องตั้งให้ตรงกัน

ว่าจะต่อ TTGO แต่ หลังจากเขียน blog บน Safari แล้ว save, publish แล้วพัง ข้อมูลหาย ดีว่า wordpress save draft ไว้บ้างเลยไม่ต้องพิมพ์ใหม่ทั้งหมด หมดเวลา เดี๋ยวค่อยมาต่ออีกที

April 17, 2019 at 4:58pm

ต่อกันด้วย TTGO board

บอร์ดนี้ได้จาก aliexpress (มีหลายเจ้าเลือกเอาตามใจชอบ) แต่สายอากาศที่ได้มาเล็กไปนิด (6 cm) เมื่อเทียบกับสายอากาศของ LoPy  (20 cm) น่าจะมีผลต่อการขยายสัญญาณพอสมควรเมื่อเทียบกัน  รุ่นของบอร์ดก็มีหลายรุ่น ตำแหน่งขาก็จะไม่เหมือนกันรายละเอียดดูจาก forum https://www.thethingsnetwork.org/forum/t/big-esp32-sx127x-topic-part-3/18436 

ที่ทดลองใช้เป็น TTGO version 1

// Pin mapping
// Adapted for Feather M0 per p.10 of [feather]
// change to TTGO ESP32 LoRa v1
const lmic_pinmap lmic_pins = {
.nss = 18, // chip select on feather (rf95module) CS
.rxtx = LMIC_UNUSED_PIN,
.rst = 14, // reset pin
.dio = {/*dio0*/ 26, /*dio1*/ 33, /*dio2*/ LMIC_UNUSED_PIN}, // assumes external jumpers [feather_lora_jumper]
// DIO1 is on JP1-1: is io1 - we connect to GPO6
// DIO1 is on JP5-3: is D2 - we connect to GPO5
};

สำหรับโปรแกรมที่ใช้ทดสอบก็จะใช้ตัวอย่างจาก นี่ https://github.com/matthijskooijman/arduino-lmic/blob/master/examples/ttn-abp/ttn-abp.ino 

ส่วน Library ที่ใช้จะเป็น LMIC Library ที่ปรับแต่งมาแล้ว (เขาว่าแบบนั้นนะ) อ่านรายละเอียดได้จากที่นี่ http://binahead.com/web/2018/02/21/controller-lorawanbycat-test/

หรือ download library ได้จากนี่ https://github.com/kaebmoo/LoRa-Example/tree/master/LMIC-Arduino-AS923-upper

แก้ไขในตัวอย่าง เปลี่ยนค่าโดยการกำหนด LoRaWAN Config ให้เป็นการใช้ความถี่ในไทย

// LoRaWAN Config
#define CFG_as923

จากนั้นก็กำหนดค่าต่าง ๆ สำหรับการเชื่อมต่อ เช่น network session key, application session key, device address (กรณีเชื่อมต่อแบบ ABP)

แล้วเพิ่ม code นี้ เข้าไปสำหรับการกำหนดความถี่ ในการเชื่อมต่อ

    #elif defined(CFG_as923)

LMIC_setupChannel(0, 923200000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
LMIC_setupChannel(1, 923400000, DR_RANGE_MAP(DR_SF12, DR_SF7B), BAND_CENTI); // g-band
LMIC_setupChannel(2, 922000000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
LMIC_setupChannel(3, 922200000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
LMIC_setupChannel(4, 922400000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
LMIC_setupChannel(5, 922600000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
LMIC_setupChannel(6, 922800000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
LMIC_setupChannel(7, 923000000, DR_RANGE_MAP(DR_SF12, DR_SF7), BAND_CENTI); // g-band
LMIC_setupChannel(8, 924800000, DR_RANGE_MAP(DR_FSK, DR_FSK), BAND_MILLI); // g2-band
#endif

เนื่องจากเราใช้ช่องสัญญาณได้แค่ 2-3 ช่อง ดังนั้นเพื่อไม่ให้มันไปวน loop ส่งในความถี่ช่องอื่นก็ทำการ disable ช่องอื่นด้วยคำสั่ง
// disable channel 2 - channel 8.
for (int i = 3; i < 9; i++) {
LMIC_disableChannel(i);
}

ตัวอย่าง https://github.com/kaebmoo/LoRa-Example/blob/master/PMS5003_ESP32.ino

การส่งข้อมูลไม่ว่าจะเป็นบอร์ด Sodaq, TTGO ด้วยข้อจำกัดของ LoRa ซึ่งส่งข้อมูลได้ด้วยขนาดที่จำกัด < 60 byte ดังนั้นการที่จะส่งข้อมูล string พวก JSON จะมีข้อจำกัดมากอาจจะบรรจุข้อมูลที่ส่งได้ไม่พอดังนั้นจึงจำเป็นต้องส่งข้อมูลแบบ byte หรือ binary data format (encode) แล้วมา decode ออกที่ปลายทาง ซึ่งอาจจะทำรูปแบบขึ้นมาเองก็ได้แต่ที่นิยมใช้กัน ชาวโลกก็มักจะใช้รูปแบบ Cayenne LPP ซึ่งมี Libary มาให้เลือกใช้แล้ว เช่น https://www.thethingsnetwork.org/docs/devices/arduino/api/cayennelpp.html

รายละเอียดของ Cayenne Low Power Payload อ่านได้จากนี่ https://mydevices.com/cayenne/docs/lora/#lora-cayenne-low-power-payload

ซึ่งข้อดีของการส่งข้อมูลแบบนี้คือ เราสามารถส่งข้อมูลได้เกือบครบเท่าที่มีเบื้องต้น เช่น อุณหภูมิ ความชื้น ตำแหน่ง (GPS) แสงสว่าง digital input/output ได้ในขนาดข้อมูลรวมแล้วไม่เกิน 50-60 byte โดยรูปแบบของค่า หรือข้อจำกัดของข้อมูล ประเภทข้อมูลสามารถศึกษาได้จากข้อมูลที่กล่าวไปแล้ว

ตัวอย่างคำสั่งการเตรียมข้อมูล ให้เป็น Cayenne LPP

  CayenneLPP lpp(60); //ประกาศตัวแปร class

lpp.reset();
//ไม่มี field PM25 ก็ใช้ field digital input แทน
lpp.addDigitalInput(1, averagePM25);
lpp.addDigitalInput(1, averagePM10);
lpp.addDigitalInput(1, maximum25);
lpp.addDigitalInput(1, minimum25);

lpp.addTemperature(1, temperature);
lpp.addRelativeHumidity(1, humidity);
lpp.addBarometricPressure(1, pressure);
lpp.addGPS(1, 13.884292, 100.569145, 1);

เมื่อจะส่งข้อมูล
LMIC_setTxData2(1, lpp.getBuffer(), lpp.getSize(), 1);

สำหรับการส่งข้อมูลนั้นจะมี 2 แบบที่ unconfirm กับ แบบ confirm การส่งแบบ unconfirm ก็คือส่งข้อมูลออกแบบแล้วจบ (รับได้ รับไม่ได้ ไม่สนใจ) ซึ่งจากทดสอบถ้าอยู่ในที่สัญญาณอ่อนโอกาสส่งไปแล้วโครงข่าย LoRaWAN จะรับได้ค่อนข้างต่ำ (RSSI ~ -100db) ทำให้บางครั้งไม่ได้รับข้อมูล เช่น ถ้าส่งทุก 5 นาที ใน 1 ชั่วโมงควรจะได้ 12 ครั้ง ก็อาจจะได้ไม่ถึง ข้อมูลอาจหายไปเป็นบางช่วง เลยเลือกส่งด้วยแบบ confirm ตัวอย่างคำสั่งของ Sodaq LoRaBee.sendReqAck(1, lpp.getBuffer(), lpp.getSize(), 10) โดย 10 คือค่าที่ให้ส่งซ้ำ ถ้าส่งแล้วไม่มี acknowledge กลับมาก็จะวนส่งไป 10 ครั้ง เท่าที่ debug ทดสอบดูถึงแม้ว่าจะส่งซ้ำไปจนจบโดยไม่มี acknowledge กลับมาก็ตามแต่ LoRaWAN gate ก็ได้รับข้อมูล กรณี TTGO LMIC_setTxData2(1, lpp.getBuffer(), lpp.getSize(), 1); ก็กำหนด argument สุดท้ายเป็น 1 จะหมายถึงการส่งแบบ confirm กรณีที่สัญญาณค่อนข้างดีเช่น RSSI อยู่ที่ -30 ถึง -50 db การส่งแบบ unconfirm ก็สามารถทำได้โดยไม่มีปัญหาของการรับข้อมูลไม่ได้

ตัวอย่างการใช้ Sodaq One GPS เก็บข้อมูล Drive test โดยส่งข้อมูลทุก 1 นาที

สำหรับแบตเตอรี่ขนาด 1200 mAh ที่ใช้กับ Sodaq One โดยส่งข้อมูลทุก 1 นาที (ไม่มีการ sleep) ใช้ได้ประมาณ 24 ชั่วโมง

 

 

 

 

 

มั่ว, ไม่ธรรมดา

ระบบเกษตรความแม่นยำสูง

ระบบเกษตรความแม่นยำสูงประกอบด้วย

เครื่องมือวัด

  1. เครื่องวัดอุณหภูมิ และความชื้นสัมพัทธ์ในอากาศ
  2. เครื่องวัดความชื้นในดิน
  3. เครื่องวัดแสง

ทั้งนี้อาจมีเครื่องมือวัดที่จำเป็นอื่น ได้อีก เช่น การวัดค่า pH, CO2, ความกดอากาศ, ความเร็วลม, การวัดความถี่ของแสงที่เหมาะกับพืช, วัดค่าทางไฟฟ้าของปุ๋ยแบบน้ำ, ปริมาณน้ำ, วัดกำลังงานไฟฟ้า ซึ่งเราสามารถเลือกใช้ให้เหมาะกับงานเกษตรเป็นกรณีไป

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

เครื่องปิด เปิด อุปกรณ์ไฟฟ้า

  1. รีเลย์ (Relay)

ทำหน้าที่เป็นอุปกรณ์ปิด เปิด แบบอัตโนมัติที่มีคอมพิวเตอร์ขนาดเล็กควบคุม โดยมีความสามารถคือ การตั้งเวลา เปิด ปิด ตามที่ผู้ใช้ต้องการ โดยมีการตั้งเวลาได้ตั้งแต่ 1-9 ครั้งต่อวันหรือมากกว่า และมีรูปแบบการตั้งเวลาแบบอื่นได้ด้วย เช่น ให้เปิด ปิดสลับกัน ตามจำนวนและเวลาที่ผู้ใช้กำหนด นอกจากนี้ยังสามารถทำงานร่วมกับเงื่อนไขที่วัดได้จากเครื่องมือวัดด้วย ยกตัวอย่างเช่น เมื่อวัดความชื้นในดินได้สูง Relay หรือ switch ก็จะไม่ต้องทำงานในการเปิดปั๊มน้ำ หรือเมื่อวัดค่าอุณหภูมิได้สูงกว่าที่กำหนดอุปกรณ์สามารถเปิดเองได้โดยอัตโนมัติเพื่อควบคุมอุปกรณ์เช่น ม่านบังแสง พัดลม เป็นต้น

ระบบแอพพลิเคชั่น

  1. เก็บข้อมูล และแสดงผลข้อมูล
  2. ระบบประมวลผลตามเงื่อนไข

มีหน้าที่ในการรับข้อมูลจากเครื่องมือวัด พร้อมทั้งทำหน้าที่แสดงผลในรูปแบบกราฟ ตาราง นอกจากนี้ยังทำหน้าทีประมวลผลเพื่อทำตามเงื่อนไขที่ผู้ใช้กำหนด เช่น เมื่อค่าอุณหภูมิที่วัดได้มีค่ามากกว่าหรือน้อยกว่าที่กำหนดก็สั่งให้อุปกรณ์ (Relay) เปิดให้เครื่องใช้ไฟฟ้าทำงาน เช่น ปั๊มน้ำ, พัดลม, เครื่องทำความร้อนหรือความเย็น, ฯลฯ โดยระบบนี้โดยทั่วไปจะประกอบด้วยระบบรับส่งข้อมูล (MQTT, REST API) ระบบเก็บข้อมูล (PostgresSQL, MySQL Database, NoSQL Cassandra) ระบบทำงานตามเงื่อนไข Node-RED เป็นต้น

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

ระบบติดต่อกับผู้ใช้ด้วยโทรศัพท์

ได้แก่แอพพลิเคชั่นที่ให้ผู้ใช้งานสามารถดูสถานะการทำงานหรือข้อมูลระบบ พร้อมทั้งสามารถสั่งการทำงานของระบบหรือตั้งค่าการทำงานได้

 

เมื่อได้ค่าที่เราเก็บและทำการวิเคราะห์แล้วเราก็จะสามารถตัดสินใจในการทำงานหรือสั่งการให้ระบบทำงานสอดคล้องไปกับสภาวะแวดล้อมที่เกิดขึ้น รวมถึงควบคุมสภาวะแวดล้อมให้เหมาะสมกับพืชนั้น เช่น ทราบว่าควรจะให้น้ำพืชตอนไหนถึงจะเหมาะสมโดยดูจากกราฟค่าอุณภูมิและความชื้นสัมพัทธ์ในอากาศที่เปรียบเทียบกับช่วงเวลา ทราบว่าความชื้นในดินมีความเหมาะสมกับพืชที่ปลูกหรือไม่ ทราบว่าช่วงไหนของวันที่ควรมีการพรางหรือลดแสงสว่างของโรงเรือนเพื่อไม่ให้อุณหภูมิของโรงเรือนสูงเกินไป นี่จึงเป็นที่มาของคำว่าเกษตรความแม่นยำ คือการใช้การวัดวิเคราะห์และควบคุม ซึ่งจะทำให้ผลผลิตมีคุณภาพ ได้จำนวนผลผลิตที่เหมาะสม และประหยัดค่าใช้จ่ายได้ในระยะยาว นอกจากนี้แล้วในปัจจุบันระบบที่เรียกว่า Machine Learning (ML) หรือ Artificial intelligence (AI) หรือ ปัญญาประดิษฐ์ ที่พัฒนาขึ้นด้วยซอฟต์แวร์คอมพิวเตอร์ ก็ยังสามารถมาช่วยในการวิเคราะห์สั่งการ(ทำงานแทนมนุษย์)ได้อย่างอัตโนมัติอีกด้วย

ขอบคุณเจ้าของสถานที่และผู้ใช้งานระบบได้แก่ ศรีเชียงใหม่อุตสาหกรรม

มั่ว, ไม่ธรรมดา

energy meter

ตัวอย่างการอ่านค่าจากมิเตอร์ไฟฟ้า ยี่ห้อนี้ http://www.eastrongroup.com/products/59.html

ผ่าน modbus 485 https://www.arduinoall.com/product/1205/ttl-to-rs485-level-serial-uart-module

ติดตั้ง library นี้ก่อน https://github.com/reaper7/SDM_Energy_Meter

ตัวอย่างนี้ อ่านข้อมูลจากมิเตอร์ไฟฟ้าแล้วส่งข้อมูลขึ้น thingspeak.com

/*
 * 
 * 
 * https://github.com/reaper7/SDM_Energy_Meter
 * 
 */


#include <SDM.h>
#include <ESP8266WiFi.h>          //https://github.com/esp8266/Arduino
#include <ThingSpeak.h>
#include <BlynkSimpleEsp8266.h>


// SDM<9600> sdm;
SDM sdm(Serial, 9600, NOT_A_PIN, SERIAL_8N1, false);

// ThingSpeak information
char thingSpeakAddress[] = "api.thingspeak.com";
unsigned long channelID = 123456;
char *readAPIKey = "xxxxxxxxxxxxxxxx";
char *writeAPIKey = "xxxxxxxxxxxxxxxx";

BlynkTimer blynkTimer;

WiFiClient client;

float tmpVol = NAN;
float tmpAmp = NAN;
float tmpWat = NAN;
float tmpFre = NAN;
float tmpEne = NAN;
int readCount = 0;
float voltage = 0.0;
float amp = 0.0;
float watt = 0.0;
float freq = 0.0;
float energy = 0.0;


void setup() {
  pinMode(BUILTIN_LED, OUTPUT);
  digitalWrite(BUILTIN_LED, HIGH);

  
  sdm.begin();
  
  WiFi.begin("XXX", "12345678");
  Serial.print("Connecting");
  Serial.println();

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    /*
    if ( digitalRead(TRIGGER_PIN) == LOW ) {
      ondemandWiFi();
    }
    */
  }
  Serial.println();
  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP()); 
  
  ThingSpeak.begin( client );
  blynkTimer.setInterval(60000L, sendThingSpeak);                   // send data to thingspeak
  blynkTimer.setInterval(5000L, readMeterData);
}

void loop() {
  blynkTimer.run();
  
}

void readMeterData()
{
  tmpVol = sdm.readVal(SDM220T_VOLTAGE);
  delay(50);
  tmpAmp = sdm.readVal(SDM230_CURRENT);
  delay(50);
  tmpWat = sdm.readVal(SDM230_POWER);
  delay(50);
  tmpFre = sdm.readVal(SDM230_FREQUENCY);
  delay(50);
  tmpEne = sdm.readVal(SDM230_TOTAL_ACTIVE_ENERGY);

  if (!isnan(tmpVol)) {
    digitalWrite(BUILTIN_LED, LOW);
    Serial.println();
    Serial.print("Voltage:   ");
    Serial.print(tmpVol);
    Serial.println("V");

    Serial.print("Current:   ");
    Serial.print(tmpAmp);
    Serial.println("A");

    Serial.print("Power:     ");
    Serial.print(tmpWat);
    Serial.println("W");

    Serial.print("Frequency: ");
    Serial.print(tmpFre);
    Serial.println("Hz");

    Serial.print("Total Energy: ");
    Serial.print(tmpEne);
    Serial.println("kWh");
    voltage += tmpVol;
    amp += tmpAmp;
    watt += tmpWat;
    freq = tmpFre;
    energy = tmpEne;
    readCount++;
  }
  delay(500);
  digitalWrite(BUILTIN_LED, HIGH);
  delay(500);
  digitalWrite(BUILTIN_LED, LOW);
}


void sendThingSpeak()
{
  if(readCount != 0) {
    voltage = voltage / readCount;
    amp = amp / readCount;
    watt = watt / readCount;    
  }

    Serial.println();
    Serial.print("Voltage:   ");
    Serial.print(voltage);
    Serial.println("V");

    Serial.print("Current:   ");
    Serial.print(amp);
    Serial.println("A");

    Serial.print("Power:     ");
    Serial.print(watt);
    Serial.println("W");

    Serial.print("Frequency: ");
    Serial.print(freq);
    Serial.println("Hz");

    Serial.print("Total Energy: ");
    Serial.print(energy);
    Serial.println("kWh");
    
  

  
    ThingSpeak.setField( 1, voltage );
    ThingSpeak.setField( 2, amp );
    ThingSpeak.setField( 3, watt);
    ThingSpeak.setField( 4, freq );
    ThingSpeak.setField( 5, energy);
  
    int writeSuccess = ThingSpeak.writeFields( channelID, writeAPIKey );
    Serial.println(writeSuccess);
    Serial.println();

    voltage = 0;
    amp = 0;
    watt = 0;
    readCount = 0;
}
ธรรมชาติ, ไม่ธรรมดา

การกระทบของอารมณ์

มีเรื่องจะเล่าให้ฟัง (อ่าน)

เล่าจากประสบการณ์ตัวเอง

บางคนอาจจะมี อาจจะเป็น อาจจะเคย ก็ว่ากันไป

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

ทำไปนานนาน จนบางที คนจะมองว่า ไอ้นี่มันไม่มีความรู้สึก (รัก โลภ โกรธ หลง ฯลฯ) มันไม่เคย …(รู้สึก) เปล่าเลย มันยังรู้สึก แต่ ถ้ามีสติดี มันสลัดออกไปได้เร็ว สลัดคือ ไม่ใช่การปฏิเสธมัน หรือไม่ใช่การโยนทิ้ง ไม่ใช่การต่อต้านมัน แต่มันก็การยอมรับแบบหนึ่งก็ได้ (ศิโรราบ) หรือการวางความรู้สึกเป็นกลาง แล้วไอ้ความรู้สึกนั้นมันก็หายไปของมันเอง

บ้างเขาก็เปรียบเหมือนโยนอะไรลงไปบนผิวน้ำ มันเกิดการกระทบ แต่ มันจะกระเพื่อมไหว รุนแรง นาน หรือไม่ นั่นมันอีกเรื่อง บ้างเกิดการกระทบ แต่ ไม่มีการไหวกระเพื่อมเลย หรือเกิดการกระเพื่อม ซ้ำแล้ว ซ้ำเล่า เปรียบได้ แบบนั้น

บางที ที่ฝึกบ่อย ฝึกได้ดี เวลาดูหนัง ดูละคร ก็รู้สึกเฉย ไป (คล้ายจะไม่สนุก) มันไม่เหมือนที่เราปล่อยให้มันรับอารมณ์แล้วรู้สึกคล้อยตามไปกับมัน (กระเพื่อม) แต่มันก็ยังกระทบ กระเพื่อมอยู่ (ยังไม่บรรลุนี่) แค่มันรู้สึกตัวดี บางครั้งก็ยอมปล่อยให้มัน อยู่ในวังวนไปบ้าง ฮ่า ฮ่า

ใครจะทำ จะหัด จะไม่ทำ นั่นก็แล้วแต่ ทำเองก็รู้ ไม่ทำก็คงไม่ได้ผิดอะไร (แต่คนที่เคยทำแล้ว ที่รู้แล้วพ้นไปแล้ว ก็มักจะเตือนว่า เสียดายเวลา เสียดายโอกาสนะ ถ้าไม่หัด ไม่ฝึก)

ข้อดีคือ เวลารับรู้เรื่องดีดี เช่น ดีใจ รัก ชอบ รสสัมผัส ที่ดี มันจะรู้สึกได้ดีมากมาก รับการสัมผัส มีการรับรู้ได้บริสุทธิ์ ไม่ว่าจะกิน (รู้รส) การฟัง การดู การเกิดความรู้สึกข้างใน

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

และมันจะมี เมตตา เกิดขึ้น มาแทน เราอาจจะเกลียดศัตรู แต่ สุดท้าย ก็มีเมตตา ต่อเขา เมื่อถึงที่สุด หรือเราก็ไม่ต้องเกลียด และปฏิบัติต่อกัน ตามเหตุ ตามผล ที่พึงมี หรือ ทำไปตามเหตุ ว่าต้องทำอะไร ไม่ต้องทำอะไร อะไรที่ต้องทำไปตามที่เหมาะที่ควร

 

วันที่  28 ตุลาคม พ.ศ. 2561

เวลา 12:40:28 น.

บนเตียงนอน ที่บ้านตรอกจันทน์

 

มั่ว, ไม่ธรรมดา

การบริหารจัดการวิกฤตการณ์น้ำท่วมด้วยเครื่องมือจาก Google

ตอนที่สอง ต่อจากตอนแรก https://kaebmoo.wordpress.com/2011/10/18/google-crisis-response/

Google Crisis Response

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

  1. อินเทอร์เน็ต แน่นอนไม่มีไม่ได้ ไม่มีแล้วจะใช้ Google ได้อย่างไร เอะ ก็น้ำมันท่วมระบบสื่อสารก็เสียหาย ไฟฟ้าไม่รู้จะมีหรือไม่ แล้วจะเอาอินเทอร์เน็ตจากไหนละวะ พักเรื่องนี้ไว้ก่อนมาดูข้อต่อไป
  2. คอมพิวเตอร์ จะเป็น PC เป็น Mac เป็นกระดานชนวนอิเล็กทรอนิกส์ ก็ Tablet นั่นแหละ หรือแม้แต่โทรศัพท์ ขอให้มันเปิด web ได้ก็พอ แต่ไอ้สองอย่างหลังนี่ อาจจะมีข้อจำกัด
  3. ใช้อินเทอร์เน็ตเป็น และมีความรู้ทางด้านอินเทอร์เน็ตบ้าง ถ้าบอกว่า facebook คืออะไร twitter คืออะไร google maps ใช้อย่างไร แบบนี้สงสัยจะไม่รอด
  4. ความรู้ทางวิชาชีพ อะ อันนี้ถ้าไม่มีก็ไม่รู้จะว่าอย่างไรแล้วละครับท่าน นอกเหนือจากนี้ก็ต้องมีความรู้ทางด้านระบบพิกัดภูมิศาสตร์  คณิตศาสตร์ สถิติ เป็นต้น
  5. โทรศัพท์เคลื่อนที่ หรือวิทยุสื่อสารที่สามารถใช้ได้ในกรณีที่เครือข่ายโทรศัพท์ไม่สามารถใช้การได้ โทรศัพท์ถ้าเป็นแบบ smart phone ได้ยิ่งดีโดยเฉพาะรุ่นที่มี GPS ถ้าไม่มีจะมีอุปกรณ์ระบุพิกัดทางภูมิศาสตร์หรือ GPS ต่างหากก็ได้ ซึ่งระบบ GPS นี้จะสามารถช่วยให้เจ้าหน้าที่ ที่ปฏิบัติงานในพื้นที่สามารถแจ้งระบุตำแหน่งได้แม่นยำมากยิ่งขึ้น

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

ปัจจุบันทราบว่าการระบุตำแหน่งสามารถทำได้ง่ายขึ้น เช่น ข้อมูลของการไฟฟ้ามีการเก็บข้อมูลตำแหน่งของมิเตอร์ไฟฟ้า ดังนั้นเพียงแค่ผู้ประสบภัยแจ้งบ้านเลขที่ หมู่บ้าน ตำบล ก็จะทำให้ทราบตำแหน่งที่อยู่ของผู้แจ้งได้ทันที คำถามมีอยู่ว่าแล้วเราจะเข้าถึงระบบแผนที่หรือ GIS ของการไฟฟ้าได้หรือไม่ คำตอบในภาวะวิกฤตก็ต้องบอกว่าทำได้ยากหรือไม่ได้เลย แล้วเราจะแบ่งปันตำแหน่งเหล่านี้ได้อย่างไร หรืออีกกรณี ถ้าเจ้าหน้าที่กู้ภัยเข้าไปถึงจุดประสบภัยแล้วทราบตำแหน่งพิกัดจากอุปกรณ์ GPS แล้วจะแบ่งปันพิกัดเหล่านี้ให้กับผู้อื่นที่เกี่ยวข้องได้อย่างไร คำตอบก็คือใช้ Google Maps ครับ เราสามารถที่จะสร้างแผนที่ขึ้นมาโดยกำหนดให้เป็นแบบสาธารณะ (public) ในการแก้ไขแผนที่เราสามารถที่จะใช้เครื่องมือคือ การวางตำแหน่ง (placemark) ซึ่งมี icon สัญลักษณ์ให้เลือกตามความเหมาะสม การวาดเส้น (Lines) การวาดเส้นตามถนน และการวาดเส้นล้อมรอบพื้นที่ (Shapes) โดยสามารถกำหนดสีเพื่อระบุความหมายได้ สำหรับการวางตำแหน่งเมื่อเราทราบพิกัดต่าง ๆ ไม่ว่าจะเป็นพิกัดของผู้ประสบภัย (ละติจูด ลองติจูด) เราก็สามารถจะกำหนดจุดพิกัดดังกล่าวในแผนที่ได้ทันที

รูปแสดงตัวอย่างแผนที่ ที่สร้างจาก Google Maps

😉

07 09 2018 มาถึงวันนี้ ไม่รู้เรายังมีปัญหาแบบ 2554 อยู่อีกมั้ย