typedef struct
{
int x, y;
short life;
char *nama;
} Man;
void setup() {
Serial.begin(9600);
//menggunakan 4 memori untuk string
String hi = "Hello";
String names = "World";
String hello = hi + " " + names;
//menggunakan 1 memori
String greeting = hi;
greeting.concat(" ");
greeting.concat(names);
String tempname = "Temperature";
String temp = "23C";
PrintVal1(tempname, temp); //membuat string redundan. Lihat fungsi
PrintVal2(tempname, temp); //pass by reference, tidak redundan. Lihat fungsi
char thestring[30] = "This is a string";
//thestring = "New content"; //cara yang salah, panjang string harus sama!
strcpy(thestring, "New content"); //good method
char isgood[8] = "is good";
//char allbad[38] = thestring + isgood; //cara yang salah, ini adalah operasi biner. gunakan strcat
char allgood[38];
strcat(allgood, thestring); strcat(allgood, isgood);
char a[2] = "A"; char b[2] = "A";
if (a == b) {}//cara yang salah, akan selalu bernilai false
if (strcmp(a, b) == 0 ) {} //car yang benar, atau gunakan strcasecmp()
//pointer
int var = 0;
int arr[] = {1, 2, 3};
int *ptr; //init, don't set to NULL (destroy), *ptr = 0, first address? no!
ptr = &var; //to address of var, not the value of var
*ptr = 50;; //pointer content is 50
//ptr = 50; //pointer (address) is 50
//ptr++; //pointer address + 1
ptr = arr; //to array
ptr[0] = 50; //array number 0, is 50
ptr = &arr[0]; //equal to above, array number 0 is 50
Man *ptrMan;
Man manusia = {0, 0, 0, NULL};
manusia.life = 9; //kucing :D
manusia.nama = "Todol"; //pointer in struct
ptrMan = &manusia;
ptrMan-> life = 0; //mati
char *pString = "This is text"; //not safe to change content! don't do!
const char *pStringSafe = "This is text"; //display warning when change content
char temperature[] = "23C"; //constant
//Following syntax is not compiler friendly, it will be unhappy
PrintValP("Temperature", temperature);
//The following will make compiler happier (look at the fuction!)
PrintValPC("Temperature", temperature);
PrintString(temperature);
}
//make 2 new strings, redundant string
void PrintVal1(String tag, String value) {
Serial.print(tag);
Serial.print(" = ");
Serial.println(value);
}
//pass by reference
void PrintVal2(String &tag, String &value) {
Serial.print(tag);
Serial.print(" = ");
Serial.println(value);
}
//pass by pointer
void PrintValP(char *tag, char *value) {
Serial.print(tag);
Serial.print(" = ");
Serial.println(value);
}
void PrintValPC(const char *tag, const char *value) {
Serial.print(tag);
Serial.print(" = ");
Serial.println(value);
}
void PrintString(const char *str) {
const char *p;
p = str;
while (*p) {
Serial.print(*p);
p++;
}
}
void loop() {
// put your main code here, to run repeatedly:
}
Kategori: Mikrokontroller
Mencoba seonsor yang ada pada Nano BLE Sense
Melanjutkan tulisan Mencoba Nano 33 BLE Sense saatnya mencoba sensor-sensor yang ada pada modul ini. Sensor yang ada adalah 3D accelerometer, 3D gyroscope, 3D magnetometer (LSM9DS1), MEMS Digital Microphone (MP34DT05), Digital Proximity, Ambient Light, RGB and Gesture (APDS9960), Tekanan Udara (LPS22HB), Suhu dan Kelambaban (HTS221) Chip sensornya kecil kecil sekali!

Langsung saja, untuk mencoba Microphone, bisa kita lihat di sample skecthnya. Pastikan Board sudah bisa terpilih, driver terpasang dan Port juga sudah benar, cek di tulisan Mencoba Nano 33 BLE Sense. Selanjutnya pilih di bagian example -> PDM ->PDMSerialPlotter

Program ini menggunakan mikrofon on-board untuk mendengarkan audio dan memplotnya pada plotter serial. Kita akan melakukan kompilasi yang sangat lambat, membutuhkan waktu sekitar 10 menit untuk mengkompilasi dan mengunggah program. Ini karena integrasi Mbed OS dengan Arduino IDE, semoga Komunitas Arduino bisa memberikan solusi untuk ini.

Sedangkan untuk mencoba sensor-sensor lain, perlu mengistall library sesuai dengan chip sensornya berikut:

