TUTORIAL MENGINTEGRASIKAN MIKROKONTROLER ESP32 KE IOT CORE AMAZON WEB SERVICE (AWS)

 

    Pada kesempatan kali ini saya akan memberikan tutorial cara mengintegrasikan mikrokontroler ESP-32 ke cloud AWS pada IoT core. Tutorial ini akan memberikan gamabaran pada anda cara untuk mempublish dan mensubscribe pesan atau data diantara dua tools ini.

1. Set Up AWS IoT Core

Pada laman AWS anda silahkan membuka console home dan cari IoT core. Setelah itu, silahkan buka manage, kemudian all device dan pilih Things.
Console Home > IoT Core > Manage > All Device > Things.


Selanjutnya anda akan diarahkan untuk membuat things baru dan pilih create single thing.


Setelah next, silahkan anda menamai thing anda dan ikuti saja pengaturan default seperti berikut.


Next, anda akan diarahkan untuk membuat device certificate dan pilih auto (recomended).


Next, anda akan diminta untuk membuat Attach policies to certificate. Silahkan klik create policy pada sisi kanan atas layar anda. Pada laman tersebut silahkan ikuti policy document berikut.


Setelah itu, anda akan diminta untuk mendownload 4 dokumen berikut.


Setelah itu silahkan kembali kehalaman Attach policies to certificate, pilih policy yang telah anda create dan klik create thing.

2. Setup Arduino IDE dan ESP32

Pertama, untuk board saya merekomendasikan anda menggunakan ESP32 Dev Module.


Kemudian pastikan ESP32 anda telat terhubung ke plot USB laptop dan pilih port yang terhubung ke ESP32. Sebagai tambahan anda harus memastikan fungsionalitas ESP32. Anda dapat menggunakan kode berikut:

// Pin untuk LED built-in pada ESP32 (biasanya GPIO 2)
const int ledPin = 2;

void setup() {
  // Inisialisasi pin sebagai output
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Nyalakan LED
  digitalWrite(ledPin, HIGH);
  delay(500); // Tahan LED menyala selama 500ms
  
  // Matikan LED
  digitalWrite(ledPin, LOW);
  delay(500); // Tahan LED mati selama 500ms
}

Setalah memastikan  ESP32 anda berfungsi dengan baik mari kita lanjutkan ke step berikutnya!.

3. Create Code

Sebelum masuk ke code, mari kita kenali fungsi-fungsi yang akan kita gunakan.
Mari kita jelaskan baris kode tersebut satu per satu:

1. `#include <pgmspace.h>`: Menggunakan direktif pra-prosesor `#include` untuk menyertakan pustaka `pgmspace.h`, yang memberikan akses ke fungsi-fungsi yang memungkinkan untuk mengakses data yang disimpan di dalam ruang program pada mikrokontroler.

2. `#include <WiFiClientSecure.h>`: Menggunakan direktif pra-prosesor `#include` untuk menyertakan pustaka `WiFiClientSecure.h`, yang menyediakan klien WiFi yang aman untuk koneksi SSL/TLS.

3. `#include <PubSubClient.h>`: Menggunakan direktif pra-prosesor `#include` untuk menyertakan pustaka `PubSubClient.h`, yang menyediakan klien MQTT untuk ESP32.

4. `#include "WiFi.h"`: Menggunakan direktif pra-prosesor `#include` untuk menyertakan file header `WiFi.h`, yang memberikan akses ke fungsi-fungsi dan konstanta-konstanta yang diperlukan untuk mengelola koneksi WiFi pada ESP32.

5. `#define AWS_IOT_SUBSCRIBE_TOPIC "esp32/sub"`: Mendefinisikan konstanta `AWS_IOT_SUBSCRIBE_TOPIC` sebagai topik MQTT yang akan disubscribe untuk menerima perintah.

6. `#define THINGNAME "***********"`: Mendefinisikan konstanta `THINGNAME` sebagai identifikasi unik untuk perangkat, yang akan digunakan dalam koneksi ke AWS IoT.

7. `const char WIFI_SSID[] = "***********";`: Mendefinisikan array karakter konstan `WIFI_SSID` yang menyimpan SSID (nama jaringan WiFi) yang akan digunakan untuk koneksi.

8. `const char WIFI_PASSWORD[] = "***********";`: Mendefinisikan array karakter konstan `WIFI_PASSWORD` yang menyimpan kata sandi jaringan WiFi yang akan digunakan untuk koneksi.

9. `const char AWS_IOT_ENDPOINT[] = "***********";`: Mendefinisikan array karakter konstan `AWS_IOT_ENDPOINT` yang menyimpan endpoint AWS IoT yang akan digunakan untuk koneksi.

