void setupRadio() { printf_begin(); // Setup and configure radio radio.begin(); radio.setAutoAck(1); // Ensure autoACK is enabled radio.enableAckPayload(); // Allow optional ack payloads radio.setRetries(2,15); // Smallest time between retries, max no. of retries radio.setPayloadSize(8); radio.setDataRate(RF24_250KBPS); if( radio.getDataRate() == RF24_250KBPS ) { debugPrint("Radio is available"); radio_hw_available = true; radio.startListening(); // Start listening radio.powerUp(); radio.openWritingPipe(pipes[0]); // Open different pipes when writing. Write on pipe 0, address 0 radio.openReadingPipe(1,pipes[1]); // Read on pipe 1, as address 1 } else { debugPrint("Radio is NOT available"); } //radio.printDetails(); // Dump the configuration of the rf unit for debugging }
void pcmRF::broadcast(byte device){ noInterrupts(); if(device == 255){ radi.openWritingPipe(addresses[1]); }else{ radi.openWritingPipe(addresses[device+2]); } interrupts(); }
void pcmRF::play(char* filename, byte device){ stop(); rfPlaying = 1; if(device == 255){ radi.openWritingPipe(addresses[1]); }else{ radi.openWritingPipe(addresses[device+2]); } #if !defined(SDFAT) if(!txFile){ txFile = SD.open(filename);} if(txFile){ txFile.seek(24); //skip the header info #else if(!txFile.isOpen()){ txFile.open(filename);} if(txFile.isOpen()){ txFile.seekSet(24); //skip the header info #endif unsigned int SAMPLE_RATE = txFile.read(); SAMPLE_RATE |= txFile.read() << 8; #if !defined(SDFAT) txFile.seek(44); #else txFile.seekSet(44); #endif unsigned int res = (10 * (1600000/SAMPLE_RATE)) * 32; noInterrupts(); ICR1 = res; TCCR1A = _BV(WGM11); TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10); TIMSK1 = ( _BV(OCIE1A) ); interrupts(); }else{ #if defined (debug) Serial.println("failed to open music file"); #endif } } ISR(TIMER1_COMPA_vect){ radi.writeFast(&buff,32); txFile.read((byte*)buff,32); if(txFile.available() < 32){ radi.txStandBy(); stop(); } }
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 setup(void) { TRI_LOG(sizeof(long)); TRI_LOG(sizeof(int)); // Refer to RF24.h or nRF24L01 DS for settings TRI_LOG_STR("radio.begin()"); radio.begin(); TRI_LOG_STR("CONFIGURE_RADIO(radio)"); CONFIGURE_RADIO(radio); // Open 6 pipes for readings ( 5 plus pipe0, also can be used for reading ) radio.openWritingPipe(WRITING_PIPE); radio.openReadingPipe(1, READING_PIPE); radio.startListening(); // // Dump the configuration of the rf unit for debugging // radio.printDetails(); memset(&EMPTY_MESSAGE, 0, sizeof(ArPiMessage)); }
void setup(void) { // // Refer to RF24.h or nRF24L01 DS for settings radio.begin(); radio.enableDynamicPayloads(); radio.setAutoAck(1); radio.setRetries(15,15); radio.setDataRate(RF24_250KBPS); radio.setPALevel(RF24_PA_MAX); radio.setChannel(70); radio.setCRCLength(RF24_CRC_8); // Open 6 pipes for readings ( 5 plus pipe0, also can be used for reading ) radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.openReadingPipe(2,pipes[2]); radio.openReadingPipe(3,pipes[3]); radio.openReadingPipe(4,pipes[4]); radio.openReadingPipe(5,pipes[5]); // Start Listening radio.startListening(); radio.printDetails(); usleep(1000); }
int main(int argc, char** argv){ radio.begin(); // optionally, increase the delay between retries & # of retries radio.setRetries(0,0); // Dump the configuration of the rf unit for debugging radio.printDetails(); string input = ""; cout << "Choose your node number. #0-6 \n>"; getline(cin,input); int radioNumber = (int)input[0]-48; cout << "input" << input << "\n"; radio.openWritingPipe(pipes[radioNumber]); for (int i = 0; i < 6; i++) { if (i != radioNumber) { cout << i << "\n"; radio.openReadingPipe(i,pipes[i]); } } }
void setup(void) { wiringPiSetupGpio(); // // Refer to RF24.h or nRF24L01 DS for settings radio.begin(WPI_MODE_GPIO); radio.enableDynamicPayloads(); radio.setAutoAck(1); radio.setRetries(15,15); radio.setDataRate(RF24_1MBPS); radio.setPALevel(RF24_PA_MAX); radio.setChannel(76); radio.setCRCLength(RF24_CRC_16); // Open 6 pipes for readings ( 5 plus pipe0, also can be used for reading ) radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.openReadingPipe(2,pipes[2]); radio.openReadingPipe(3,pipes[3]); radio.openReadingPipe(4,pipes[4]); radio.openReadingPipe(5,pipes[5]); // // Dump the configuration of the rf unit for debugging // // Start Listening radio.startListening(); radio.printDetails(); printf("\n\rOutput below : \n\r"); usleep(1000); }
void setup(void) { //maxa = EEPROM.read(CONFIG_START); //EEPROM.write(CONFIG_START, maxa); lcd.begin (20,4); delay(10); lcd.setBacklightPin(BACKLIGHT,POSITIVE); lcd.setBacklight(HIGH); lcd.clear(); delay(10); lcd.home (); Serial.begin(57600); printf_begin(); radio.begin(); radio.setPALevel(RF24_PA_MAX); //RF24_PA_MIN = 0, RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX, RF24_PA_ERROR radio.setDataRate(RF24_250KBPS); //RF24_1MBPS = 0, RF24_2MBPS, RF24_250KBPS //radio.setAutoAck(1); radio.setRetries(15,15); radio.enableDynamicPayloads(); radio.openWritingPipe(pipes[1]); radio.openReadingPipe(1, pipes[0]); radio.startListening(); radio.printDetails(); }
void setup(void){ //Prepare the radio module printf("\nPreparing NRF24L01 interface\n"); radio.begin(); radio.setRetries( 15, 15); radio.setChannel(120); radio.enableAckPayload(); //radio.disableCRC(); radio.setAutoAck(true); radio.openWritingPipe(pipes[0]); radio.openReadingPipe(2,pipes[1]); radio.openReadingPipe(3,pipes[2]); radio.openReadingPipe(1,pipes[0]); radio.printDetails(); printf("\nPreparing MySQL interface.\n"); mysql_connect(); if ((mysql1 != NULL)) { sprintf(SQLstring,"CREATE TABLE IF NOT EXISTS CC_SENSOR_DYN (timestamp DATETIME, id INTEGER, temperature FLOAT, value INTEGER);"); if (!mysql_query(mysql1, SQLstring)) { printf("SQL CC_SENSOR_DYN Table is Ok: %s\n",SQLstring); } else { printf("SQL CC_SENSOR_DYN NOk: %s\n",SQLstring); printf("%s\n", mysql_error(mysql1)); } sprintf(SQLstring,"CREATE TABLE IF NOT EXISTS CC_SENSOR_HIST (timestamp DATETIME, id INTEGER, hist_type VARCHAR(1), hist_period INTEGER, value FLOAT);"); if (!mysql_query(mysql1, SQLstring)) { printf("SQL CC_SENSOR_HIST Table is Ok: %s\n",SQLstring); } else { printf("SQL CC_SENSOR_HIST NOk: %s\n",SQLstring); printf("%s\n", mysql_error(mysql1)); } } radio.startListening(); printf("\nNow Listening...\n"); }
void setup() { // - Setup serial port Serial.begin(115200); // - Pin initialization pinMode(STEP_UP_PIN, OUTPUT); digitalWrite(STEP_UP_PIN, LOW); // - Read address selection pinMode(ADDRESS_SELECTION_PIN, INPUT_PULLUP); if(digitalRead(ADDRESS_SELECTION_PIN) == HIGH) { nodeAddress[0] = 0x01; } else { nodeAddress[0] = 0x02; } // - Setup and configure radio radio.begin(); //radio.enableDynamicPayloads(); radio.setPayloadSize(PAYLOAD_SIZE); radio.setDataRate(RF24_250KBPS); // - Lower speed radio.setPALevel(RF24_PA_HIGH); // - Higher power level radio.openWritingPipe(gatewayAddress); // - To send values radio.openReadingPipe(1, nodeAddress); // - Not used in reality radio.powerDown(); }
void setup(void) { printf("\n\rnRF24l01+ remotecmd\n\r"); // // Setup and configure rf radio // radio.begin(); // optionally, increase the delay between retries & # of retries radio.setRetries(15,15); // optionally, reduce the payload size. seems to // improve reliability // radio.setPayloadSize(PACKET_LENGTH); radio.setChannel(0x4c); radio.setPALevel(RF24_PA_MAX); // // Open pipes to other nodes for communication // // Open pipe for writing // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading) radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); }
/******************************************************************************** Main ********************************************************************************/ int main(void) { // initialize code usart_init(); // enable interrupts //sei(); _delay_ms(2000); printf("Start NRF24L01P test..."); radio.begin(); radio.setRetries(15,15); radio.setPayloadSize(8); radio.setPALevel(RF24_PA_MAX); radio.setChannel(120); radio.openWritingPipe(pipes[1]); radio.openReadingPipe(1,pipes[0]); radio.startListening(); radio.printDetails(); loop(); // main loop while (true) { _delay_ms(1000); printf("Elapsed: %u \n", TCNT1); } }
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(); }
void pcmRF::begin(){ radi.begin(); radi.setChannel(1); // Set RF channel to 1 radi.setAutoAck(0); // Disable ACKnowledgement packets radi.setDataRate(RF24_1MBPS); // Set data rate as specified in user options radi.setCRCLength(RF24_CRC_8); radi.openWritingPipe(addresses[1]); radi.openReadingPipe(1,addresses[0]); }
void setupRadio() { radio.begin(); radio.setRetries(0,15); radio.setPayloadSize(sizeof(PosData)); radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.startListening(); }
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; }
void setup(void){ radio.begin(); radio.setPALevel(RF_24_PA_MAX); radio.setChannel(0x75); radio.openWritingPipe(0xF0F0F0F0E1LL); radio.enableDynamicPayloads(); radio.powerUp(); }
/******************************************************************************** Main ********************************************************************************/ int main(void) { // initialize usart module usart_init(); // enable interrupts sei(); // Init GPIO initGPIO(); // Init Timer 1 initTimer(); // Init Timer 0 & 2 initTimers(); OCR0A = 255; OCR0B = 255; OCR2A = 255; OCR2B = 255; _delay_ms(1000); OCR0A = 0; OCR0B = 0; OCR2A = 0; OCR2B = 0; fixZeroValueOCR(); // Console friendly output printf("Start..."); printf(CONSOLE_PREFIX); // Init NRF24L01+ radio.begin(); radio.setRetries(15,15); radio.setPayloadSize(8); radio.setPALevel(RF24_PA_MAX); radio.setChannel(115); radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.startListening(); // Some RF module diagnostics logs radio.printDetails(); // main loop while (1) { // main usart loop for console usart_check_loop(); } }
void setup() { Serial.begin(9600); //delay(1000); radio.begin(); print_welcome_message(); radio.openReadingPipe(1,pipe[0]);//For Receiving Operation radio.openWritingPipe(pipe[1]);//For Transmitting Operation radio.startListening(); }
void rf24_init(RF24& radio) { const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL }; radio.begin(); // radio.setChannel(100); radio.setRetries(15, 15); radio.setPayloadSize(sizeof(report_t)); radio.setDataRate(RF24_250KBPS); radio.openWritingPipe(pipes[1]); radio.openReadingPipe(1, pipes[0]); radio.startListening(); radio.printDetails(); }
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 radioSetup() { radio.begin(); radio.setRetries(15, 15); radio.setChannel(0x4c); //76 radio.setPALevel(RF24_PA_MAX); radio.setPALevel(RF24_PA_MAX); radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1, pipes[1]); radio.startListening(); radio.printDetails(); printf("Radio setup is complete!\n"); }
//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(); } }
//Initial setup of GPIO Pins and pipe modes (read/write). void setup(void) { radio.begin(); radio.setRetries(15,15); radio.setChannel(0x4c); radio.setPALevel(RF24_PA_MAX); radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.openReadingPipe(2,pipes[2]); radio.openReadingPipe(3,pipes[3]); radio.startListening(); radio.printDetails(); }
boolean setData(const byte cmd_buffer[], const byte write_pipe[]) { if( !radio_hw_available ) { debugPrint("Radio is NOT available"); return false; } radio.openWritingPipe(write_pipe); if( !sendRadioCommand(cmd_buffer) ) { return false; } return true; }
void initialiseBoard() { Serial.begin(57600); radio.begin(); mapFreeCH(); // optionally, increase the delay between retries & # of retries radio.setRetries(15,15); radio.setPayloadSize(PAYLOAD_SIZE); \ radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.startListening(); }
float requestData(const byte cmd_buffer[], const byte write_pipe[]) { if( !radio_hw_available ) { debugPrint("Radio is NOT available"); return -1.0; } debugPrint("Request data from Radio ... "); radio.openWritingPipe(write_pipe); // Open different pipes when writing. Write on pipe 0, address 0 radio.openReadingPipe(1,pipes[1]); // Read on pipe 1, as address 1 byte rec_buffer[8]; /* if( !radio.testRPD() || !radio.isValid() ) { debugPrint("Radio is not available"); return false; } */ if( !sendRadioCommand(cmd_buffer) ) { debugPrint("Send Radio command failed"); return false; } unsigned long started_waiting_at = millis(); // Set up a timeout period, get the current milliseconds boolean timeout = false; // Set up a variable to indicate if a response was received or not while ( ! radio.available() ){ // While nothing is received if (millis() - started_waiting_at > 200 ) { // If waited longer than 200ms, indicate timeout and exit while loop timeout = true; break; } } if ( timeout ) { debugPrint("Failed, response timed out.\n\r"); } else { radio.read( &rec_buffer, 8 ); byte fbytes[4]; for(int i=0,j=4;i<4;i++,j++) fbytes[i] = rec_buffer[j]; return convertToFloat(fbytes); } return -99.99; }
void setup(void){ //Prepare the radio module printf("\nPreparing interface\n"); radio.begin(); radio.setRetries( 15, 15); radio.setChannel(0x4c); radio.setPALevel(RF24_PA_MAX); radio.setPALevel(RF24_PA_MAX); radio.openWritingPipe(pipes[0]); radio.openReadingPipe(1,pipes[1]); radio.startListening(); radio.printDetails(); }