bool COM_24g::sendFrame(RF24 _radioCom) { // First, stop listening so we can talk _radioCom.stopListening(); //Opening the writting Pipe _radioCom.openWritingPipe(_writingPipe); delay(20); //put in place the Paypload _payload.type = _dataType; _payload.version = _dataVersion; _payload.data = _data; bool Writestatus = _radioCom.write(&_payload, sizeof(_payload)); if (Writestatus) printf("Communication has been sent successfully. \n"); else printf("Communication has failed.\n\r"); //back in read mode _radioCom.startListening(); }
void loop(void){ const char text[] = "girish ramnani"; radio.write(text,sizeof(text)); }
boolean writePackage(void * package, unsigned char len) { radio.stopListening(); boolean temp = radio.write(package,32); radio.startListening(); return temp; }
void trans() { Serial.println("Enter a msg (max 32 Characters)"); while(!Serial.available()); delay(32); // for collection char tx[32]; for(int j=0;j<32;j++) { tx[j]=Serial.read(); if(tx[j]==(char)-1) // to avoid writing unkown char in spaces { tx[j]='\0'; goto loop1; } } loop1: loop2: bool done = radio.write(tx, sizeof(tx)); if(done==false) { retx++; Serial.println("Tx Failed"); if(retx<10) { goto loop2; }else retx=0; } radio.startListening(); print_welcome_message(); }
boolean sendRadioCommand(const byte cmd_buffer[]) { if( !radio_hw_available ) { debugPrint("Radio is NOT available"); return false; } int counter = 0; //byte cmd_buffer[] = { 0xFF, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00}; radio.stopListening(); debugPrint("Now sending payload: ",counter); boolean radio_write_ok = false; while( !radio_write_ok && counter < MAX_RADIO_RETRIES ) { radio_write_ok = radio.write(cmd_buffer,8); if( !radio_write_ok ) debugPrint("Retry send: ", counter++); } debugPrint("Payload sent. ",counter); radio.startListening(); return radio_write_ok; }
void add_names_to_devices(){ uint8_t i=0; uint64_t mask=0xFFFFFFFFFF000000LL; dev device; uint8_t tam; printf("Please add names to the devices\r\n"); while(load_address(&RFbuffer.destino,i)){ blink_led(); device.addr=RFbuffer.destino; RFbuffer.comando=all_on; radio.stopListening(); radio.openWritingPipe((RFbuffer.destino & mask)); radio.write(&RFbuffer,sizeof(RFbuffer)); radio.startListening(); printf("enter name for device:%d,with addr:%lX%08lX\r\n",i+1,(uint32_t)(device.addr>>32),(uint32_t)device.addr); while(!Serial.available()); do { blink_led(); tam=Serial.readBytes(device.name,sizeof(device)); if (tam>=sizeof(device.name)){ printf("name must be smaller than 7 letter\r\n"); }else{ device.name[tam]='\0'; printf("device name set to:"); int n=0; do{ printf("%c",device.name[n]); n++; } while (device.name[n]!='\0'); printf("\r\n"); file=SD.open("devs.lst",FILE_WRITE); if (file){ file.write((byte *)&device,sizeof(device)); } file.close(); } } while (tam>=sizeof(device.name)); RFbuffer.comando=all_off; radio.stopListening(); radio.openWritingPipe((RFbuffer.destino & mask)); radio.write(&RFbuffer,sizeof(RFbuffer)); radio.startListening(); i++; } printf("done\r\n"); return; }
void sendPacket(Packet packet) { radio.stopListening(); radio.openWritingPipe(base_pipe+packet.nodeId); //open pipe unique to the node radio.setAutoAck(0, false); radio.write( &packet, sizeof(Packet) ); radio.startListening(); }
/** fungsi untuk mengirim paket via radio @param paket* alamat ke paket @return ok bernilai true jika pengiriman berhasil, false jika sebaliknya */ bool kirim_paket(paket* paket_dikirim) { uint8_t yang_dikirim[PANJANG_PAKET]; toarray(paket_dikirim, yang_dikirim); printf("ngirim paket gan "); cetakpaket(paket_dikirim); radio.stopListening(); bool ok = radio.write(yang_dikirim, PANJANG_PAKET); radio.startListening(); return ok; }
void loop() { radio.stopListening(); uint8_t data[] = {111, 101}; bool ok = radio.write(data, 2); if (ok) printf("ok...\n\r"); else printf("failed.\n\r"); }
int main(int argc, char** argv) { printf("RF24 example starting.") /** Set up the radio **/ radio.begin(); radio.setRetries(15, 15); radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1, pipes[1]); radio.startListening(); /** Loop forever, writing and then listening for response **/ while (1) { /** Send out the current time **/ radio.stopListening(); unsigned long time = millis(); bool ok = radio.write(&time, sizeof(unsigned long)); if (!ok) printf("Failed to send for some reason.\n"); radio.startListening(); /** Start waiting around for the response **/ unsigned long started_waiting_at = millis(); bool timeout = false; while( !radio.available() && !timeout ) { if (millis() - started_waiting_at > 200) timeout = true; } /** Describe the results **/ if (timeout) { printf("Failed. Response timed out.\n") } else { unsigned long got_time; radio.read(&got_time, sizeof(unsigned long)) printf("Got response %lu, round-trip delay: %lu\n", got_time, millis() - got_time); sleep(1); } }
void loop(void) { // // Ping out. // // The payload will always be the same, what will change is how much of it we send. static char send_payload[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ789012"; // First, stop listening so we can talk. radio.stopListening(); // Take the time, and send it. This will block until complete printf("Now sending length %i...",next_payload_size); radio.write( send_payload, next_payload_size ); // Now, continue listening radio.startListening(); // Wait here until we get a response, or timeout long started_waiting_at = __millis(); bool timeout = false; while ( ! radio.available() && ! timeout ) if (__millis() - started_waiting_at > 500 ) timeout = true; // Describe the results if ( timeout ) { printf("Failed, response timed out.\n\r"); } else { // Grab the response, compare, and send to debugging spew uint8_t len = radio.getDynamicPayloadSize(); radio.read( receive_payload, len ); // Put a zero at the end for easy printing receive_payload[len] = 0; // Spew it printf("Got response size=%i value=%s\n\r",len,receive_payload); } // Update size for next time. next_payload_size += payload_size_increments_by; if ( next_payload_size > max_payload_size ) next_payload_size = min_payload_size; sleep(1); }
uint8_t send(uint8_t * data_pointer){ // Stop listening so we can talk radio.stopListening(); // Send data. This is a blocking call. uint8_t result = radio.write(data_pointer, PAYLOADLEN); // Resume listening radio.startListening(); // Return the error code. If result is 0, there was a sending failure. return (result == 0); }
void loop(void) { // First, stop listening so we can talk. radio.stopListening(); bool ok = radio.write( &packet, PACKET_LENGTH); if (ok) printf("sent...%d\n\r",packet[2]); else printf("failed.\n\r"); sleep(1); packet[2]++; // packet[5]++; }
void loop(void) { char receivePayload[32]; uint8_t pipe = 0; while ( radio.available( &pipe ) ) { uint8_t len = radio.getDynamicPayloadSize(); radio.read( receivePayload, len ); // Display it on screen printf("Recv: size=%i payload=%s pipe=%i",len,receivePayload,pipe); // Send back payload to sender radio.stopListening(); // if pipe is 7, do not send it back if ( pipe != 7 ) { // Send back using the same pipe // radio.openWritingPipe(pipes[pipe]); time_t now = time(0); tm * gmtm = gmtime(&now); char * dt = asctime(gmtm); //sprintf(dt, "%d", time_t); strftime(dt, 20, "%Y-%m-%d %H:%M:%S", localtime(&now)); radio.write(dt,strlen(dt)); receivePayload[len]=0; printf("\t Send: size=%i payload=%s pipe:%i\n\r",strlen(dt),dt,pipe); } else { printf("\n\r"); } // Enable start listening again radio.startListening(); // Increase the pipe outside the while loop pipe++; // reset pipe to 0 if ( pipe > 5 ) pipe = 0; } usleep(20); }
bool switchLight(int action){ //This function send a message, the 'action', to the arduino and wait for answer //Returns true if ACK package is received //Stop listening radio.stopListening(); unsigned long message = action; printf("Now sending %lu...", message); //Send the message bool ok = radio.write( &message, sizeof(unsigned long) ); if (ok) printf("ok..."); else printf("failed.\n\r"); //Listen for ACK radio.startListening(); //Let's take the time while we listen unsigned long started_waiting_at = __millis(); bool timeout = false; //if(!radio.available() ){ // printf("No hay radio disponible\n"); // } while ( ! radio.available() && ! timeout ) { __msleep(10); if (__millis() - started_waiting_at > 5000 ) timeout = true; } if( timeout ){ //If we waited too long the transmission failed printf("Failed, response timed out.\n\r"); radio.printDetails(); return false; }else{ //If we received the message in time, let's read it and print it unsigned long got_time; radio.read( &got_time, sizeof(unsigned long) ); printf("Got response %lu, round-trip delay: %lu\n\r",got_time,__millis()-got_time); return true; } }
int main(int argc, char** argv){ uint8_t tank1pipes[][6] = {"1Node","2Node"}; uint8_t tank2pipes[][6] = {"3Node","4Node"}; if (argc > 1) { int tank; sscanf(argv[1],"%d", &tank); int num; sscanf(argv[2],"%d", &num); radio.begin(); radio.setRetries(15,15); if(tank>0 && tank < 3){ if(tank==1) { radio.openWritingPipe(tank1pipes[1]); radio.openReadingPipe(1,tank1pipes[0]); } if(tank==2) { radio.openWritingPipe(tank2pipes[1]); radio.openReadingPipe(1,tank2pipes[0]); } bool ok = radio.write( &num, sizeof(int) ); if (!ok){ printf("failed.\n"); } } else { printf("Usage: senddata <tanknumber> <action number>\n"); } } else { printf("Usage: senddata <tanknumber> <action number>\n"); } return 0; }
boolean pcmRX::txSel(byte sel, int timeoutDelay){ radi.write(&sel,sizeof(byte)); int result = radi.getDynamicPayloadSize(); if( result == 2 ){ return(1);} else{ Serial.println(result); if(result > 32){ SPI.setBitOrder(MSBFIRST); SPI.setDataMode(SPI_MODE0); SPI.setClockDivider(SPI_CLOCK_DIV4); digitalWrite(csPin,LOW); SPI.transfer( FLUSH_RX ); digitalWrite(csPin,HIGH); } if(timeoutDelay > 0){ delay(timeoutDelay);} return(0); } }
void loop(void) { radio.startListening(); delay(10); if ( radio.available() ) { while ( radio.available() ) { len = radio.getDynamicPayloadSize(); radio.read(receive_payload, len); receive_payload[len] = 0; printf("Payload size=%i value=%s\n\r", len, receive_payload); lcd.setCursor(0, 0); delay(1); lcd.print(receive_payload); } } radio.stopListening(); delay(1); radio.write( send_payload, 16 ); delay(10); }
void loop(void) { char receivePayload[32]; uint8_t pipe = 0; while ( radio.available( &pipe ) ) { uint8_t len = radio.getDynamicPayloadSize(); radio.read( receivePayload, len ); // Display it on screen printf("Recv: size=%i payload=%s pipe=%i",len,receivePayload,pipe); // Send back payload to sender radio.stopListening(); // if pipe is 7, do not send it back if ( pipe != 7 ) { // Send back using the same pipe // radio.openWritingPipe(pipes[pipe]); radio.write(receivePayload,len); receivePayload[len]=0; printf("\t Send: size=%i payload=%s pipe:%i\n\r",len,receivePayload,pipe); } else { printf("\n\r"); } // Enable start listening again radio.startListening(); // Increase the pipe outside the while loop pipe++; // reset pipe to 0 if ( pipe > 5 ) pipe = 0; } usleep(20); }
void loop(void) { DHT11Readings payload = getReadings(); Serial.print("Humidity (%): "); Serial.println(payload.humidity); Serial.print("Temperature (°C): "); Serial.println(payload.temperature); radio.stopListening(); Serial.print(F("Now sending length ")); Serial.println(sizeof(payload)); radio.write(&payload, sizeof(payload)); // Now, continue listening radio.startListening(); delay(55000); }
void updateRadio() { PosData& ctrlData = getCtrlData(); unsigned long now = millis(); if(now >= nextMessage) { unsigned long time = now; radio.stopListening(); bool ok = radio.write( &ctrlData, sizeof(PosData) ); radio.startListening(); unsigned long started_waiting_at = millis(); bool timeout = false; while ( ! radio.available() && ! timeout ) { if (millis() - started_waiting_at > 100 ) { timeout = true; } delay(1); } if(!timeout) { // Grab the response, compare, and send to debugging spew PosData imuData = {0.0, 0.0, 0.0}; radio.read( &imuData, sizeof(PosData) ); // Spew it Serial.print(imuData.roll); Serial.print(' '); Serial.print(imuData.pitch); Serial.print(' '); Serial.print(imuData.yaw); Serial.print(' '); Serial.print(millis()-started_waiting_at); Serial.print('\n'); } nextMessage += MSG_FREQUENCY; } }
//This part of program is executed forever. It is assumed that the Raspberry Pi is powered on 24 x 7 so that program runs forever. void loop(void) { radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.openReadingPipe(2,pipes[2]); radio.openReadingPipe(3,pipes[3]); time_t t; count++; FILE *F1; F1 = fopen("database.txt","a"); unsigned long incoming; if(radio.available()) //If any data packet is available on "ANY PIPE" { unsigned long got_time; bool done = false; while (!done) { done = radio.read( &got_time, sizeof(unsigned long) ); //Read the data printf("Got payload %lu...",got_time); time(&t); incoming = got_time%1000; //Finding out the node number because the format in which data is sent is ~ timing_data * 1000 + node_number unsigned long value = got_time/1000; //Finding out the timing data because the format in which data is sent is ~ timing_data * 1000 + node_number fprintf(F1, "%i %lu %lu %s", count,incoming,value,ctime(&t));//putting into a file to keep a log. Improve the data logging based on your requirements delay(20); } // First, stop listening so we can talk radio.stopListening(); radio.openWritingPipe(pipes[incoming-1]); //I must send back the confirmation to the sensor_node from which I received the data // Send the final one back. printf("Sent response.\n\r"); radio.write( &got_time, sizeof(unsigned long) ); // Now, resume listening so we catch the next packets. radio.startListening(); } }
void intHandler(){ // // Pong back role. Receive each packet, dump it out, and send it back // if ( role == role_pong_back ) { // if there is data ready if ( radio.available() ) { // Dump the payloads until we've gotten everything uint8_t len=0; while (radio.available()) { // Fetch the payload, and see if this was the last one. len = radio.getDynamicPayloadSize(); radio.read( receive_payload, len ); // Put a zero at the end for easy printing receive_payload[len] = 0; // Spew it printf("Got payload size=%i value=%s\n\r",len,receive_payload); } // First, stop listening so we can talk radio.stopListening(); // Send the final one back. radio.write( receive_payload, len ); printf("Sent response.\n\r"); // Now, resume listening so we catch the next packets. radio.startListening(); } } }
int main(int argc, char** argv) { int fr = atoi(argv[1]); int to = atoi(argv[2]); int ac = atoi(argv[3]); printf("vendor/TMRh20/RF24_RPi/Task\n"); // Refer to RF24.h or nRF24L01 DS for settings radio.begin(); delay(5); radio.setPayloadSize(10); radio.setRetries(15,15); // optionally, increase the delay between retries & # of retries //radio.setAutoAck(1); // Ensure autoACK is enabled radio.setAutoAck(0); // Ensure autoACK is disabled radio.setPALevel(RF24_PA_HIGH); radio.setDataRate(RF24_250KBPS); //radio.setCRCLength(RF24_CRC_8); radio.setChannel(114); radio.openWritingPipe(pipes[(to-1)]); // atoi() change a char to a int radio.openReadingPipe(1,pipes[(fr-1)]); radio.startListening(); radio.printDetails(); // First, stop listening so we can talk. radio.stopListening(); radio.powerUp(); // Take the time, and send it. This will block until complete char payload_send[10] = ""; snprintf(payload_send, 10, "to:%d,ac:%d", to, ac); char payload_send_size[10] = ""; snprintf(payload_send_size, 10, "%d", sizeof(payload_send)); printf("Sending ..\n"); printf("Payload size: "); printf(payload_send_size); printf("\n"); printf("Payload: "); printf(payload_send); printf("\n"); //bool ok = radio.write( &payload_send, 10 ); radio.write( &payload_send, 10 ); /*if (!ok){ printf("failed.\n"); exit(1); }*/ //radio.powerDown(); // Now, continue listening radio.startListening(); // Wait here until we get a response, or timeout (250ms) unsigned long started_waiting_at = millis(); bool timeout = false; // Reading temperature or humidity takes about 250 milliseconds! // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor) while ( ! radio.available() && ! timeout ) { if (millis() - started_waiting_at > 3000 ) { timeout = true; } } // Describe the results if ( timeout ) { printf("err: response timed out.\n"); exit(1); } else { // Grab the response, compare, and send to debugging spew char payload_receive[10] = ""; radio.read( &payload_receive, 10 ); char payload_receive_size[10] = ""; snprintf(payload_receive_size, 32, "%d", 10); // Spew it printf("Received ..\n"); printf("Payload size: "); printf(payload_receive_size); printf("\n"); printf("Payload: "); printf(payload_receive); printf("\n"); printf(payload_receive); exit(0); } exit(1); }
void loop(void) { // Read the current command from the user std::string command; std::getline(std::cin, command); std::cerr << "Got '" << command << "'.\n"; // Split the command on spaces std::stringstream ss("0 "); ss << command; ss << " 0"; unsigned char bytes[PAYLOAD]; int buf = 0; // Read each space-separated value into an integer and put it into bytes int used = 0; for (int i = 0; i < PAYLOAD && ss >> buf; i++) { bytes[i] = (unsigned char)buf; used = i; } std::cerr << "Read " << used << " bytes from stdin." << std::endl; // Stop listening so we can talk. radio.stopListening(); // Send the bytes std::cerr << "Sending bytes: "; for (int i = 0; i < used; i++) { std::cerr << (int)bytes[i] << " "; } std::cerr << std::endl; bool ok = radio.write( bytes, used ); if (ok) { std::cerr << "ok..." << std::endl; } else { std::cerr << "failed..." << std::endl; // TODO: retry! } // Now, continue listening radio.startListening(); // Wait here until we get a response, or timeout (500ms) unsigned long started_waiting_at = __millis(); bool timeout = false; while ( !radio.available() && ! timeout ) { __msleep(5); //add a small delay to let radio.available to check payload timeout = ((__millis() - started_waiting_at) > TIMEOUT); } // Describe the results if (timeout) { std::cerr << "response timed out..." << std::endl; // TODO: retry! } else { // Grab the response, compare, and send to debugging spew radio.read( bytes, PAYLOAD ); // TODO: replace PAYLOAD // Print the bytes for (int i = 0; i < PAYLOAD; i++) { std::cout << (unsigned int)bytes[i] << " "; } std::cout << std::endl; } }
boolean txSelX(byte sel, int timeoutDelay){ radi.write(&sel,1); if(radi.isAckPayloadAvailable() == 1){ radi.read(&tmpArr,sizeof(tmpArr)); return(1);} else{ if(timeoutDelay > 0){ delay(timeoutDelay);} return(0); } }
void loop() { char receivePayload[32]; uint8_t pipe = 0; while ( radio.available( &pipe ) ) { uint8_t len = radio.getDynamicPayloadSize(); radio.read( &p, sizeof(p) ); char temp[5]; char outBuffer[1024]=""; strcat(outBuffer, ""); strcat(outBuffer, "key="); strcat(outBuffer, p.id); int val = 0; if ((p.type & TEMPERATURE) == TEMPERATURE) { strcat(outBuffer,"&1="); sprintf(temp, "%3.2f", p.val[val++]/100.0); strcat(outBuffer, temp); } if ((p.type & HUMIDITY) == HUMIDITY) { strcat(outBuffer,"&2="); sprintf(temp, "%3.2f", p.val[val++]/100.0); strcat(outBuffer, temp); } if ((p.type & CURRENT) == CURRENT) { strcat(outBuffer,"&3="); sprintf(temp, "%3.2f", p.val[val++]/100.0); strcat(outBuffer, temp); } if ((p.type & LUMINOSITY) == LUMINOSITY) { strcat(outBuffer,"&4="); sprintf(temp, "%3.2f", p.val[val++]/100.0); strcat(outBuffer, temp); } if ((p.type & PRESSURE) == PRESSURE) { strcat(outBuffer,"&6="); sprintf(temp, "%3.2f", p.val[val++]/100.0); strcat(outBuffer, temp); } // Display it on screen printf("\n\rRecv: size:%i pipe:%i type:%d data:%s\n\r",len,pipe,p.type,outBuffer); sendToServer(outBuffer); // Send back payload to sender radio.stopListening(); // if pipe is 7, do not send it back if ( pipe != 7 ) { // Send back using the same pipe // radio.openWritingPipe(pipes[pipe]); radio.write(receivePayload,len); receivePayload[len]=0; printf("\t Send: size=%i payload=%s pipe:%i\n\r",len,receivePayload,pipe); } else { printf("\n\r"); } // Enable start listening again radio.startListening(); } //read on all pipes pipe++; if ( pipe > 5 ) pipe = 0; usleep(20); }
int main(int argc, char** argv){ // Print preamble: cout << "RF24/examples/pingpair_dyn/\n"; // Setup and configure rf radio radio.begin(); radio.enableDynamicPayloads(); radio.setRetries(5,15); radio.printDetails(); /********* Role chooser ***********/ printf("\n ************ Role Setup ***********\n"); string input = ""; char myChar = {0}; cout << "Choose a role: Enter 0 for receiver, 1 for transmitter (CTRL+C to exit) \n>"; getline(cin,input); if(input.length() == 1) { myChar = input[0]; if(myChar == '0'){ cout << "Role: Pong Back, awaiting transmission " << endl << endl; }else{ cout << "Role: Ping Out, starting transmission " << endl << endl; role = role_ping_out; } } /***********************************/ if ( role == role_ping_out ) { radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); } else { radio.openWritingPipe(pipes[1]); radio.openReadingPipe(1,pipes[0]); radio.startListening(); } attachInterrupt(interruptPin, INT_EDGE_FALLING, intHandler); //Attach interrupt to bcm pin 23 // forever loop while (1) { if (role == role_ping_out) { // The payload will always be the same, what will change is how much of it we send. static char send_payload[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ789012"; // First, stop listening so we can talk. radio.stopListening(); // Take the time, and send it. This will block until complete printf("Now sending length %i...",next_payload_size); radio.write( send_payload, next_payload_size ); // Now, continue listening radio.startListening(); // Wait here until we get a response, or timeout unsigned long started_waiting_at = millis(); bool timeout = false; while ( ! radio.available() && ! timeout ) if (millis() - started_waiting_at > 500 ) timeout = true; // Describe the results if ( timeout ) { printf("Failed, response timed out.\n\r"); } else { // Grab the response, compare, and send to debugging spew uint8_t len = radio.getDynamicPayloadSize(); radio.read( receive_payload, len ); // Put a zero at the end for easy printing receive_payload[len] = 0; // Spew it printf("Got response size=%i value=%s\n\r",len,receive_payload); } // Update size for next time. next_payload_size += payload_size_increments_by; if ( next_payload_size > max_payload_size ) next_payload_size = min_payload_size; // Try again 1s later delay(100); } } }
static void vTaskRoute(void* pvParam) { while (1) { if (node_type == NODE_SENSOR) { // apa ada paket yang mau masuk? if (!radio.available()) { // kalau nggak, kirim paketnya sekarang // rawan chaos: tambahkan mutex di sini // TODO: tambah flag untuk info data udah siap atau belum while(xSemaphoreTake(&sem_pckt, 0)) ; pckt.addr_s = addr_saya; pckt.addr_t = ADDR_SINK; xSemaphoreGive(&sem_pckt); kirim_paket(&pckt); } else { // tahan, ada paket masuk bool done = false; while (!done) { done = radio.read(&buf, PANJANG_PAKET); } // liat alamatnya, buat kita apa bukan? uint16_t addr_tujuan_paket = buf[5] << 8 | buf[4]; uint16_t addr_asal_paket = buf[3] << 8 | buf[2]; if (addr_tujuan_paket == addr_saya) { // apa yang mau dilakuin seandainya paket ini buat saya // misalnya ini perintah dari server atau informasi dari // tetangga printf("hore kita dapet paket "); cetakpaket(buf); ; } if (addr_asal_paket == addr_saya) { // ini paket yang mau saya kirim, keluar dari loop saat ini printf("paket ini sih punya saya "); cetakpaket(buf); continue; } // paket ini bukan dari saya dan bukan buat saya, forward ke node berikutnya printf("ada paket yang diterusin "); cetakpaket(buf); radio.write(&buf, PANJANG_PAKET); } delay_rand(); } else { bool done = false; uint8_t arr[PANJANG_PAKET]; if (radio.available()) { while (!done) done = radio.read(&arr, PANJANG_PAKET); printf("yang ditangkep: "); cetakpaket(arr); } } } }
int main(int argc, char** argv){ bool role_ping_out = true, role_pong_back = false; bool role = role_pong_back; printf("RF24/examples/GettingStarted/\n"); // Setup and configure rf radio radio.begin(); // optionally, increase the delay between retries & # of retries radio.setRetries(15,15); // Dump the configuration of the rf unit for debugging radio.printDetails(); /********* Role chooser ***********/ printf("\n ************ Role Setup ***********\n"); string input = ""; char myChar = {0}; cout << "Choose a role: Enter 0 for pong_back, 1 for ping_out (CTRL+C to exit) \n>"; getline(cin,input); if(input.length() == 1) { myChar = input[0]; if(myChar == '0'){ cout << "Role: Pong Back, awaiting transmission " << endl << endl; }else{ cout << "Role: Ping Out, starting transmission " << endl << endl; role = role_ping_out; } } /***********************************/ // This simple sketch opens two pipes for these two nodes to communicate // back and forth. if ( !radioNumber ) { radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); } else { radio.openWritingPipe(pipes[1]); radio.openReadingPipe(1,pipes[0]); } radio.startListening(); // forever loop while (1) { if (role == role_ping_out) { // First, stop listening so we can talk. radio.stopListening(); // Take the time, and send it. This will block until complete printf("Now sending...\n"); unsigned long time = millis(); bool ok = radio.write( &time, sizeof(unsigned long) ); if (!ok){ printf("failed.\n"); } // Now, continue listening radio.startListening(); // Wait here until we get a response, or timeout (250ms) unsigned long started_waiting_at = millis(); bool timeout = false; while ( ! radio.available() && ! timeout ) { if (millis() - started_waiting_at > 200 ) timeout = true; } // Describe the results if ( timeout ) { printf("Failed, response timed out.\n"); } else { // Grab the response, compare, and send to debugging spew unsigned long got_time; radio.read( &got_time, sizeof(unsigned long) ); // Spew it printf("Got response %lu, round-trip delay: %lu\n",got_time,millis()-got_time); } sleep(1); } // // Pong back role. Receive each packet, dump it out, and send it back // if ( role == role_pong_back ) { // if there is data ready if ( radio.available() ) { // Dump the payloads until we've gotten everything unsigned long got_time; // Fetch the payload, and see if this was the last one. while(radio.available()){ radio.read( &got_time, sizeof(unsigned long) ); } radio.stopListening(); radio.write( &got_time, sizeof(unsigned long) ); // Now, resume listening so we catch the next packets. radio.startListening(); // Spew it printf("Got payload(%d) %lu...\n",sizeof(unsigned long), got_time); delay(925); //Delay after payload responded to, minimize RPi CPU time } } } // forever loop return 0; }