10. `static const char AWS_CERT_CA[] PROGMEM = R"EOF(...)` dan sejenisnya: Mendefinisikan sertifikat dan kunci pribadi AWS IoT dalam bentuk string konstan yang diletakkan dalam memori program (PROGMEM). Ini termasuk sertifikat CA, sertifikat klien, dan kunci pribadi klien.

12. `WiFiClientSecure net = WiFiClientSecure();`: Membuat objek `net` dari kelas `WiFiClientSecure` untuk mengelola koneksi WiFi yang aman.

13. `PubSubClient client(net);`: Membuat objek `client` dari kelas `PubSubClient` menggunakan objek `net` sebagai klien MQTT yang akan digunakan.

14. `void messageHandler(char* topic, byte* payload, unsigned int length)`: Mendefinisikan fungsi `messageHandler` yang akan dipanggil ketika pesan MQTT diterima.

15. `void setup() {...}`: Mendefinisikan fungsi `setup()` yang akan dijalankan sekali saat perangkat pertama kali dijalankan.

16. `void loop() {...}`: Mendefinisikan fungsi `loop()` yang akan dijalankan berulang kali selama perangkat berjalan, yang dalam hal ini digunakan untuk menjaga koneksi MQTT tetap aktif.

Berikut adalah sorce code yang dapat anda gunakan:

#include <pgmspace.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include "WiFi.h"

// AWS IoT Configuration
#define AWS_IOT_SUBSCRIBE_TOPIC "***/***" // MQTT topic to subscribe to for commands
#define AWS_IOT_PUBLISH_TOPIC "****/****"   // MQTT topic to publish messages to
#define THINGNAME "***********" // Unique identifier for your device, change this
const char WIFI_SSID[] = "***********"; // Your WiFi SSID
const char WIFI_PASSWORD[] = "***********"; // Your WiFi password
const char AWS_IOT_ENDPOINT[] = "***********"; // Your AWS IoT endpoint, change this

// Certificates and Keys
static const char AWS_CERT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
// Paste certificate here
-----END CERTIFICATE-----
)EOF";

static const char AWS_CERT_CRT[] PROGMEM = R"KEY(
-----BEGIN CERTIFICATE-----
// Paste certificate here
-----END CERTIFICATE-----
)KEY";

static const char AWS_CERT_PRIVATE[] PROGMEM = R"KEY(
-----BEGIN RSA PRIVATE KEY-----
// Paste private key here
-----END RSA PRIVATE KEY-----
)KEY";

WiFiClientSecure net = WiFiClientSecure();
PubSubClient client(net);

// Function to handle incoming MQTT messages
void messageHandler(char* topic, byte* payload, unsigned int length) 
{
  Serial.print("Incoming message on topic [");
  Serial.print(topic);
  Serial.print("]: ");
 
  // Construct message from payload
  String received_msg = "";
  for (int i = 0; i < length; i++) 
  {
    received_msg += (char)payload[i];
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

// Function to publish message to MQTT topic
void publishMessage(const char* message)
{
  if (client.connected())
  {
    client.publish(AWS_IOT_PUBLISH_TOPIC, message);
    Serial.println("Message published to MQTT topic!");
  }
  else
  {
    Serial.println("Error: Not connected to MQTT broker!");
  }
}

void setup()
{
  Serial.begin(115200); // Start serial communication
 
  WiFi.mode(WIFI_STA); // Set WiFi to station mode
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD); // Connect to WiFi network
 
  Serial.println("Connecting to Wi-Fi");
 
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
 
  // Configure WiFiClientSecure to use the AWS IoT device credentials
  net.setCACert(AWS_CERT_CA);
  net.setCertificate(AWS_CERT_CRT);
  net.setPrivateKey(AWS_CERT_PRIVATE);
 
  // Connect to the MQTT broker on the AWS endpoint
  client.setServer(AWS_IOT_ENDPOINT, 8883);
 
  // Set the function to handle messages
  client.setCallback(messageHandler);
 
  Serial.println("Connecting to AWS IOT");
 
  // Attempt to connect to AWS IoT
  while (!client.connect(THINGNAME))
  {
    Serial.print(".");
    delay(100);
  }
 
  // Check if connection was successful
  if (!client.connected())
  {
    Serial.println("AWS IoT Timeout!");
    return;
  }
 
  // Subscribe to the MQTT topic for receiving commands
  client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);
 
  Serial.println("AWS IoT Connected!");
}

