Hello,
for this project I am using a pair of Pro Micro with ATMEGA32U4, 5 V, 16 MHz.
I am trying to write a simple half-duplex rf 433Mhz protocol with a master and X slaves.
Slaves must register theirself on master and send a keepalive.
In attachment you can see what program should do now.
Example:
- Master broadcast its name: M2;
- Slave receive M2 and broadcast M2 I am SX;
- Master "Hey SX, yeah, now we are friends". I add you to the list of friends of mine.
- Periodically master ask slaves: "Hey SX are you still there?". No? I remove you from my list.
The problem is that slaves lost the name of the master stored in variable masterId (you can see details in my second post).
I spent hour to search it, but i didn't find it 
I really don't understand where the program lost this value.
Thanks if you find it 
PS: and i am open to advices, i am new in arduino programming 
Receiver (Slave):
//Receiver Code (Leonardo)
#include <VirtualWire.h>
uint8_t buflen = VW_MAX_MESSAGE_LEN;
char ACK = 'K';
char INIT_SLAVE = 'I';
char SLAVE_PREF = 'S';
char SLAVE_NEW_ID = 'N';
char* EMPTY = "ER";
char* slaveIdentifier = "S2";
char* masterId ="M2";
void setup() {
delay(2000);
Serial.begin(9600);
pinMode(13, OUTPUT);
digitalWrite(13, LOW);
vw_setup(2000);
vw_set_tx_pin(8);
vw_set_rx_pin(7);
vw_rx_start();
randomSeed(42);
}
void loop() {
//Cerco un master
masterId = lookForMaster();
//Chiedo al master di darmi un id
requestNewSlaveID(masterId);
return;
//Aspetto che mi venga assegnato un id
slaveIdentifier = getNewIDFromMaster(masterId);
delay(99999);
}
char* lookForMaster() {
Serial.println(F("Looking for master..."));
boolean masterFound = false;
do {
uint8_t buf[buflen];
vw_wait_rx();
if (vw_get_message(buf, &buflen)) {
char masterId[buflen + 1];
int i = 0;
for (i = 0; i < buflen; i++) {
masterId[i] = (char) buf[i];
}
masterId[i] = '\0';
if (masterId[0] == 'M' && sizeof(masterId) == 3) {
Serial.print(F("Master found: "));Serial.println(masterId);
return masterId;
}
}
} while (true);
return slaveIdentifier;
}
void requestNewSlaveID(char* masterId) {
//char *masterId1 = "M2";
send(slaveIdentifier, masterId, INIT_SLAVE);
}
char* getNewIDFromMaster(char* masterId) {
Serial.println(F("Waiting new slaveID from master..."));
char* message;
do {
message = listenMessagesForMe();
} while (sizeof(message) == 0 || message == EMPTY);
Serial.print(F("New slaveIdentifier: "));
Serial.println(message);
Serial.println(F("Confirming to master my new id..."));
return message;
}
char* listenMessagesForMe() {
//delay(25);
uint8_t buf[VW_MAX_MESSAGE_LEN];
vw_wait_rx_max(300);
if (vw_get_message(buf, &buflen)) { // Non-blocking
char sender[3];
char command;
char recipient[3];
char message[buflen + 1 ];
int i;
// Message with a good checksum received, dump it.
for (i = 0; i < buflen; i++) {
message[i] = (char) buf[i];
}
for (i = 0; i < buflen; i++) {
if ( (message[i] >= '0' && message[i] <= '9') || (message[i] >= 'A' && message[i] <= 'Z')) {
//Controllo se il messaggio è per me, altrimenti esco
if (i < sizeof(slaveIdentifier) && message[i] != slaveIdentifier[i]) {
Serial.println(F("Messaggio per altri: ")); Serial.println(message);
return EMPTY;
}
if (i == sizeof(slaveIdentifier)) {
command = message[i];
}
else if (i > sizeof(slaveIdentifier)) {
recipient[i - sizeof(slaveIdentifier) - 1] = message[i];
recipient[i - sizeof(slaveIdentifier)] = '\0';
}
} else {
Serial.println(F("Carattere non valido: "));
return EMPTY;
}
}
message[i] = '\0';
Serial.println(message);
Serial.print(F("Command: ")); Serial.println(command);
Serial.print(F("Recipient: ")); Serial.println(recipient);
if (command != ACK) {
received(slaveIdentifier, recipient);
}
return message;
}
Serial.println(F("Messaggio vuoto "));
return EMPTY;
}
void send(char* sender, char* receiver, char command) {
char tosend[(sizeof(sender) ) + (sizeof(receiver) ) + 1 + 1];
Serial.print(F("SizeofTosend:")); Serial.println(sizeof(tosend));
int i = 0;
for (int r = 0; r < sizeof(receiver) ; ++r, ++i) {
tosend[i] = receiver[r];
Serial.print(F("[1]IndexofTosend:")); Serial.println(tosend[i]);
}
tosend[i] = command;
Serial.print(F("[2]IndexofTosend:")); Serial.println(tosend[i]);
i++;
for (int r = 0; r < sizeof(sender); ++r, ++i) {
tosend[i] = sender[r];
Serial.print(F("[2]IndexofTosend:")); Serial.println(tosend[i]);
}
tosend[i] = '\0';
Serial.print(F("ToSend: ")); Serial.println(tosend);
do {
send(tosend);
delay(random(50, 500));
} while (!isReceived(sender, receiver) );
free(tosend);
}
boolean isReceived(char* sender, char* receiver) {
char ackMessage[sizeof(sender) + sizeof(receiver) + 1 + 1];
Serial.print(F("SizeofackMessage:")); Serial.println(sizeof(ackMessage));
int i = 0;
for (int r = 0; r < sizeof(receiver) ; ++r, ++i) {
ackMessage[i] = receiver[r];
Serial.print(F("[1]IndexofackMessage:")); Serial.println(ackMessage[i]);
}
ackMessage[i] = ACK;
Serial.print(F("[2]IndexofackMessage:")); Serial.println(ackMessage[i]);
i++;
for (int r = 0; r < sizeof(sender); ++r, ++i) {
ackMessage[i] = sender[r];
Serial.print(F("[2]IndexofackMessage:")); Serial.println(ackMessage[i]);
}
ackMessage[i] = '\0';
Serial.print(F("ackMessage: ")); Serial.println(ackMessage);
char* message = "M2KS2";//listenMessagesForMe();
Serial.print(F("ackMessage: ")); Serial.println(message);
if (message == EMPTY) {
return false;
}
if (sizeof(ackMessage) - 1 != strlen(message)) {
Serial.print(F("Different size ")); Serial.print(strlen(message) -1); Serial.println(sizeof(ackMessage));
//free(ackMessage);
//free(message);
return false;
}
for (int i = 0; i < sizeof(ackMessage) && i < sizeof(message); ++i) {
if (ackMessage[i] != message[i]) {
Serial.println(F("Caratteri diversi"));
//free(ackMessage);
// free(message);
return false;
}
}
Serial.println(F("RECEIVED!"));
//free(ackMessage);
//free(message);
return true;
}
void extractElements(char srcArray[], char subArray[], int n)
{
for (char i = 0; i < n; i++)
{
subArray[i] = srcArray[i];
}
}
void received(char* sender, char* receiver) {
send(sender, receiver, ACK);
}
void send(char* message) {
waitChannelFree();
vw_send((uint8_t *)message, strlen(message));
vw_wait_tx(); // Wait until the whole message is gone
}
void waitChannelFree() {
uint8_t buf[buflen];
do {
delay(random(150, 800));
} while (vw_get_message(buf, &buflen)) ;
}