Selanjutnya gunakan contoh sketch berikut:
#include <Arduino_LSM9DS1.h> //IMU
#include <Arduino_LPS22HB.h> //Tekanan
#include <Arduino_HTS221.h> //Suhu dan kelembaban
#include <Arduino_APDS9960.h> //Gerakan, cahaya dan proksimiti
void setup(){
Serial.begin(9600);
if (!IMU.begin())
{ Serial.println("Chip IMU tidak ditemukan!"); while (1);}
if (!BARO.begin())
{ Serial.println("Chip Sensor Tekanan tidak ditemukan!"); while (1);}
if (!HTS.begin())
{ Serial.println("Chip Sensor Suhu & Kelembaban tidak ditemukan!"); while (1);}
if (!APDS.begin())
{ Serial.println("Chip Gesture, cahaya dan proksimiti tidak ditemukan!"); while (1);}
}
float accel_x, accel_y, accel_z;
float gyro_x, gyro_y, gyro_z;
float mag_x, mag_y, mag_z;
float Pressure;
float Temperature, Humidity;
int Proximity;
void loop()
{
//Accelerometer
if (IMU.accelerationAvailable()) {
IMU.readAcceleration(accel_x, accel_y, accel_z);
Serial.print("Accelerometer = ");Serial.print(accel_x); Serial.print(", ");Serial.print(accel_y);Serial.print(", ");Serial.println(accel_z);
}
delay (200);
//Gyroscope
if (IMU.gyroscopeAvailable()) {
IMU.readGyroscope(gyro_x, gyro_y, gyro_z);
Serial.print("Gyroscope = ");Serial.print(gyro_x); Serial.print(", ");Serial.print(gyro_y);Serial.print(", ");Serial.println(gyro_z);
}
delay (200);
//Magnetometer
if (IMU.magneticFieldAvailable()) {
IMU.readMagneticField(mag_x, mag_y, mag_z);
Serial.print("Magnetometer = ");Serial.print(mag_x); Serial.print(", ");Serial.print(mag_y);Serial.print(", ");Serial.println(mag_z);
}
delay (200);
//Pressure
Pressure = BARO.readPressure();
Serial.print("Tekanan= ");Serial.println(Pressure);
delay (200);
//Temperature
Temperature = HTS.readTemperature();
Serial.print("Suhu= ");Serial.println(Temperature);
delay (200);
//Humidity
Humidity = HTS.readHumidity();
Serial.print("Kelembaban= ");Serial.println(Humidity);
delay (200);
//Proximity
if (APDS.proximityAvailable()) {
Proximity = APDS.readProximity();
Serial.print("Proksimiti= ");Serial.println(Proximity);
}
delay (200);
Serial.println();
delay(1000);
}
HAsil bisa dilihat di serial monitor

Mencoba Nano 33 BLE Sense
Papan Arduino NANO 33 BLE Sense dirancang untuk solusi hemat daya dan hemat biaya bagi pembuat piranti elektronika yang memiliki konektivitas Bluetooth Hemat Energi. Menggunakan modul NINA B306, terdiri dari chip mikrokontroler Cortex M4F besutan Nordik, yaitu nRF52480. Arduino NANO 33 BLE Sense sama dengan Arduino NANO 33 BLE namun dengan tambahan satu set sensor yang sangat populer untuk mempelajari Machine Learning sebagai bagian dari kecerdasan buatan atau Artificial Inteligence (AI).

Untuk menggunakan modul ini, perlu menambahkan pustaka (library) Arduino nRF528x mbed Core. Caranya dengan memilih menu Tools, kemudian Boards dan Boards Manager, seperti yang didokumentasikan di halaman Arduino Boards Manager.

Arduino NANO 33 BLE Sense adalah variasi perangkat keras dari Arduino NANO 33 BLE; kedua modul tersebut dikenali sebagai Arduino NANO 33 BLE dan ini normal.
menginstal Driver untuk Arduino NANO 33 BLE Sense.
Dengan nRF528x mbed core diinstal, saatnya melanjutkan dengan penginstalan driver.
Pada Windows, jika menginstal Core nRF528x mbed dengan benar, cukup hubungkan Arduino NANO 33 BLE Sense ke komputer dengan kabel USB. Windows akan memulai proses instalasi drivernya setelah papan dicolokkan.
Memulai contoh sketch: blink

Pilih jenis board yang benar

Pilih Port yang sesuai