void loop()
{
  // Keep the MQTT connection alive
  client.loop();

  // Example: Publish a message every 5 seconds
  static unsigned long lastPublish = 0;
  if (millis() - lastPublish > 5000)
  {
    publishMessage("Hello from NOPS ESP32!");
    lastPublish = millis();
  }

  delay(1000);
}


Pada kode diatas, anda tinggal menambahkan isian sesuai kebutuhan yang telah saya tandai dengan "*******". Dan jangan lupa memasukkan certificate dan key yang telah anda download sebelumnya sesuai yang diminta. Caranya, anda dapat membuka file certificate tadi menggunakan notepad dan copy dan paste pada bagian source code diatas. Kemudian untuk endpoint anda bisa dapatkan dibagian setting pada console home. Setelah itu silahkan upload code ke ESP32 anda dan buka serial monitor untuk cek status pengiriman. Untuk memastikan pesan atau data sudah masuk ke AWS anda dapat membuka MQTT test client dan masukan topic yang sudah anda isi diatas.








Komentar

Posting Komentar

Postingan populer dari blog ini

Mengenal Metode Komunikasi Long Range (LoRa)

Gambar
       LoRa  adalah sebuah teknologi komunikasi nirkabel yang dirancang untuk mentransmisikan data dengan jangkauan jauh, konsumsi daya rendah, dan biaya rendah. Ini merupakan teknologi yang sangat cocok untuk aplikasi IoT (Internet of Things) yang membutuhkan pengiriman data yang jarang, tetapi memerlukan jangkauan yang luas. Berikut adalah beberapa poin penting tentang teknologi komunikasi LoRa: Modulasi LoRa      LoRa menggunakan modulasi CSS (Chirp Spread Spectrum), yang memungkinkan sinyal LoRa memiliki keunggulan dalam jangkauan dan penetrasi yang baik di lingkungan perkotaan atau rural. Modulasi CSS menggunakan sinyal chirp (sinyal yang frekuensinya berubah seiring waktu) untuk mentransmisikan data, yang memungkinkan sinyal LoRa lebih tahan terhadap gangguan dan noise. Jangkauan Jarak Jauh      Salah satu keunggulan utama dari LoRa adalah jangkauan jarak jauhnya. Dengan menggunakan frekuensi radio yang rendah, LoRa dapat menc...
Baca selengkapnya

Tutorial Instalasi MicroPython di Mikrokontroler ESP32

Gambar
            Baik pada kesempatan kali ini saya akan memberikan tutorial bagaimana cara anda dapat menginstall MicroPython pada ESP32. Sebelumnya anda perlu mengetahui apa itu MicroPython,  MicroPython adalah implementasi open-source dari bahasa pemrograman Python yang dioptimalkan untuk mikrokontroler dan perangkat terbatas. Ia dirancang agar dapat berjalan pada perangkat keras dengan sumber daya terbatas, MicroPython memungkinkan sipengembang untuk menggunakan kekuatan Python dalam pengembangan perangkat keras. Dengan ukurannya yang kecil dan kemampuannya untuk berjalan di mikrokontroler, MicroPython menjadi pilihan yang populer untuk pengembangan prototipe, proyek Internet of Things (IoT), dan aplikasi perangkat keras sederhana. Baik tanpa perlu berlama-lama lagi mari kita simak cara instalasinya. Step 1 Anda dapat langsung menginstall MicroPython pada device anda melalui browser menggunakan link berikut:  https://micropython.org/download/E...
Baca selengkapnya

Tutorial Mengirim Data Ke Server Client (ChirpStack) Via LoRa

Gambar
  Pada kesempatan kali ini, saya akan menggunakan ChirpStack sebagai client server yang berfungsi sebagai penerima data atau pesan yang akan kita kirim. Berikut merupakan beberapa step yang harus anda perhatikan dan fahami: Persiapkan Perangkat dan Lingkungan Pengembangan    Pastikan Anda telah menyiapkan ESP32 dan lingkungan pengembangan Anda dengan benar. Ini termasuk memastikan ESP32 Anda telah diprogram dengan firmware yang mendukung koneksi LoRa, dan Anda memiliki akses ke server LoRaWAN seperti ChirpStack. Gunakan Server LoRaWAN Pribadi    Anda dapat menggunakan server LoRaWAN pribadi seperti ChirpStack (sebelumnya dikenal sebagai LoRaServer) untuk mengelola perangkat LoRa Anda. Ini memungkinkan Anda untuk mengontrol dan memantau perangkat Anda dengan lebih baik daripada menggunakan server publik. Buat Akun Pribadi    Jika Anda belum memiliki akun di ChirpStack, buatlah akun terlebih dahulu. Ini biasanya melibatkan memberikan informasi pribadi da...
Baca selengkapnya