void initRadio(void){ nrf24_init(); nrf24_config(NRF24_CHANNEL_MHZ, NRF24_PAYLOAD_LEN);//channel 15, 16 byte payload nrf24_tx_address(ptxAddr); nrf24_rx_address(prxAddr); }
bool RHReliableDatagram::init() { spi_init(); if (nrf24_init()) return 0; update_rx_addr(addr); nrf24_rx_mode(); return 1; }
//system initialize function void sys_init(void) { TRISB&=0xE7; //ss & ce are output, RB2 is input ss=1; ce=1; TRISA=0xFF; //RA0 is analog input TRISC=0xF8; //lcd control pins buzzer=0; //fire alarm buzzer TRISD=0x00; //lcd data bus lcd_init(); //initialize LCD adc_init(); //initialize ADC interrupt_init(); //initialize interrupts SPI_master_init(0x00, SLOW); //initialize MSSP module for SPI communication nrf24_init(); //initialize nRF24L01+ }
/*---------------------------------------------------------------------------*/ static PT_THREAD(nrf24_thread(struct pt *pt)) { PT_BEGIN(pt); /* init hardware pins */ nrf24_init(); /* Channel #2 , payload length: 8 */ nrf24_config(2,8); /* Set the device addresses */ nrf24_tx_address(tx_address); nrf24_rx_address(rx_address); uint32_t counter; uint16_t temp; int16_t realval; while(1) { PT_WAIT_UNTIL(pt,nrf24_dataReady()); dbg(PSTR("> -------------------------------------\r\n")); nrf24_getData(data_array); temp = (data_array[0]<<8)+data_array[1]; realval = temp * 10; realval /= 11; realval -= 500; dbg(PSTR("> RAW Temp: %u\r\n"),temp); dbg(PSTR("> Temp: %u\r\n"),realval); temp = (data_array[2]<<8)+data_array[3]; dbg(PSTR("> Batt: %u\r\n"),temp); counter = (data_array[4]<<24)+(data_array[5]<<16)+(data_array[6]<<8)+data_array[7]; dbg(PSTR("> Counter: %u\r\n"),counter); } PT_END(pt); }
int main(int argc, char **argv){ uint8_t data_array[4]; uint8_t tx_address[5] = { 0xE7, 0xE7, 0xE7, 0xE7, 0xE7 }; uint8_t rx_address[5] = { 0xD7, 0xD7, 0xD7, 0xD7, 0xD7 }; if (!bcm2835_init()) return 1; mysql_connect(); /* 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); printf("Configured\n"); while (1){ if (nrf24_dataReady()) { nrf24_getData(data_array); printf("> %d %d %d %d \n", data_array[0], data_array[1], data_array[2], data_array[3]); if (argc>1) { if (argv[1][0]=='1') { writeCpm( data_array[0], data_array[1], data_array[2], data_array[3]); } } } } mysql_disconnect(); bcm2835_close(); return 0; }
int main(void) { // LCD Screen lcd_init(); terminal_init(); // Input input_init(); // Set power LED DDRB |= (1 << PINB6); clear_bit(PORTB, PINB6); // Radio uint8_t local_addr[] = { 0x1B, 0x1B, 0x1B, 0x1B, 0x1B }; uint8_t robot_addr[] = { 0x0A, 0x0A, 0x0A, 0x0A, 0x0A }; spi_init(); nrf24_init(); nrf24_config(47, sizeof(RemoteCommand)); // Channel 7 nrf24_set_rx_addr(local_addr); nrf24_set_tx_addr(robot_addr); // Ready to go! sei(); RemoteMode mode = MODE_MANUAL; while (1) { input_update(&input_state); switch (mode) { case MODE_MANUAL: UpdateManualMode(&input_state); break; case MODE_AUTO: asm("nop"::); break; case MODE_MENU: asm("nop"::); break; } } }
/*---------------------------------------------------------------------------*/ void init_hardware() { /* init interrupt pin */ pinMode(B,2,INPUT); /* init led ... */ led0_init(); led0_low(); /* init hardware pins */ nrf24_init(); /* disable the analog comparator */ ACSR = (1<<ACD); /* channel #2 , payload length: 4 */ nrf24_config(2,32); /* get the rx address from EEPROM */ rx_address[0] = eeprom_read_byte((uint8_t*)10); rx_address[1] = eeprom_read_byte((uint8_t*)11); rx_address[2] = eeprom_read_byte((uint8_t*)12); rx_address[3] = eeprom_read_byte((uint8_t*)13); rx_address[4] = eeprom_read_byte((uint8_t*)14); /* set the device addresses */ nrf24_tx_address(tx_address); nrf24_rx_address(rx_address); /* initial power-down */ nrf24_powerDown(); /* disable digital buffer at the adc pin */ cbi(DIDR0,ADC1D); PRR = (1<<PRTIM1)|(1<<PRTIM0)|(0<<PRADC)|(0<<PRUSI); }
void setup(void) { uint8_t s = SREG; uint8_t m = MCUCR; uint8_t i, addrs[6]; wdt_disable(); serial_init(); timer_init(); spi_init(); nrf24_init(); sei(); /* * Set our radio address and the remote end's radio address, read * the addresses from EEPROM where they need to be saved first. */ for (i = 0; i < 6; i ++) addrs[i] = eeprom_read(i); nrf24_set_rx_addr(addrs + 0); nrf24_set_tx_addr(addrs + 3); /* Write something to say hello */ serial_write_str("SREG:"); serial_write_hex16(s); serial_write_str(", MCUCR:"); serial_write_hex16(m); serial_write_str(", our addr: "); serial_write1(addrs[0]); serial_write1(addrs[1]); serial_write1(addrs[2]); serial_write_eol(); nrf24_rx_mode(); serial_set_handler(handle_input); }
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(); } }
static void nrf24_test(void) { uint8_t rx_address[5] = {0xA7,0x95,0xF1,0x36,0x07}; uint8_t tx_address[5] = {0xA7,0x95,0xF1,0x36,0x06}; //uint8_t tx_address[5] = {0x17,0x97,0xA7,0xA7,0xD7}; uint8_t addr[10] = {0x1}; uint8_t val = 0x17; uint8_t reg; uint8_t data_array[6]; uint32_t counter = 0; spi_delay(1000000); /* init hardware pins */ nrf24_init(); if (spi_init() < 0) { printf("ERRRRROR SPI!\n"); } /* Returned value is not correct on the first read, who knows why... */ nrf24_readRegister(CONFIG, ®, 1); nrf24_readRegister(CONFIG, ®, 1); printf("CONFIG (before configured) = %x\n", reg); nrf24_readRegister(EN_AA, ®, 1); printf("EN_AA = %x\n", reg); nrf24_readRegister(RF_SETUP, ®, 1); printf("RF_SETUP = %x\n", reg); nrf24_readRegister(SETUP_AW, ®, 1); printf("SETUP_AW = %x\n", reg); nrf24_readRegister(SETUP_RETR, ®, 1); printf("SETUP_RETR = %x\n", reg); nrf24_readRegister(FIFO_STATUS, ®, 1); printf("FIFO_STATUS = %x\n", reg); nrf24_readRegister(RF_CH, ®, 1); printf("RF_CH = %x\n", reg); nrf24_writeRegister(RF_CH, &val, 1); nrf24_readRegister(RF_CH, ®, 1); printf("RF_CH = %x\n", reg); val = 2; nrf24_writeRegister(RF_CH, &val, 1); nrf24_readRegister(RF_CH, ®, 1); printf("RF_CH = %x\n", reg); #if 1 nrf24_readRegister(RX_ADDR_P0, addr, 5); printf("RX_ADDR_P0: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); nrf24_writeRegister(RX_ADDR_P0, tx_address,5); spi_delay(1000000); nrf24_readRegister(RX_ADDR_P0, addr, 5); printf("RX_ADDR_P0: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); spi_delay(1000000); nrf24_readRegister(RF_CH, ®, 1); nrf24_readRegister(TX_ADDR, addr, 5); printf("TX_ADDR: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); nrf24_writeRegister(TX_ADDR, tx_address,5); nrf24_readRegister(TX_ADDR, addr, 5); printf("TX_ADDR: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); spi_delay(1000000); nrf24_readRegister(RX_ADDR_P1, addr, 5); printf("RX_ADDR_P1: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); nrf24_writeRegister(RX_ADDR_P1, rx_address,5); nrf24_readRegister(RX_ADDR_P1, addr, 5); printf("RX_ADDR_P1: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); #endif /* Channel #2 , payload length: 4 */ nrf24_config(16,6); nrf24_readRegister(FIFO_STATUS,®,1); printf("!> 1 FIFO_STATUS = %2X\n", reg); spi_delay(1000000); nrf24_readRegister(CONFIG, ®, 1); nrf24_readRegister(CONFIG, ®, 1); printf("CONFIG (after configured) = %x\n", reg); nrf24_readRegister(EN_AA, ®, 1); printf("EN_AA = %x\n", reg); nrf24_readRegister(RF_SETUP, ®, 1); printf("RF_SETUP = %x\n", reg); nrf24_readRegister(TX_ADDR, addr, 5); printf("TX addr is: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); //spi_delay(1000000); nrf24_readRegister(RX_ADDR_P0, addr, 5); printf("RX addr is: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); //spi_delay(1000000); nrf24_readRegister(RX_ADDR_P1, addr, 5); printf("RX_ADDR_P1 addr is: %x %x %x %x %x\n", addr[0], addr[1], addr[2], addr[3], addr[4]); nrf24_readRegister(FIFO_STATUS,®,1); printf("!!!!!!> 2 FIFO_STATUS = %2X\n", reg); /* Set the device addresses */ //nrf24_tx_address(rx_address); //nrf24_rx_address(rx_address); //nrf24_ce_digitalWrite(HIGH); //reg = nrf24_getStatus(); //printf("STATUS = %2X\n", reg); nrf24_readRegister(FIFO_STATUS,®,1); printf("!!!!!!> 3 FIFO_STATUS = %2X\n", reg); while(1) { if(nrf24_dataReady()) { counter = 0; //reg = nrf24_getStatus(); //printf("STATUS = %x\n", reg); nrf24_getData(data_array); printf("> "); printf("%2X ",data_array[0]); printf("%2X ",data_array[1]); printf("%2X ",data_array[2]); printf("%2X ",data_array[3]); printf("%2X ",data_array[4]); printf("%2X\r\n",data_array[5]); //spi_delay(1000); } else if (counter > 100000) { reg = nrf24_getStatus(); printf("(counter > 100000) STATUS = %2X\n", reg); nrf24_readRegister(FIFO_STATUS,®,1); printf("(counter > 100000) FIFO_STATUS = %2X\n", reg); } counter++; } }
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) { // set clock prescaler for 8MHz CLKPR = 0x80; CLKPR = 0x01; cli(); power_all_disable(); power_spi_enable(); power_timer1_enable(); set_sleep_mode(SLEEP_MODE_IDLE); pins_init(); delay_ms(345); // arbitrary uint8_t dpi = 0x0f; // default to 800 if (!(PIND & (1<<0))) // if left is pressed at boot dpi = 0xff; // set to 12800 pmw3366_init(dpi); nrf24_init(); // button stuff // previous debounced state uint8_t btn_prev = ~(PIND); // time (in 125us) button has been unpressed. // consider button to be released if this time exceeds DEBOUNCE_TIME. uint8_t btn_time[3] = {0, 0, 0}; // absolute positions. relies on integer overflow union motion_data x = {0}, y = {0}; // wheel stuff uint8_t whl_prev_same = 0; // what A was the last time A == B uint8_t whl_prev_diff = 0; // what A was the last time A != B // absolute scroll position. relies on integer overflow int8_t whl = 0; // begin burst mode for 3366 spi_set3366mode(); SS_3366_LOW; spi_3366_write(0x50, 0x00); SS_3366_HIGH; // set up timer1 to set OCF0A in TIFR0 every 1ms TCCR1A = 0x00; TCCR1B = 0x09; // CTC, 8MHz OCR1A = 7999; // main loop nominal period (7999 + 1) / 8MHz = 1ms OCR1B = 320; // timing of when to read burst mode data from sensor OCR1C = 800; // timing of when to load nrf24l01+ with data // let receiver know if it's the first time sending data, so that it // can reset the reference for absolute position and that there's no // jump when rebooting the mouse // uint8_t first = 0x80; // transmitted as MSB with button data below. // when sync reaches 0, always send a packet with bit 6 in btn set, to // tell the receiver to calculate the timing offset. // when sync reaches 1, always send a packet requesting ACK to load the // timing offset // i.e. when it overflows, so 256ms periodicity. // when sync reaches 0, afk increments. // afk is cleared by any motion or button press. // when afk reaches AFK_TIMEOUT, go into powerdown mode. for (uint8_t first = 0x80, sync = 0, afk = 0; ; first = 0, sync++) { // sync to 1ms intervals using timer1 // if (TIFR1 & (1<<OCF1A)) PORTD |= (1<<6); TIMSK1 |= (1<<OCIE1A); sei(); sleep_mode(); cli(); TIMSK1 &= ~(1<<OCIE1A); TIFR1 |= (1<<OCF1A); TIFR1 |= (1<<OCF1B); TIFR1 |= (1<<OCF1C); // begin burst mode read spi_set3366mode(); SS_3366_LOW; spi_send(0x50); // do stuff here instead of busy waiting for 35us // read wheel int8_t dwhl = 0; const uint8_t whl_a = WHL_A_IS_HIGH; const uint8_t whl_b = WHL_B_IS_HIGH; // if (whl_a == whl_b) { // if (whl_a != whl_prev_same) { // dwhl = 2 * (whl_a ^ whl_prev_diff) - 1; // whl += dwhl; // whl_prev_same = whl_a; // } // } else // whl_prev_diff = whl_a; if (whl_a != whl_b) whl_prev_diff = whl_a; else if (whl_a != whl_prev_same) { dwhl = 2 * (whl_a ^ whl_prev_diff) - 1; whl += dwhl; whl_prev_same = whl_a; } // read buttons /* PIND 0 EIFR 0: low, no edges -> is low PIND 0 EIFR 1: low, edge -> is low PIND 1 EIFR 0: high, no edges -> always high during last 1ms PIND 1 EIFR 1: high, edge -> low at some point in the last 1ms */ const uint8_t btn_unpressed = PIND & ~(EIFR); EIFR = 0b00000111; // clear EIFR // manual loop debouncing for every button uint8_t btn_dbncd = 0x00; #define DEBOUNCE(index) \ if ((btn_prev & (1<<index)) && (btn_unpressed & (1<<index))) { \ btn_time[index]++; \ if (btn_time[index] < DEBOUNCE_TIME) \ btn_dbncd |= (1<<index); \ } else { \ btn_time[index] = 0; \ btn_dbncd |= (~btn_unpressed) & (1<<index); \ } DEBOUNCE(0); DEBOUNCE(1); DEBOUNCE(2); #undef DEBOUNCE // wait until 35us have elapsed since spi_send(0x50) // if (TIFR1 & (1<<OCF1B)) PORTD |= (1<<6); TIMSK1 |= (1<<OCIE1B); sei(); sleep_mode(); cli(); TIMSK1 &= ~(1<<OCIE1B); union motion_data dx, dy; spi_send(0x00); // motion, not used spi_send(0x00); // observation, not used dx.lo = spi_recv(); dx.hi = spi_recv(); dy.lo = spi_recv(); dy.hi = spi_recv(); SS_3366_HIGH; x.all += dx.all; y.all += dy.all; if (sync == 0) afk++; const uint8_t changed = (btn_dbncd != btn_prev) || dx.all || dy.all || dwhl; if (changed) afk = 0; if (changed || (sync <= 1)) { btn_prev = btn_dbncd; // W_TX_PAYLOAD if sync == 1, W_TX_PAYLOAD_NOACK otherwise const uint8_t mode = (sync == 1) ? 0b10100000 : 0b10110000; // send miscellaneous info using top bits of btn byte uint8_t btn_send = btn_dbncd | first; // first is either 0x80 or 0 if (sync == 0) btn_send |= 0x40; // try to transmit at the same time every frame // if (TIFR1 & (1<<OCF1C)) {PORTD |= (1<<6);} TIMSK1 |= (1<<OCIE1C); sei(); sleep_mode(); cli(); TIMSK1 &= ~(1<<OCIE1C); spi_setnrf24mode(); SS_NRF24_LOW; spi_send(0x20 | 0x07); // STATUS spi_send(0b01110000); // clear IRQ SS_NRF24_HIGH; SS_NRF24_LOW; spi_send(0b11100001); // flush tx SS_NRF24_HIGH; SS_NRF24_LOW; spi_send(0b11100010); // flush rx SS_NRF24_HIGH; SS_NRF24_LOW; spi_send(mode); spi_send(btn_send); spi_send(x.lo); spi_send(x.hi); spi_send(y.lo); spi_send(y.hi); spi_send(whl); SS_NRF24_HIGH; // pulse CE to transmit CE_HIGH; delay_us(12); CE_LOW; if (sync == 1) { // get ack payload of timing offset delay_us(400); if (IRQ_IS_LOW) { // recycle motion_data union for timing union motion_data offset; SS_NRF24_LOW; spi_send(0b01100001); offset.lo = spi_recv(); offset.hi = spi_recv(); SS_NRF24_HIGH; // shift TCNT1 by the offset, plus a // little more because of the time it // takes to add stuff to TCNT1. TCNT1 += offset.all + 11; } } } // power down if afk if (afk > AFK_TIMEOUT) { // enable external interrupts on INT0/1/2/3, PCINT0 EIMSK = 0b00000111; PCICR = 0x01; // go power down mode; wake up on interrupt set_sleep_mode(SLEEP_MODE_PWR_DOWN); sei(); sleep_mode(); cli(); // disable external interrupts PCICR = 0; EIMSK = 0; // restore state set_sleep_mode(SLEEP_MODE_IDLE); sync = 0; afk = 0; } } }
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]); } } */ } }