Mikrokontroler pada Arduino NANO 33 BLE Sense berjalan pada 3.3V, yang berarti tidak boleh menggunakan lebih dari 3.3V ke pin Digital dan Analognya. Berhati-hatilah saat menghubungkan sensor dan aktuator untuk memastikan bahwa batas 3,3V ini tidak pernah terlampaui. Menghubungkan sinyal tegangan yang lebih tinggi, seperti 5V yang biasa digunakan dengan papan Arduino lainnya, akan merusak Sense Arduino NANO 33 BLE.
Tegangan kerja 5V sekarang hanya menjadi pilihan tambahan untuk berbagai modul, sedangkan tegangan 3,3V menjadi tegangan standar untuk IC elektronik.
Terlindungi: Proteksi Sensor Suhu
Membuat Motion Capture
Printer POS USB menggunakan PHP
<?php
$tmpdir = sys_get_temp_dir(); # ambil direktori temporary untuk simpan file.
$file = tempnam($tmpdir, 'ctk'); # nama file temporary yang akan dicetak (Windows, samba)
$handle = fopen($file, 'w');
//Printer parameter (ESC POS Command)
$initialized = chr(27).chr(64);
$justify = Chr(27) . Chr(97);
$left = Chr(0); $center = Chr(1);$right = Chr(2);
$fontwidth = Chr(27).Chr(87);
$doublewidth = Chr(1); $normalwidth = Chr(0);
$LF = Chr(10);
//Start making data
$Data = $initialized;
$Data .= $fontwidth.$doublewidth;
$Data .= $justify.$center;
$Data .= "NAMA TOKO"."\n";
$Data .= $fontwidth.$normalwidth;
$Data .= "Alamat Toko"."\n";
$Data .= $LF.$LF;
//Write data to temporary file
fwrite($handle, $Data);
fclose($handle);
//WIN: send temporary file to nerwork shared printer (share your printer)
//LINUX: send data directly to device
if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN'){ //Win
copy($file, "//localhost/POS-58"); # Shared Printer as POS-58
}else if (strtoupper(substr(PHP_OS, 0, 3)) === 'LIN'){ //Linux
$device = "/dev/usb/lp0"; # Print at lp0, find it using lsusb! Use udev for managing user access
if (is_writable($device)) {
$fp =fopen($device, "w");
if($fp) {
fwrite($fp, $Data);
fclose($fp);
}
}
}
unlink($file);
//echo $Data;
?>
Cara mencetak ke printer POS menggunakan PHP. Skrip ini mencontohkan jika menggunakan Windows maupun Linux.
Untuk menggunakan Windows maupun Linux, printer dibuat menjadi akses bersama (shared printer) terlebih dahulu lalu beri nama, misalnya: POS-58. Pastikan bisa diakses di //ALAMAT_IP/NAMA_PRINTER. Untuk skrip ini, menggunakan //localhost/POS-58 Untuk di Windows, buka di Control Panel, pastikan printer yang di-share sudah tersedia dan online.
Sedangkan jika menggunakan Linux, cari nama device dengan perintah:
ls /dev/usb
alamat device printer akan diawali dengan lpx, dimana x bisa 0,1,2 atau angka yang lain. Bagaimana bisa memastikan mana alamat device yang benar? gunakan perintah berikut:
echo "Test Printer" >> /dev/usb/lp0
Jika printer bisa mencetak, berarti alamat printer adalah benar, yaitu /dev/usb/lp0 jika salah ganti angka 0 dengan angka 1 atau 2 atau angka lain hingga printer bisa mencetak. Pada skrip ini, alamat device perinter adalah /dev/usb/lp0
Penerima Waktu Tunda WiFi

