343 lines
8.2 KiB
C++
343 lines
8.2 KiB
C++
//
|
|
// wirelessly connected cloud (based on a LPWAN, called ESP-NOW)
|
|
//
|
|
|
|
//
|
|
// puredata gathering @ ururu.cloud, Seoul
|
|
//
|
|
|
|
//
|
|
// 2024 02 17
|
|
//
|
|
// this module will be an esp-now node in a group.
|
|
// like, a bird in a group of birds.
|
|
//
|
|
// esp-now @ esp8266 w/ broadcast address (FF:FF:FF:FF:FF:FF)
|
|
// always broadcasting. everyone is 'talkative'.
|
|
//
|
|
|
|
//============<identities>============
|
|
#define MY_GROUP_ID (4000)
|
|
#define MY_ID (MY_GROUP_ID + 1)
|
|
#define MY_SIGN ("ROLLER2")
|
|
//============</identities>============
|
|
|
|
//============<parameters>============
|
|
#define WIFI_CHANNEL 1
|
|
//============</parameters>===========
|
|
|
|
//arduino
|
|
#include <Arduino.h>
|
|
|
|
//network credentials
|
|
char ssid[] = "KT_GiGA_D565"; // ssid
|
|
char pass[] = "bhc1dd4971"; // password
|
|
|
|
////udp
|
|
#include <ESP8266WiFi.h>
|
|
#include <WiFiUdp.h>
|
|
WiFiUDP Udp;
|
|
|
|
// destination IP & Port
|
|
// const IPAddress dest_ip(192,168,43,255);
|
|
const IPAddress dest_ip(255,255,255,255);
|
|
const unsigned int dest_port = 5555;
|
|
|
|
// - Local broadcast address (255.255.255.255)
|
|
// - Directed broadcast address (192.168.25.255 or 192.168.255.255 depends on your subnet)
|
|
|
|
// difference between 'Directed broadcast' vs 'Local broadcast'
|
|
// ==> https://serverfault.com/a/219767
|
|
// ==> https://www.sysnet.pe.kr/2/0/11368
|
|
|
|
// listening Port
|
|
const unsigned int listening_port = 5555; // listening port
|
|
|
|
//message types
|
|
#include "message.h"
|
|
|
|
//osc
|
|
#include <OSCMessage.h>
|
|
#include <OSCBundle.h>
|
|
OSCErrorCode error;
|
|
|
|
//task
|
|
#include <TaskScheduler.h>
|
|
Scheduler runner;
|
|
|
|
//-*-*-*-*-*-*-*-*-*-*-*-*-
|
|
// servo
|
|
#define MOTOR_1A (D6)
|
|
#define MOTOR_1B (D5)
|
|
// my tasks
|
|
int speed = 0;
|
|
bool isactive = false;
|
|
void set_speed() {
|
|
int r = speed;
|
|
//
|
|
if (r >= 0) {
|
|
digitalWrite(MOTOR_1A, LOW);
|
|
analogWrite(MOTOR_1B, r);
|
|
} else {
|
|
digitalWrite(MOTOR_1B, LOW);
|
|
analogWrite(MOTOR_1A, r*(-1));
|
|
}
|
|
Serial.print("set_speed:");
|
|
Serial.println(r);
|
|
isactive = true;
|
|
}
|
|
Task set_speed_task(0, TASK_ONCE, &set_speed, &runner, false);
|
|
//
|
|
void rest() {
|
|
analogWrite(MOTOR_1A, LOW);
|
|
analogWrite(MOTOR_1B, LOW);
|
|
isactive = false;
|
|
}
|
|
Task rest_task(0, TASK_ONCE, &rest, &runner, false);
|
|
//
|
|
uint8_t watch_counter = 0;
|
|
void watcher() {
|
|
if (isactive) {
|
|
if (watch_counter > 3) {
|
|
rest_task.restartDelayed(10);
|
|
watch_counter = 0;
|
|
} else {
|
|
watch_counter++;
|
|
}
|
|
}
|
|
}
|
|
Task watcher_task(1000, TASK_FOREVER, &watcher, &runner, true);
|
|
//
|
|
#define MOTOR_2A (D3)
|
|
#define MOTOR_2B (D2)
|
|
// my tasks
|
|
int speed2 = 0;
|
|
bool isactive2 = false;
|
|
void set_speed2() {
|
|
int r = speed2;
|
|
//
|
|
if (r >= 0) {
|
|
digitalWrite(MOTOR_2A, LOW);
|
|
analogWrite(MOTOR_2B, r);
|
|
} else {
|
|
digitalWrite(MOTOR_2B, LOW);
|
|
analogWrite(MOTOR_2A, r*(-1));
|
|
}
|
|
Serial.print("set_speed2:");
|
|
Serial.println(r);
|
|
isactive2 = true;
|
|
}
|
|
Task set_speed2_task(0, TASK_ONCE, &set_speed2, &runner, false);
|
|
//
|
|
void rest2() {
|
|
analogWrite(MOTOR_2A, LOW);
|
|
analogWrite(MOTOR_2B, LOW);
|
|
isactive2 = false;
|
|
}
|
|
Task rest2_task(0, TASK_ONCE, &rest2, &runner, false);
|
|
//
|
|
uint8_t watch2_counter = 0;
|
|
void watcher2() {
|
|
if (isactive2) {
|
|
if (watch2_counter > 3) {
|
|
rest2_task.restartDelayed(10);
|
|
watch2_counter = 0;
|
|
} else {
|
|
watch2_counter++;
|
|
}
|
|
}
|
|
}
|
|
Task watcher2_task(1000, TASK_FOREVER, &watcher2, &runner, true);
|
|
//*-*-*-*-*-*-*-*-*-*-*-*-*
|
|
|
|
// on 'Note'
|
|
void onNoteHandler(Note & n) {
|
|
Serial.println(n.to_string());
|
|
//is it for me?
|
|
if (n.id == MY_GROUP_ID || n.id == MY_ID) {
|
|
//
|
|
if (n.pitch == 0) {
|
|
speed = n.velocity;
|
|
//
|
|
if (n.onoff == 1) {
|
|
set_speed_task.restartDelayed(10);
|
|
watch_counter = 0;
|
|
} else if (n.onoff == 0) {
|
|
rest_task.restartDelayed(10);
|
|
} else if (n.onoff == 2) {
|
|
set_speed_task.restartDelayed(10);
|
|
rest_task.restartDelayed(10 + n.x1);
|
|
}
|
|
}
|
|
//
|
|
else if (n.pitch == 1) {
|
|
speed2 = n.velocity;
|
|
//
|
|
if (n.onoff == 1) {
|
|
set_speed2_task.restartDelayed(10);
|
|
watch2_counter = 0;
|
|
} else if (n.onoff == 0) {
|
|
rest2_task.restartDelayed(10);
|
|
} else if (n.onoff == 2) {
|
|
set_speed2_task.restartDelayed(10);
|
|
rest2_task.restartDelayed(10 + n.x1);
|
|
}
|
|
}
|
|
//
|
|
}
|
|
}
|
|
|
|
//*-*-*-*-*-*-*-*-*-*-*-*-*
|
|
//common task #0 : blink led
|
|
#define LED_PERIOD (11111)
|
|
#define LED_ONTIME (1)
|
|
#define LED_GAPTIME (222)
|
|
#define LED_PIN 2
|
|
extern Task blink_task;
|
|
void blink() {
|
|
//
|
|
static int count = 0;
|
|
count++;
|
|
//
|
|
switch (count % 4) {
|
|
case 0:
|
|
digitalWrite(LED_PIN, LOW); // first ON
|
|
blink_task.delay(LED_ONTIME);
|
|
break;
|
|
case 1:
|
|
digitalWrite(LED_PIN, HIGH); // first OFF
|
|
blink_task.delay(LED_GAPTIME);
|
|
break;
|
|
case 2:
|
|
digitalWrite(LED_PIN, LOW); // second ON
|
|
blink_task.delay(LED_ONTIME);
|
|
break;
|
|
case 3:
|
|
digitalWrite(LED_PIN, HIGH); // second OFF
|
|
blink_task.delay(LED_PERIOD - 2* LED_ONTIME - LED_GAPTIME);
|
|
break;
|
|
}
|
|
}
|
|
Task blink_task(0, TASK_FOREVER, &blink, &runner, true); // -> ENABLED, at start-up.
|
|
|
|
//common task #1 : listen on osc messages
|
|
// - osc processing
|
|
void route_note(OSCMessage& msg, int offset) {
|
|
// Serial.println("got route_note!");
|
|
// matches will happen in the order. that the bundle is packed.
|
|
static Note note;
|
|
// (1) --> /onoff
|
|
if (msg.fullMatch("/onoff", offset)) {
|
|
//
|
|
note.clear();
|
|
//
|
|
note.onoff = msg.getFloat(0);
|
|
// if (note.onoff != 0) note.onoff = 1;
|
|
}
|
|
// (2) --> /velocity
|
|
if (msg.fullMatch("/velocity", offset)) {
|
|
note.velocity = msg.getFloat(0);
|
|
}
|
|
// (3) --> /pitch
|
|
if (msg.fullMatch("/pitch", offset)) {
|
|
note.pitch = msg.getFloat(0);
|
|
}
|
|
// (4) --> /id
|
|
if (msg.fullMatch("/id", offset)) {
|
|
note.id = msg.getInt(0);
|
|
}
|
|
// (5) --> /x
|
|
if (msg.fullMatch("/x", offset)) {
|
|
note.x1 = msg.getFloat(0);
|
|
note.x2 = msg.getFloat(1);
|
|
note.x3 = msg.getFloat(2);
|
|
note.x4 = msg.getFloat(3);
|
|
note.ps = msg.getFloat(4);
|
|
//
|
|
onNoteHandler(note);
|
|
//
|
|
}
|
|
}
|
|
// - osc task
|
|
extern Task osc_task;
|
|
void osc()
|
|
{
|
|
//osc
|
|
OSCBundle bundleIN;
|
|
int size = Udp.parsePacket();
|
|
|
|
if (size > 0) {
|
|
Serial.println(size);
|
|
while (size--) {
|
|
bundleIN.fill(Udp.read());
|
|
}
|
|
if (!bundleIN.hasError()) {
|
|
// on '/note'
|
|
bundleIN.route("/note", route_note);
|
|
} else {
|
|
error = bundleIN.getError();
|
|
Serial.print("error: ");
|
|
Serial.println(error);
|
|
}
|
|
}
|
|
}
|
|
Task osc_task(0, TASK_FOREVER, &osc, &runner, false); // -> ENABLED, at start-up.
|
|
//*-*-*-*-*-*-*-*-*-*-*-*-*
|
|
|
|
//
|
|
void setup() {
|
|
|
|
//led
|
|
pinMode(LED_PIN, OUTPUT);
|
|
|
|
//pwm freq.
|
|
analogWriteFreq(40000);
|
|
|
|
//serial
|
|
Serial.begin(115200);
|
|
delay(100);
|
|
|
|
//wifi
|
|
Serial.println();
|
|
Serial.println();
|
|
Serial.print("Connecting to ");
|
|
Serial.println(ssid);
|
|
WiFi.begin(ssid, pass);
|
|
while (WiFi.status() != WL_CONNECTED) {
|
|
delay(500);
|
|
Serial.print(".");
|
|
}
|
|
Serial.println("");
|
|
Serial.println("WiFi connected");
|
|
Serial.println("IP address: ");
|
|
Serial.println(WiFi.localIP());
|
|
Serial.println("Starting UDP");
|
|
Udp.begin(listening_port);
|
|
Serial.print("Local port: ");
|
|
Serial.println(Udp.localPort());
|
|
Udp.flush();
|
|
|
|
//start osc processing
|
|
osc_task.restartDelayed(10);
|
|
|
|
//info
|
|
Serial.println();
|
|
Serial.println();
|
|
Serial.println("\"hi, i m your postman.\"");
|
|
Serial.println("-");
|
|
Serial.println("- my id: " + String(MY_ID) + ", gid: " + String(MY_GROUP_ID) + ", call me ==> \"" + String(MY_SIGN) + "\"");
|
|
Serial.println("- mac address: " + WiFi.macAddress() + ", channel: " + String(WIFI_CHANNEL));
|
|
Serial.println("-");
|
|
Serial.println("\".-.-.-. :)\"");
|
|
Serial.println();
|
|
|
|
//random seed
|
|
randomSeed(analogRead(0));
|
|
}
|
|
|
|
void loop() {
|
|
//
|
|
runner.execute();
|
|
//
|
|
}
|