Why Wemos D1 not respond after working for a while - c++

I’m trying to build a feeder machine on a pig farm by using the Infrared photoelectric switch Sensor E18-D80NK to control relay then send notifications to line and mqtt broker when it’s working. I have been testing for 2 days, it’s working normal, but third day, it’s not responding then I just press reset so it’s working again.
I’m wondering it may cause by board cause it happen only one of four boards that I tasted or may be my code cause I was confused why output to line send “connected” so many times it’s should sent only one time when connected to wifi, so I’m not sure pls help.
Question
Why board not responding after working normal for a while.
Why out output to line send "connected" more than one cause I put in void setup()
Pictures
Last line output since working
All code
extra library line notification library
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <TridentTD_LineNotify.h>
const char* ssid = "Artnaseaw-2.4G";
const char* password = "0812667120";
const char* mqttUser = "****";
const char* mqttPassword = "****";
const char* mqttServer = "******";
const int mqttPort = *****;
const char* linetoken = "********";
long lastMsg = 0;
String DataString;
int lastL=0;
WiFiClient espClient;
PubSubClient client(espClient);
const int ACTION = D8;
const int SENSOR = D2;
const char* host = "maker.ifttt.com";
const char *privateKey = "******";
const char *event = "*****";
String value1, value2;
String postData = "";
String MachineID="A01";
void setup() {
Serial.begin(115200);
pinMode(SENSOR, INPUT_PULLUP);
pinMode(ACTION, OUTPUT);
digitalWrite(SENSOR, LOW);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.println("Connecting to WiFi..");
}
Serial.println("Connected to the WiFi network");
client.setServer(mqttServer, mqttPort);
client.setCallback(callback);
while (!client.connected()) {
Serial.println("Connecting to MQTT...");
if (client.connect("test", mqttUser, mqttPassword )) {
Serial.println("connected");
} else {
Serial.print("failed with state ");
Serial.print(client.state());
delay(2000);
}
}
client.subscribe("command");
LINE.setToken(linetoken);
LINE.notify("Connected");
Serial.println("line send connected");
}
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived in topic: ");
Serial.println(topic);
Serial.print("Message:");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
Serial.println("-----------------------");
}
void loop() {
client.loop();
delay(5000);
int sensorValue = digitalRead(SENSOR);
long now = millis();
if (now - lastMsg > 60000)
{
lastMsg = now;
int sensorValue = digitalRead(SENSOR);
if (sensorValue == LOW){
Serial.println(" === Obstacle detected");
Serial.print(" realy OFF ");
digitalWrite(ACTION,LOW);
} else {
LINE.notify("send data to line ---working");
Serial.println(" === All Clear");
Serial.println(" relay ON ");
digitalWrite(ACTION,HIGH);
sendMessageToIFTTT();
sendSensorToMQTT();
}
}
}
void sendSensorToMQTT(){
char msg[100];
int count = 1;
DataString = "e18,location=test detest="+String(count);
DataString.toCharArray(msg, 100);
Serial.print("Publish message: ");
Serial.println(msg);
client.publish("e18", msg);
}
void sendMessageToIFTTT(){
WiFiClient client;
const int httpPort = 80;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
String url = "/trigger/";
url += event;
url += "/with/key/";
url += privateKey;
value1 = "Worked";
value2 = "1";
genJSonObject();
Serial.print("Requesting URL: ");
Serial.println(url);
Serial.println(postData);
client.print(String("GET ") + url + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n");
client.println("Content-Type: application/json");
client.print("Content-Length: ");
client.println(postData.length());
client.println();
client.println(postData);
client.println("Connection: close\r\n\r\n");
while (client.connected())
{
if (client.available())
{
String line = client.readStringUntil('\r');
Serial.print(line);
} else {
// No data yet, wait a bit
delay(50);
};
}
}
void genJSonObject()
{
postData = "{";
postData.concat("\"value1\":\"");
postData.concat(value1);
postData.concat("\",");
postData.concat("\"value2\":\"");
postData.concat(value2);
postData.concat("\"}");
}

Try to connect to another mqtt broker and see if it connects more than once in there too. If it happens the problem might be in the sketch. Otherwise, the cause may be with the IFTTT service.

Related

Arduino/ESP32 can't connect to to MQTT broker

I'm working on getting my ESP32 board (also Arduino R3 & Nano) to connect to a HiveMQ broker, but it will not connect. I've tried various ports, different brokers, disabling ad blocking on my network, etc., but nothing seems to make a difference.
#include <Arduino.h>
#include <ArduinoJson.h>
#include <WiFi.h>
#include <PubSubClient.h>
void MQTT_callback(char* topic, byte* message, unsigned int length);
void setup() {
Serial.begin(115200);
while (!Serial);
delay(250);
Serial.println("setup beginning");
Serial.print("Connecting to WiFi...");
WiFi.begin("...", "...");
for (int i=0; i<30 && WiFi.status() != WL_CONNECTED; ++i) {
Serial.print(".");
delay(250);
}
if (WiFi.status() != WL_CONNECTED) {
Serial.println(" failed");
Serial.println("Oh no, no Wifi!? You're back in 1980! That's horrible...");
return;
} else {
Serial.println(" connected!");
}
WiFiClient espClient;
PubSubClient client(espClient);
const char* MQTT_URL = "somereallylongstring.s2.eu.hivemq.cloud";
const int MQTT_PORT = 8883;
const char* MQTT_uid = "...";
const char* MQTT_pwd = "...";
const String MQTT_client = "esp32-client-" + WiFi.macAddress();
client.setServer(MQTT_URL, MQTT_PORT);
client.setCallback(MQTT_callback);
if (!client.connected()) {
Serial.println("Connecting to MQTT broker with client '" + MQTT_client + "'...");
for (int i=0; i<10 && !client.connected(); ++i) {
if (client.connect(MQTT_client.c_str(), MQTT_uid, MQTT_pwd)) {
Serial.println("Connected to MQTT broker");
} else {
Serial.print("Connection to MQTT broker failed: ");
#define C(x) case (x): Serial.println(#x); break;
switch (client.state()) {
C(MQTT_CONNECTION_TIMEOUT)
C(MQTT_CONNECTION_LOST)
C(MQTT_CONNECT_FAILED)
C(MQTT_DISCONNECTED)
C(MQTT_CONNECTED)
C(MQTT_CONNECT_BAD_PROTOCOL)
C(MQTT_CONNECT_BAD_CLIENT_ID)
C(MQTT_CONNECT_UNAVAILABLE)
C(MQTT_CONNECT_BAD_CREDENTIALS)
C(MQTT_CONNECT_UNAUTHORIZED)
}
#undef C
}
}
}
if (client.connected()) {
const char* topic = "/sensors/sean/salt_tank";
StaticJsonDocument<MQTT_MAX_PACKET_SIZE> doc;
doc["ts"] = "2023-01-15 20:24:00";
doc["temp"] = 82.1;
doc["tds"] = 821;
doc["ph"] = 7.6;
String output;
serializeJson(doc, output);
Serial.println("Publishing message to " + String(topic) + output);
client.publish(topic, output.c_str());
}
Serial.println("setup complete!");
}
void loop() {
}
void MQTT_callback(char* topic, byte* message, unsigned int length) {
String msg = "";
for (int i=0; i<length; ++i)
msg += (char)message[i];
Serial.println("Message arrived on topic " + String(topic) + ":");
Serial.println(msg);
}
Here's the output:
22:11:00.629 > setup beginning
22:11:00.631 > Connecting to WiFi........ connected!
22:11:02.001 > Connecting to MQTT broker with client 'esp32-client-08:3A:F2:B8:8B:CC'...
22:11:17.512 > Connection to MQTT broker failed: MQTT_CONNECTION_TIMEOUT
22:11:32.670 > Connection to MQTT broker failed: MQTT_CONNECTION_TIMEOUT
I don't know if this makes a difference, but I'm using an ARM MacBook. I don't know if the difference in libraries could be causing an issue or not. Thanks!

mqtt error code RC = -1 connecting while esp32 to aws

I am going to establish a mqtt connection to aws. DHT senstor reading must be sent from esp32 to aws. How can I fix the error RC = -1 when connecting esp32 to aws. I receive this error in serial monitor :
Attempting MQTT connection...failed, rc=-1 try again in 5 seconds
What can be the reaon?
My code is as follows:
#include "SPIFFS.h"
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <DHT.h> // library for getting data from DHT
// Enter your WiFi ssid and password
const char* ssid = "TP-Link_DBCA"; //Provide your SSID
const char* password = "44388027"; // Provide Password
const char* mqtt_server = "a3k7086cinb3bt-ats.iot.us-west-2.amazonaws.com"; // Relace with your MQTT END point
const int mqtt_port = 8883;
String Read_rootca;
String Read_cert;
String Read_privatekey;
#define BUFFER_LEN 256
long lastMsg = 0;
char msg[BUFFER_LEN];
int Value = 0;
byte mac[6];
char mac_Id[18];
int count = 1;
WiFiClientSecure espClient;
PubSubClient client(espClient);
#define DHTPIN 4 //pin where the DHT22 is connected
DHT dht(DHTPIN, DHT11);
void setup_wifi() {
delay(10);
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
randomSeed(micros());
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived [");
Serial.print(topic);
Serial.print("] ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
}
void reconnect() {
// Loop until we're reconnected
while (!client.connected()) {
Serial.print("Attempting MQTT connection...");
// Create a random client ID
String clientId = "ESP32-";
clientId += String(random(0xffff), HEX);
// Attempt to connect
if (client.connect(clientId.c_str())) {
Serial.println("connected");
// Once connected, publish an announcement...
client.publish("ei_out", "hello world");
// ... and resubscribe
client.subscribe("ei_in");
} else {
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void setup() {
Serial.begin(115200);
dht.begin();
// initialize digital pin LED_BUILTIN as an output.
pinMode(2, OUTPUT);
setup_wifi();
delay(1000);
//=============================================================
if (!SPIFFS.begin(true)) {
Serial.println("An Error has occurred while mounting SPIFFS");
return;
}
//=======================================
//Root CA File Reading.
File file2 = SPIFFS.open("/AmazonRootCA1.pem", "r");
if (!file2) {
Serial.println("Failed to open file for reading");
return;
}
Serial.println("Root CA File Content:");
while (file2.available()) {
Read_rootca = file2.readString();
Serial.println(Read_rootca);
}
//=============================================
// Cert file reading
File file4 = SPIFFS.open("/certificate.pem.crt.txt", "r");
if (!file4) {
Serial.println("Failed to open file for reading");
return;
}
Serial.println("Cert File Content:");
while (file4.available()) {
Read_cert = file4.readString();
Serial.println(Read_cert);
}
//=================================================
//Privatekey file reading
File file6 = SPIFFS.open("/private.pem.key", "r");
if (!file6) {
Serial.println("Failed to open file for reading");
return;
}
Serial.println("privateKey File Content:");
while (file6.available()) {
Read_privatekey = file6.readString();
Serial.println(Read_privatekey);
}
//=====================================================
char* pRead_rootca;
pRead_rootca = (char *)malloc(sizeof(char) * (Read_rootca.length() + 1));
strcpy(pRead_rootca, Read_rootca.c_str());
char* pRead_cert;
pRead_cert = (char *)malloc(sizeof(char) * (Read_cert.length() + 1));
strcpy(pRead_cert, Read_cert.c_str());
char* pRead_privatekey;
pRead_privatekey = (char *)malloc(sizeof(char) * (Read_privatekey.length() + 1));
strcpy(pRead_privatekey, Read_privatekey.c_str());
Serial.println("================================================================================================");
Serial.println("Certificates that passing to espClient Method");
Serial.println();
Serial.println("Root CA:");
Serial.write(pRead_rootca);
Serial.println("================================================================================================");
Serial.println();
Serial.println("Cert:");
Serial.write(pRead_cert);
Serial.println("================================================================================================");
Serial.println();
Serial.println("privateKey:");
Serial.write(pRead_privatekey);
Serial.println("================================================================================================");
espClient.setCACert(pRead_rootca);
espClient.setCertificate(pRead_cert);
espClient.setPrivateKey(pRead_privatekey);
client.setServer(mqtt_server, mqtt_port);
client.setCallback(callback);
//====================================================================================================================
WiFi.macAddress(mac);
snprintf(mac_Id, sizeof(mac_Id), "%02x:%02x:%02x:%02x:%02x:%02x",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
Serial.print(mac_Id);
//=====================================================================================================================
delay(2000);
}
void loop() {
float h = 80; // Reading Temperature form DHT sensor
float t = 22.5; // Reading Humidity form DHT sensor
float tF = (t * 1.8) + 32;
if (isnan(h) || isnan(t))
{
Serial.println("Failed to read from DHT sensor!");
return;
}
if (!client.connected()) {
reconnect();
}
client.loop();
long now = millis();
if (now - lastMsg > 2000) {
lastMsg = now;
//=============================================================================================
String macIdStr = mac_Id;
String Temprature = String(t);
String Humidity = String(h);
snprintf (msg, BUFFER_LEN, "{\"mac_Id\" : \"%s\", \"Temprature\" : %s, \"Humidity\" : \"%s\"}", macIdStr.c_str(), Temprature.c_str(), Humidity.c_str());
Serial.print("Publish message: ");
Serial.print(count);
Serial.println(msg);
client.publish("temp/", msg);
count = count + 1;
//================================================================================================
}
digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}```

MQTT client not subscribing to a given topic (or callback not working as intended)

I'm going nuts trying to guess why my Arduino Nano33 is not being able to receive mqtt messages. Or may be it receives them but the callback function is not working as I intend (since the callback is the only way I have to see if a message was received).
I can publish messages without problem. Any clues on what can be wrong in my code? (I have zero experience with C++ so it could be some stupid mistake).
I'm copying the entire code in case the issue is somewhere else, but I guess the key functions to look at are callback and setup.
#include <WiFiNINA.h>
#include <PubSubClient.h>
#include <Arduino_LSM6DS3.h>
#include "credentials.h"
const char* ssid = SSID_WIFI;
const char* password = PW_WIFI;
const char* mqttServer = MQTT_SERVER;
const int mqttPort = MQTT_PORT;
const char* mqttUsername = MQTT_USRNM;
const char* mqttPassword = MQTT_PW;
char pubTopic[] = "sensors/imu1/values";
char subTopic[] = "sensors/imu1/mode";
WiFiSSLClient wifiClient; //SSL
PubSubClient client(wifiClient);
void setup_wifi()
//Connect to wifi network
{
delay(10);
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
randomSeed(micros());
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void callback(char* topic, byte* payload, unsigned int length) {
//char* payload_chr;
Serial.print("Message arrived [");
Serial.print(topic);
Serial.print("] ");
for (int i=0;i<length;i++) {
//payload_chr[i] = (char)payload[i];
Serial.print((char)payload[i]);
}
Serial.println();
//String message = payload_chr;
//Serial.print(message);
}
void reconnect()
{
// Loop until we're reconnected
while (!client.connected())
{
Serial.print("Attempting MQTT connection...");
String clientId = "Nano33-";
clientId += String(random(0xffff), HEX);
// Attempt to connect
if (client.connect(clientId.c_str(), mqttUsername, mqttPassword))
{
Serial.println("connected");
// ... and resubscribe
client.subscribe(subTopic);
} else
{
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void setup()
{
Serial.begin(9600);
setup_wifi();
client.setServer(mqttServer, mqttPort);
client.setCallback(callback);
if (!IMU.begin()) {
Serial.println("Failed to initialize IMU!");
while (1);
}
Serial.println("IMU initialized!");
}
void publish_imu_values(float x_acc, float y_acc, float z_acc,
float x_gyr, float y_gyr, float z_gyr){
//Publish imu readings in InfluxDB Line Protocol format
String temp_str;
char mensaje[100];
temp_str = "imu x_acc=";
temp_str += String(x_acc);
temp_str += ",y_acc=";
temp_str += String(y_acc);
temp_str += ",z_acc=";
temp_str += String(z_acc);
temp_str += ",x_gyr=";
temp_str += String(x_gyr);
temp_str += ",y_gyr=";
temp_str += String(y_gyr);
temp_str += ",z_gyr=";
temp_str += String(z_gyr);
temp_str.toCharArray(mensaje, temp_str.length() + 1);
client.publish(pubTopic, mensaje);
}
void loop()
{
if (!client.connected())
{
reconnect();
}
float x_acc, y_acc, z_acc;
float x_gyr, y_gyr, z_gyr;
if (IMU.accelerationAvailable() && IMU.gyroscopeAvailable()) {
IMU.readAcceleration(x_acc, y_acc, z_acc);
IMU.readGyroscope(x_gyr, y_gyr, z_gyr);
publish_imu_values(x_acc, y_acc, z_acc, x_gyr, y_gyr, z_gyr);
}
delay(1000);
}
You need a client.loop(); line in your loop() main function. Without that line, you MQTT code never gets executed.

Connecting an Arduino ESP32 microcontroller to javafx via PacketSender

We have built a drone controller using C++ and an Arduino ESP32 module. We have achieved connection to a Tello Drone and can control it successfully. However, now we want to connect our controller to a javafx program that receives input and then draws on a canvas in scene builder.
Meanwhile the problem is that we can't seem to connect our controller through PacketSender. We have attached our code, including the previous built that enabled connection with a drone.
The big question is how to send the messages between two programs and initiate our virtual depiction of our drone on a canvas - instead of the actual physical one.
The issue seems to be in case 1, line 190, where we connected controller to actual drone, but now have to write up a new connection somehow.
#include <Arduino.h>
#include "WiFi.h"
#include "AsyncUDP.h"
const char * ssid = "OnePlus 7 Pro";
const char * password = "hej12345";
//Connect button variables (Command)
int inPinLand = 18;
int valLand = 0;
//Ultra sonic sensor variables
#define trigPin 2
#define echoPin 21
//Land button variables (Land)
int inPin = 25;
int val = 0;
//Instantiate specific drone
const char * networkName = "TELLO-59F484";
const char * networkPswd = "";
//IP address to send UDP data to:
// either use the ip address of the server or
// a network broadcast address
const char * udpAddress = "10.60.0.227";
const int udpPort = 7000;
boolean connected = false;
char fromTello[256];
unsigned long timer;
//static const byte glyph[] = { B00010000, B00110100, B00110000, B00110100, B00010000 };
//static PCD8544 lcd;
uint8_t state = 0;
//Controller movement variables
int pitch = 0;
int roll = 0;
int yaw = 0;
int throttle = 0;
char cmd[256];
AsyncUDP udp;
void setup() {
Serial.begin(9600);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
if (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println("WiFi Failed");
while (1) {
delay(1000);
}
}
pinMode(5, OUTPUT);
digitalWrite(5, HIGH);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(inPin, INPUT);
pinMode(inPinLand, INPUT);
//LCD screen initialization
//lcd.begin(84, 48);
Serial.begin(9600);
//pinMode(trigPin, OUTPUT);
//pinMode(echoPin, INPUT);
//pinMode(BL, OUTPUT);
//digitalWrite(BL, HIGH);
if (udp.listen(7000)) {
Serial.print("UDP Listening on IP: ");
Serial.println(WiFi.localIP());
udp.onPacket([](AsyncUDPPacket packet) {
Serial.print("UDP Packet Type: ");
Serial.print(packet.isBroadcast()
? "Broadcast"
: packet.isMulticast() ? "Multicast" : "Unicast");
Serial.print(", From: ");
Serial.print(packet.remoteIP());
Serial.print(":");
Serial.print(packet.remotePort());
Serial.print(", To: ");
Serial.print(packet.localIP());
Serial.print(":");
Serial.print(packet.localPort());
Serial.print(", Length: ");
Serial.print(packet.length());
Serial.print(", Data: ");
Serial.write(packet.data(), packet.length());
Serial.println();
// reply to the client/sender
packet.printf("Got %u bytes of data", packet.length());
});
}
// Send unicast
// udp.print("Hello Server!");
// udp.
}
//WiFi connection function
void connectToWiFi(const char * ssid, const char * pwd) {
Serial.println("Connecting to WiFi network: " + String(ssid));
// delete old config
WiFi.disconnect(true);
//Initiate connection
WiFi.begin(ssid, pwd);
Serial.println("Waiting for WIFI connection...");
}
//Drone connection function
void TelloCommand(char *cmd) {
//only send data when connected
if (connected) {
//Send a packet
//udp.beginPacket(udpAddress, udpPort); OUTDATED has new name with ASync
udp.printf(cmd);
//udp.endPacket(); OUTDATED has new name with ASync
Serial.printf("Send [%s] to Tello.\n", cmd);
}
}
void sendMessage(String msg){
udp.writeTo((const uint8_t *)msg.c_str(), msg.length(),
IPAddress(169, 254, 107, 16), 4000);
}
void loop() {
delay(5000);
// Send broadcast on port 4000
udp.broadcastTo("Anyone here?", 4000);
// Serial.println("waiting for udp message...");
int x = 100;
int y = 100;
sendMessage("init " + String(x) + " " + String(y));
}
void loop() {
long duration, distance;
val = digitalRead(inPin); // read input value
//Ultra sonic sensor
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = (duration / 2) / 29.1;
//LCD screen line 2
// lcd.setCursor(0, 1);
// lcd.print(distance, DEC);
//State machine that connects the drone to WiFi and the controller
switch (state)
{
case 0: //Idle not connected
//LCD screen line 1
//lcd.setCursor(0, 0);
//lcd.print("Controller");
if (val == HIGH)
{
state = 1;
connectToWiFi(networkName, networkPswd);
timer = millis() + 5000;
}
break;
case 1: //Trying to connect
if (WiFi.status() == WL_CONNECTED)
{
Serial.print("Connected to: ");
Serial.println(networkName);
udp.begin(WiFi.localIP(), udpPort);
connected = true;
TelloCommand("command");
timer = millis() + 2000;
state = 2;
}
if (millis() > timer)
{
state = 0;
}
break;
case 2: //Connected on ground
//lcd.setCursor(0, 0);
//lcd.print("Connected ");
if (WiFi.status() != WL_CONNECTED)
{
WiFi.disconnect(true);
Serial.println("Disconnected");
state = 0;
}
if (distance < 10)
{
TelloCommand("takeoff");
timer = millis() + 1000;
state = 3;
Serial.println("takeoff");
}
break;
case 3: //In air
//lcd.setCursor(0, 0);
//lcd.print("In air ");
if (millis() > timer)
{
timer = millis() + 20;
pitch = map(analogRead(34) - 1890, -2000, 2000, -100, 100);
roll = map(analogRead(35) - 1910, -2000, 2000, -100, 100);
throttle = map(analogRead(33) - 1910, -2000, 2000, -100, 100);
yaw = map(analogRead(32) - 1910, -2000, 2000, -100, 100);
sprintf(cmd, "rc %d %d %d %d", roll, pitch, throttle, yaw);
TelloCommand(cmd);
}
if (val == HIGH) {
TelloCommand("land");
timer = millis() + 1000;
state = 0;
Serial.println("land");
}
break;
}
delay(200);
}

My receiving data is correct, but it can't save in the new variable

Why the d value does not equal to the data I got?
I try to let nodemcu get the NTP time and send it to the Arduino UNO. Arduino receives the data from nodemcu, then arrange them into the char data. It went alright so far.
However, when I set the new char to save the data, the value I printed always show the snark mark.
How could I fix it?
Here is Arduino UNO code
#include <SoftwareSerial.h>
SoftwareSerial s(5,6);
void setup() {
// Initialize Serial port
Serial.begin(9600);
s.begin(9600);
while (!Serial) continue;
}
int k=0;
void seting(char d){
if(k==0){
Serial.print("get = ");
Serial.println(d);
Serial.println("set Y");
}else if(k==1){
Serial.print("get = ");
Serial.println(d);
Serial.println("set M");
}else if(k==2){
Serial.print("get = ");
Serial.println(d);
Serial.println("set D");
}else if(k==3){
Serial.print("get = ");
Serial.println(d);
Serial.println("set WD");
}else if(k==4){
Serial.print("get = ");
Serial.println(d);
Serial.println("set H");
}else if(k==5){
Serial.print("get = ");
Serial.println(d);
Serial.println("set min");
}else if(k==6){
Serial.print("get = ");
Serial.println(d);
Serial.println("set sec");
}else{
k=0;
}k++;
}
int i = 0;
char data[4];
void loop() {
while(s.available()){
char x = s.read();
if(isdigit(x)){
data[i]=x;
i++;
}
else{
Serial.print("data=");
Serial.println(data);
seting(data);
memset(data,0,sizeof(data));
i=0;
}
}
}
Here is nodemcu code
#include <NTPClient.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <SoftwareSerial.h>
SoftwareSerial s(D6,D5);
const char *ssid = "dlink-0C00";
const char *password = "yjjri18598";
const long utcOffsetInSeconds = 28800;//TW+8,8*60*60
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
String formattedDate;
String dayStamp;
String timeStamp;
//Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "asia.pool.ntp.org", utcOffsetInSeconds);
void setup(){
Serial.begin(9600);
s.begin(9600);
WiFi.begin(ssid, password);
while ( WiFi.status() != WL_CONNECTED ) {
delay ( 500 );
Serial.print ( "." );
}
timeClient.begin();
}
void loop() {
timeClient.update();
formattedDate = timeClient.getFormattedDate();
int splitT = formattedDate.indexOf("T");
dayStamp = formattedDate.substring(0, splitT);
Serial.print("DATE: ");
Serial.print(dayStamp);
s.print(dayStamp);
s.print("/");
Serial.print(", ");
Serial.println(daysOfTheWeek[timeClient.getDay()]);
s.print(timeClient.getDay());
s.print("/");
/*timeStamp = formattedDate.substring(splitT+1, formattedDate.length()-1);
Serial.print("TIME:");
Serial.println(timeStamp);*/
int hour = timeClient.getHours();
int minute = timeClient.getMinutes();
int second = timeClient.getSeconds();
Serial.print("TIME:");
Serial.print(hour);
s.print(hour);
Serial.print(":");
s.print(":");
Serial.print(minute);
s.print(minute);
Serial.print(":");
s.print(":");
Serial.println(second);
s.print(second);
//s.write(timeStamp);
s.write("/");
delay(1000);
}
The argument passed to your function seting() is char array pointer of char data[4]; which may be why your output is not correct. In Arduino code, try changing:
void seting(char d){
to
void seting(char *d){
as the data passed to seting() is an array:
char data[4];
Also modify your println(d) to use k as index into the input argument d to println(d[k]). If that fixes it, you may want to adjust the size of the char data[4] to char data[7] so it can be indexed with k which seems to go from 0 to 6 according to the Arduino code posted.