#ifdef ESP32
#include <esp_now.h>
#include <WiFi.h>
#else
#include <espnow.h>
#include <ESP8266WiFi.h>
#define ESP_OK 0
#endif
#define lampPin 0
bool lampON = false;
bool lock = false;
// struktur untuk pengiriman data harus sama dengan struktur pada penerima
typedef struct struct_message {
int id; //id pengirim, lock counter
int x; //on interval counter
int y; //motion (>0)
} struct_message;
struct_message myData;
// Membuat struktur untuk tiap board
struct_message board1;
struct_message boardsStruct[3] = {board1};
volatile int counter = 0;
int max_counter = 0;
int lock_counter = 1;
// callback saat data diterima
#ifdef ESP32
void OnDataRecv(const uint8_t * mac_addr, const uint8_t *incomingData, int len)
#else
void OnDataRecv(uint8_t * mac_addr, uint8_t *incomingData, uint8_t len)
#endif
{
char macStr[18];
Serial.print("Paket diterima dari: ");
snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
Serial.println(macStr);
memcpy(&myData, incomingData, sizeof(myData));
Serial.printf("Board ID %u: %u bytes\n", myData.id, len);
// Update the structures with the new incoming data
boardsStruct[myData.id - 1].x = myData.x;
boardsStruct[myData.id - 1].y = myData.y;
Serial.printf("x value: %d \n", boardsStruct[myData.id - 1].x);
Serial.printf("y value: %d \n", boardsStruct[myData.id - 1].y);
Serial.println();
if (!lock) counter = 0;
}
void setup() {
Serial.begin(74880);
Serial.println();
Serial.print("ESP Board MAC Address: ");
Serial.println(WiFi.macAddress());
WiFi.mode(WIFI_STA);
//Init ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
//daftrakan callback
esp_now_register_recv_cb(OnDataRecv);
pinMode(lampPin, OUTPUT);
Serial.println("Turn Off lamp");
digitalWrite(lampPin, LOW);
lampON = false;
}
void loop() {
// Mengakses data dari setiap board
//Serial.println(boardsStruct[0].x,DEC);
//delay(1000);
//update counter
if (boardsStruct[0].x > 0)
max_counter = boardsStruct[0].x;
if (boardsStruct[0].id > 0)
lock_counter = boardsStruct[0].id;
//get motion information and restart counter?
if (boardsStruct[0].y > 0 && counter == 0) {
if (!lampON) {
Serial.println("Turn On lamp");
digitalWrite(lampPin, HIGH);
lampON = true;
}
}
//stop counter turn off lamp
if (counter >= max_counter && lampON) {
Serial.println("Turn Off lamp");
digitalWrite(lampPin, LOW);
lampON = false;
lock = true;
Serial.println("Lock");
delay(lock_counter * 1000);
Serial.println("Release");
lock = false;
}
if (lampON) {
counter++;
Serial.print(max_counter - counter);
delay(1000);
}
}
Memulai Percobaan ESP-CAM


ESP-CAM memiliki LED pada pin GPIO33. LED ini akan kita gunakan untuk percobaan mati nyala kedip kedip.
Kode Blink pada Arduino
#define LED_BUILTIN 33 //LED ada di GPIO33
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Konfigurasi pilihan Board
Hubungkan USB-Serial atau dapat pula menggunakan Arduino (TX-TX, RX-RX)

