/*---------------------------------------------------------------------------*/ int main() { uint8_t i; uint16_t temp; uint16_t rval; uint16_t getDataCounter; init_hardware(); while(1) { /* power up the temperature sensor */ pinMode(A,2,OUTPUT); digitalWrite(A,2,HIGH); /* prepare reading the 1st ADC channel */ init_adc(0x01); _delay_us(750); /* take multiple readings and divide later */ rval = 0; for (i = 0; i < 8; ++i) { temp = read_adc_sleepy(); /* store each sample seperatly */ data_array[(2*i)+2] = temp >> 8; data_array[(2*i)+3] = temp & 0xFF; rval += temp; } rval = rval >> 3; /* Store the averages */ data_array[0] = rval >> 8; data_array[1] = rval & 0xFF; /* reset ADC registers */ ADCSRA = 0x00; ADMUX = 0x00; /* power down the temperature sensor */ digitalWrite(A,2,LOW); pinMode(A,2,INPUT); /* automatically goes to TX mode */ nrf24_send(data_array); /* be wise ... */ sleep_during_transmisson(); /* parameter for this function determines how long does it wait for a message */ check_bootloader_message(10); /* parameter for this function is WDT overflow count */ sleep_for(25); } return 0; }
/* Send data using the nRF radio */ void radioTask(void *pvParameters) { (void) pvParameters; uint8_t rfData[NRF24_PAYLOAD_LEN]; uint8_t rcvData[NRF24_PAYLOAD_LEN]; uint8_t pktCounter = 0; uint8_t blinkCounter = 0; const portTickType blinkDelay = 250 / portTICK_RATE_MS; const portTickType sendDelay = 5000 / portTICK_RATE_MS; rfData[0] = 0xB1; rfData[1] = 0x3A; rfData[2] = 0x23; while(1) { if(nrf24_dataReady()) { nrf24_getData(rcvData); // Format message for debugging char debugRcvString[3*6] = {0}; for (uint8_t i=0; i < NRF24_PAYLOAD_LEN; i++) { sprintf(debugRcvString+(3*i), "%02X ", rcvData[i]); } printf("Received: %s\n", debugRcvString); } rfData[3] = pktCounter++; nrf24_send(rfData); while(nrf24_isSending()); char debugSendString[3*6] = {0}; for (uint8_t i = 0; i < NRF24_PAYLOAD_LEN; i++) { sprintf(debugSendString+(3*i), "%02X ", rfData[i]); } printf("Sent: %s\n", debugSendString); if(nrf24_lastMessageStatus()) { //there was a send problem }else{ //transmission was ok } for(blinkCounter = 1 + nrf24_retransmissionCount(); blinkCounter > 0; --blinkCounter) { PORTC |= _BV(PORTC3); vTaskDelay(blinkDelay); PORTC &= ~_BV(PORTC3); vTaskDelay(blinkDelay); } nrf24_powerUpRx(); vTaskDelay(sendDelay); } }
void copy_paste() { int temp; nrf24_config(2, 4); nrf24_tx_address(tx_address11); nrf24_rx_address(rx_address11); while (1) { //LED0 = LED_ON; //LED1 = LED_ON; //LED2 = LED_ON; //LED3 = LED_ON; //delay_loop1(); //LED0 = LED_OFF; //LED1 = LED_OFF; //LED2 = LED_OFF; //LED3 = LED_OFF; //delay_loop1(); //nrf24_tx_address((uint8_t*) (uartBuffer + 1)); data_array[0] = 0x00; data_array[1] = 0xAA; data_array[2] = 0x55; data_array[3] = 0x22; /* Automatically goes to TX mode */ nrf24_send(data_array,4); /* Wait for transmission to end */ while (nrf24_isSending()); /* Make analysis on last tranmission attempt */ temp = nrf24_lastMessageStatus(); if (temp == NRF24_TRANSMISSON_OK) { //Do something } else if (temp == NRF24_MESSAGE_LOST) { //Do something else } /* Retranmission count indicates the tranmission quality */ /* Optionally, go back to RX mode ... */ //nrf24_powerUpRx(); /* Or you might want to power down after TX */ // nrf24_powerDown(); /* Wait a little ... */ //_delay_ms(10); } }
static int nrf24_prepare(const void *payload, unsigned short payload_len) { //This function is first called //For now lets assume that we transfer smaller byte chunks //And remove fragmentation int i=0; length_arr=payload_len; for(i=0;i<127;i++) { data[i]=0; } for(i=0;i<payload_len;i++) { data[i]=((uint8_t *)payload)[i]; } asm("nop"); nrf24_send(payload,payload_len); return 1; }
int main() { DDRB |= 1<<PORTB3; PORTB |= 1<<PORTB3; ledPort |= _BV(ledPin); /* init hardware pins */ nrf24_init(); /* Channel #2 , payload length: 4 */ nrf24_config(2,4); /* Set the device addresses */ nrf24_tx_address(tx_address); nrf24_rx_address(rx_address); pwm_init(); // initialize timer in PWM mode interupt_init(); //initalize Interrupt 0 /* Fill the data buffer */ data_array[0] = deviceID; data_array[1] = 0xAA; while(1) { data_array[3] = events; data_array[2] = events >> 8; nrf24_send(data_array); /* Wait for transmission to end */ while(nrf24_isSending()) { } ledPort ^= _BV(ledPin); _delay_ms(80000); } }
/* ------------------------------------------------------------------------- */ int main() { /* init the software uart */ uart_init(); /* init the xprintf library */ xdev_out(uart_put_char); /* simple greeting message */ xprintf("\r\n> TX device ready\r\n"); /* init hardware pins */ nrf24_init(); /* Channel #2 , payload length: 4 */ nrf24_config(2,4); /* Set the device addresses */ nrf24_tx_address(tx_address); nrf24_rx_address(rx_address); while(1) { /* Fill the data buffer */ data_array[0] = 0x00; data_array[1] = 0xAA; data_array[2] = 0x55; data_array[3] = q++; /* Automatically goes to TX mode */ nrf24_send(data_array); /* Wait for transmission to end */ while(nrf24_isSending()); /* Make analysis on last tranmission attempt */ temp = nrf24_lastMessageStatus(); if(temp == NRF24_TRANSMISSON_OK) { xprintf("> Tranmission went OK\r\n"); } else if(temp == NRF24_MESSAGE_LOST) { xprintf("> Message is lost ...\r\n"); } /* Retranmission count indicates the tranmission quality */ temp = nrf24_retransmissionCount(); xprintf("> Retranmission count: %d\r\n",temp); /* Optionally, go back to RX mode ... */ nrf24_powerUpRx(); /* Or you might want to power down after TX */ // nrf24_powerDown(); /* Wait a little ... */ _delay_ms(10); } }
/** * @brief Main program. * @param None * @retval None */ void main(void) { static u8 status; bool flag_display_retrans_cnt; disableInterrupts(); Config(); Errors_Init(); enableInterrupts(); Goto_HALT(); while (1) { if((btn_pressed != BUTTON1) && (btn_pressed != BUTTON2)) { DELAY_STOP; goto sleep; } PWR_PVDCmd(ENABLE); /* Power voltage detector and brownout Reset unit supply current 2,6uA */ PWR_PVDLevelConfig(PWR_PVDLevel_2V26); /* Set Programmable voltage detector threshold to 2,26V */ if(DELAY_EXPIRED) flag_display_retrans_cnt = TRUE; else flag_display_retrans_cnt = FALSE; while(!DELAY_EXPIRED); /* wait for power-up delay to expire (199.68ms) - needed for nRF24L01+ power up */ DELAY_STOP; CLK_PeripheralClockConfig(CLK_Peripheral_SPI1, ENABLE); nrf24_init(); /* init hardware pins */ nrf24_config(0, 6); /* Channel #0 , payload length: 6 */ nrf24_tx_address(tx_address); /* Set the device addresses */ nrf24_rx_address(rx_address); /* Check NRF24 Init error */ if(Errors_CheckError(ERROR_NRF24_INIT)) { LED_Red_Blink(2); goto sleep; } TXmsg.M.status = 0; /* Reset status byte */ /* Check Programmable voltage detector (PVD) output flag, if battery low send this information */ /* Internal reference voltage should be stable at this point */ if(PWR->CSR1 & PWR_FLAG_PVDOF) { /* VDD/VDDA is below the VPVD threshold (2,26V) */ TXmsg.M.status |= STATUS_LOWBATT; } PWR_PVDCmd(DISABLE); if(btn_pressed == BUTTON1) { TXmsg.M.ownID = (u32)ownID_btn1; TXmsg.M.txcnt = tx_cnt++; nrf24_send((u8*)&TXmsg.B.b[0]); } else if(btn_pressed = BUTTON2) { TXmsg.M.ownID = (u32)ownID_btn2; TXmsg.M.txcnt = tx_cnt++; nrf24_send((u8*)&TXmsg.B.b[0]); } btn_pressed = 0; do { status = nrf24_getStatus(); } while(!(status & ((1 << TX_DS) | (1 << MAX_RT)))); if(status & (1 << TX_DS)) /* send successful */ { if(flag_display_retrans_cnt) { u8 i; u8 retrans_cnt = nrf24_retransmissionCount(); LED_Green_Blink(retrans_cnt); } else { LED_Green_Blink(1); } } else if(status & (1 << MAX_RT)) /* send failed, max retries exceeded */ { LED_Red_Blink(1); } sleep: Goto_HALT(); } }
int main() { uint8_t i, change; uint8_t hand; uint32_t timeout = 0; uart_init(); xdev_out(uart_putchar); // Determine which hand this is from PE2 // Left is hand 0, right is hand 1 PORTE = (1 << 2); DDRE = 0; hand = (PINE & 0x04) ? 0 : 1; xprintf("\r\nHand %d\r\n", hand); // Initialise NRF24 // Set the last byte of the address to the hand ID rx_address[4] = hand; nrf24_init(); nrf24_config(CHANNEL, sizeof msg); nrf24_tx_address(tx_address); nrf24_rx_address(rx_address); matrix_init(); msg[0] = hand & 0x01; msg[1] = 0; msg[2] = 0; // Set up LED and flash it briefly DDRE |= 1<<6; PORTE = 1<<6; _delay_ms(500); PORTE = 0; get_voltage(); check_voltage(); // Scan the matrix and detect any changes. // Modified rows are sent to the receiver. while (1) { timeout++; matrix_scan(); for (i=0; i<ROWS; i++) { change = matrix_prev[i] ^ matrix[i]; // If this row has changed, send the row number and its current state if (change) { if (DEBUG) xprintf("%d %08b -> %08b %ld\r\n", i, matrix_prev[i], matrix[i], timeout); msg[1] = i; msg[2] = matrix[i]; nrf24_send(msg); while (nrf24_isSending()); timeout = 0; } matrix_prev[i] = matrix[i]; } // Sleep if there has been no activity for a while if (timeout > SLEEP_TIMEOUT) { timeout = 0; enter_sleep_mode(); } } }
int main(void) { /* Initialise the GPIO block */ gpioInit(); /* Initialise the UART0 block for printf output */ //uart0Init(115200); uart0Init(9600); /* Configure the multi-rate timer for 1ms ticks */ mrtInit(__SYSTEM_CLOCK/1000); /* Configure the switch matrix (setup pins for UART0 and GPIO) */ //configurePins(); spiInit(LPC_SPI0, 6, 0); SwitchMatrix_Init(); //uart & spi LPC_GPIO_PORT->DIR0 |= (1 << CSN); LPC_GPIO_PORT->DIR0 |= (1 << CE); uint8_t temp = 0; nrf24_init(); /* Set the LED pin to output (1 = output, 0 = input) */ #if !defined(USE_SWD) LPC_GPIO_PORT->DIR0 |= (1 << LED_LOCATION); #endif //printf("write"); mrtDelay(500); nrf24_config(2,16); #if TX_NODE nrf24_tx_address(tx_address); nrf24_rx_address(rx_address); #else nrf24_tx_address(rx_address); //backwards looking but is fine nrf24_rx_address(tx_address); #endif uint8_t i = 0; while(1) { /* Turn LED On by setting the GPIO pin high */ LPC_GPIO_PORT->SET0 = 1 << LED_LOCATION; mrtDelay(500); /* Turn LED Off by setting the GPIO pin low */ LPC_GPIO_PORT->CLR0 = 1 << LED_LOCATION; mrtDelay(500); /* printf("Send\r\n"); for(i=0; i<16; i++){ printf("%d: %d\n\r", i, tx_data_array[i]); } */ nrf24_send(tx_data_array); while(nrf24_isSending()); nrf24_powerUpRx(); //done transmitting, set back to rx mode for(i=0; i<16; i++){ tx_data_array[i]++; } /* if(nrf24_dataReady()){ printf("\n\rGot data\n\r"); nrf24_getData(rx_data_array); for(i=0; i<16; i++){ printf("%d: %d\n\r", i, rx_data_array[i]); } } */ } }
void UpdateManualMode(volatile InputState *input) { // Get joystick X/Y // NB: Joystick is rotated on board! uint16_t x = input->joystick.x; uint16_t y = input->joystick.y; // Determine direction to go // Set motor values. // NB: Make sure not to override the motors! const uint16_t deadzone = 20; // How to determine direction and speed: // X axis determines direction // --> Rotate control vector // Y axis determines speed int32_t vec_x = ((int32_t)x - 0x3FF/2); int32_t vec_y = ((int32_t)y - 0x3FF/2); vec_y *= -1; int16_t motor_left = 0; int16_t motor_right = 0; const int32_t vec_max = 0x3FF / 2; const int32_t motor_max = 0xFF; int16_t vec_x_abs = (uint16_t)abs(vec_x); if (vec_x_abs >= deadzone) { if (vec_x < 0) { // Turn left motor_left = (int16_t)(-vec_x_abs * motor_max / vec_max); motor_right = (int16_t)(vec_x_abs * motor_max / vec_max); } else { // Turn right motor_left = (int16_t)(vec_x_abs * motor_max / vec_max); motor_right = (int16_t)(-vec_x_abs * motor_max / vec_max); } } int16_t motor_left_f = 0; int16_t motor_right_f = 0; int16_t vec_y_abs = (int16_t)abs(vec_y); if (vec_y_abs >= deadzone) { motor_left_f = (vec_y_abs * motor_max / vec_max); motor_right_f = (vec_y_abs * motor_max / vec_max); if (vec_y > 0) { // Go backwards motor_left_f *= -1; motor_right_f *= -1; } } motor_left += motor_left_f; motor_right += motor_right_f; if (motor_left > 0xFF) { motor_left = 0xFF; } else if (motor_left < -0xFF) { motor_left = -0xFF; } if (motor_right > 0xFF) { motor_right = 0xFF; } else if (motor_right < -0xFF) { motor_right = -0xFF; } if (manual_prev.initialized && (manual_prev.motor_left != motor_left || manual_prev.motor_right != motor_right)) { // Send updated signal RemoteCommand toSend; if (motor_left == 0 && motor_right == 0) { toSend.cmd = RADIO_CMD_STOP; printf("R: STOP\n"); } else { toSend.cmd = RADIO_CMD_SET_MOTOR; toSend.data[0] = motor_left >= 0 ? FORWARD : BACKWARD; toSend.data[1] = (uint8_t)abs(motor_left); toSend.data[2] = motor_right >= 0 ? FORWARD : BACKWARD; toSend.data[3] = (uint8_t)abs(motor_right); printf("D: %d, %d\n", motor_left, motor_right); } nrf24_send(&toSend, sizeof(RemoteCommand)); } // Handle light switch cmd if (!(input->buttons & BUTTON_LEFT)) { printf("LIGHT ON\n"); RemoteCommand c; c.cmd = RADIO_CMD_LIGHT_ON; nrf24_send(&c, sizeof(RemoteCommand)); } if (!(input->buttons & BUTTON_RIGHT)) { printf("LIGHT OFF\n"); RemoteCommand c; c.cmd = RADIO_CMD_LIGHT_OFF; nrf24_send(&c, sizeof(RemoteCommand)); } manual_prev.initialized = 1; manual_prev.motor_left = motor_left; manual_prev.motor_right = motor_right; // Debug output: // printf("D: %d %d\n", motor_left, motor_right); }