Jika sudah berhasil Upload, lepas hubungan GND dengan GPIO0 (Kabel abu-abu) dan tekan reset.
Pengiriman Peer-to-Peer MCU ESP
Pengiriman dilakukan oleh LOLIN32 dengan MCU ESP32 sedangkan penerimaan dilakukan oleh ESP01 dengan MCU ESP8266. Potokol pengiriman menggunakan ESP-NOW. ESP-NOW adalah salah satu protokol hibungan WiFi yang dibesut oleh Espressif.
Skrip Pengiriman yang dibenamkan di LOLIN32
#ifdef ESP32
#include <esp_now.h>
#include <WiFi.h>
#else
#include <espnow.h>
#include <ESP8266WiFi.h>
typedef enum {ESP_NOW_SEND_SUCCESS = 0, ESP_NOW_SEND_FAIL};
typedef enum {ESP_OK = 0} esp_err_t;
#endif
// Ganti dengan MAC penerima
uint8_t broadcastAddress[] = {0x50, 0x02, 0x91, 0xFE, 0x4C, 0x01};
// ID harus unik
const int id = 1;
// struktur untuk pengiriman data harus sama dengan struktur pada penerima
typedef struct struct_message {
int id;
int x;
int y;
} struct_message;
struct_message myData;
// callback saat data dikirim
#ifdef ESP32
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status)
#else
void OnDataSent(uint8_t *mac_addr, uint8_t status)
#endif
{
Serial.print("Status pengiriman:\t");
Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Sukses" : "Gagal");
}
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
// Init ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Gagal inisialisasi ESP-NOW");
return;
}
#ifdef ESP32
#else
esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
#endif
// registrasi ke penerima dan cek status paket
esp_now_register_send_cb(OnDataSent);
// Registrasi peer
#ifdef ESP32
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, broadcastAddress, 6);
peerInfo.channel = 0;
peerInfo.encrypt = false;
// Menambahkan diri peer
if (esp_now_add_peer(&peerInfo) != ESP_OK) {
Serial.println("Gagal menambahkan peer");
return;
}
#else
if (esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0) != ESP_OK) {
Serial.println("Gagal menambahkan peer");
return;
}
#endif
}
void loop() {
// Nilai untuk dikirim
myData.id = 1;
myData.x = random(0, 50);
myData.y = random(0, 50);
Serial.print("x:"); Serial.println(myData.x, DEC);
Serial.print("y:"); Serial.println(myData.y, DEC);
// Kirim pesan
#ifdef ESP32
esp_err_t result;
#else
int result;
#endif
result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
if (result == ESP_OK) {
Serial.println("Permintaan pengiriman berhasil");
}
else {
Serial.println("Gagal mengirim data");
}
delay(10000);
}
Skrip penerima yang dibenamkan di ESP01
#ifdef ESP32
#include <esp_now.h>
#include <WiFi.h>
#else
#include <espnow.h>
#include <ESP8266WiFi.h>
#define ESP_OK 0
#endif
// struktur untuk pengiriman data harus sama dengan struktur pada penerima
typedef struct struct_message {
int id;
int x;
int y;
}struct_message;
struct_message myData;
// Membuat struktur untuk tiap board
struct_message board1;
struct_message boardsStruct[3] = {board1};
// callback saat data diterima
#ifdef ESP32
void OnDataRecv(const uint8_t * mac_addr, const uint8_t *incomingData, int len)
#else
void OnDataRecv(uint8_t * mac_addr, uint8_t *incomingData, uint8_t len)
#endif
{
char macStr[18];
Serial.print("Paket diterima dari: ");
snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
Serial.println(macStr);
memcpy(&myData, incomingData, sizeof(myData));
Serial.printf("Board ID %u: %u bytes\n", myData.id, len);
// Update the structures with the new incoming data
boardsStruct[myData.id-1].x = myData.x;
boardsStruct[myData.id-1].y = myData.y;
Serial.printf("x value: %d \n", boardsStruct[myData.id-1].x);
Serial.printf("y value: %d \n", boardsStruct[myData.id-1].y);
Serial.println();
}
void setup(){
Serial.begin(74880);
Serial.println();
Serial.print("ESP Board MAC Address: ");
Serial.println(WiFi.macAddress());
WiFi.mode(WIFI_STA);
//Init ESP-NOW
if (esp_now_init() != ESP_OK) {
Serial.println("Error initializing ESP-NOW");
return;
}
//daftrakan callback
esp_now_register_recv_cb(OnDataRecv);
}
void loop() {
// Mengakses data dari setiap board
//Serial.println(boardsStruct[0].x,DEC);
delay(1000);
}
Hasil proses pengiriman lewat seriam monitor

Konfigurasi Perangkat Keras

Cara memprogram ESP01
Wiring dengan Modul Serial

Wiring dengan USB-TTL (Gunakan yang support 3,3 Volt) atau dapat juga menggunakan Board Arduino

(Jika mengunakan board Arduino, hubungkan RX ke RX dan TX ke TX)
Pilihan Setting Board
Board: “Generic ESP Module”
Flash Mode: “DIO” (Gunakan DOUT jika checksum error)
Flash Frequency: “40MHz”
CPU Frequency: “80 MHz”
Flash Size: “1M (64K SPIFFS)”
Debug Port: “Disabled”
Debug Level: “None”
Reset Method: “ck”
Upload Speed: “115200”

Contoh kode untuk blink (LED pada GPIO0)
/*
* ESP01
* Upload Configuration:
* Generic 8266
* Flash Mode: DOUT (Using: DIO --> checksum Error)
* Debug: None
* Reset: ck
* CPU: 80Mhz
* Flash: 1M (64K)
* Debug Port: Disable
* Flash: 40Mhz
* Upload Speed: 115200
*
* Flashing ESP-01 using Esp8266 Serial Module Board
* Connect GPIO0 to GND
*
* Flash ESP-01 using USB to TTL
* Connect GPIO0 to GND, EN to 3V3, RX-TX, TX-RX
*/
#define D3 0 //GPIO0
#define D4 2 //GPIO2
void setup() {
//GPIO0
pinMode(D3, OUTPUT);
Serial.begin(74880);
}
void loop() {
digitalWrite(D3, LOW); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(D3, HIGH); // turn the LED off by making the voltage LOW Serial.println("LOW");
delay(1000); // wait for a second
Serial.println("OK");
}
Untuk menjalankan hasil programming, lepas kabel IO0 terhadap GND dan lalukan reset (atau cabut pasang modul)
sumber: https://www.diyhobi.com/flash-program-esp-01-using-usb-serial-adapter/