main.cpp

00001 #include "mbed.h"
00002 
00003 DigitalOut myled(LED1);
00004 
00005 #include <stdbool.h>
00006 #include <stdint.h>
00007 #include <string.h>
00008 //#include "nrf.h"
00009 #include "micro_esb.h"
00010 #include "uesb_error_codes.h"
00011 #include "nrf_delay.h"
00012 //#include "nrf_gpio.h"
00013 
00014 static uesb_payload_t tx_payload, rx_payload;
00015 
00016 class Micro_esb {
00017     
00018     uesb_mainstate_t         m_uesb_mainstate;
00019     
00020     uesb_config_t            m_config_local;
00021     
00022     uesb_payload_tx_fifo_t   m_tx_fifo;
00023     uesb_payload_rx_fifo_t   m_rx_fifo;
00024     
00025     uint32_t  m_interrupt_flags;
00026     uint32_t  m_last_tx_attempts;
00027     
00028     public:
00029     
00030     uint32_t uesb_set_address(uesb_address_type_t address, const uint8_t *data_ptr)
00031     {
00032         if(m_uesb_mainstate != UESB_STATE_IDLE) return UESB_ERROR_NOT_IDLE;
00033         switch(address) {
00034             case UESB_ADDRESS_PIPE0:
00035                 memcpy(m_config_local.rx_address_p0, data_ptr, m_config_local.rf_addr_length);
00036                 break;
00037             case UESB_ADDRESS_PIPE1:
00038                 memcpy(m_config_local.rx_address_p1, data_ptr, m_config_local.rf_addr_length);
00039                 break;
00040             case UESB_ADDRESS_PIPE2:
00041                 m_config_local.rx_address_p2 = *data_ptr;
00042                 break;
00043             case UESB_ADDRESS_PIPE3:
00044                 m_config_local.rx_address_p3 = *data_ptr;
00045                 break;
00046             case UESB_ADDRESS_PIPE4:
00047                 m_config_local.rx_address_p4 = *data_ptr;
00048                 break;
00049             case UESB_ADDRESS_PIPE5:
00050                 m_config_local.rx_address_p5 = *data_ptr;
00051                 break;
00052             case UESB_ADDRESS_PIPE6:
00053                 m_config_local.rx_address_p6 = *data_ptr;
00054                 break;
00055             case UESB_ADDRESS_PIPE7:
00056                 m_config_local.rx_address_p7 = *data_ptr;
00057                 break;
00058             default:
00059                 return UESB_ERROR_INVALID_PARAMETERS;
00060         }
00061         //update_radio_parameters();
00062         return UESB_SUCCESS;
00063     }
00064     
00065     uint32_t uesb_flush_tx(void)
00066     {
00067         if(m_uesb_mainstate != UESB_STATE_IDLE) return UESB_ERROR_NOT_IDLE;
00068         DISABLE_RF_IRQ;
00069         m_tx_fifo.count = 0;
00070         m_tx_fifo.entry_point = m_tx_fifo.exit_point = 0;
00071         ENABLE_RF_IRQ;
00072         return UESB_SUCCESS;
00073     }
00074     
00075     uint32_t uesb_get_tx_attempts(uint32_t *attempts)
00076     {
00077         if(m_uesb_mainstate == UESB_STATE_UNINITIALIZED) return UESB_ERROR_NOT_INITIALIZED;
00078         *attempts = m_last_tx_attempts;
00079         return UESB_SUCCESS;
00080     }
00081     
00082     uint32_t uesb_read_rx_payload(uesb_payload_t *payload)
00083     {
00084         if(m_uesb_mainstate == UESB_STATE_UNINITIALIZED) return UESB_ERROR_NOT_INITIALIZED;
00085         if(m_rx_fifo.count == 0) return UESB_ERROR_RX_FIFO_EMPTY;
00086     
00087         DISABLE_RF_IRQ;
00088         payload->length = m_rx_fifo.payload_ptr[m_rx_fifo.exit_point]->length;
00089         payload->pipe   = m_rx_fifo.payload_ptr[m_rx_fifo.exit_point]->pipe;
00090         payload->rssi   = m_rx_fifo.payload_ptr[m_rx_fifo.exit_point]->rssi;
00091         memcpy(payload->data, m_rx_fifo.payload_ptr[m_rx_fifo.exit_point]->data, payload->length);
00092         if(++m_rx_fifo.exit_point >= UESB_CORE_RX_FIFO_SIZE) m_rx_fifo.exit_point = 0;
00093         m_rx_fifo.count--;
00094         ENABLE_RF_IRQ;
00095     
00096         return UESB_SUCCESS;
00097     }
00098     
00099     uint32_t uesb_get_clear_interrupts(uint32_t *interrupts)
00100     {
00101         DISABLE_RF_IRQ;
00102         *interrupts = m_interrupt_flags;
00103         m_interrupt_flags = 0;
00104         ENABLE_RF_IRQ;
00105         return UESB_SUCCESS;
00106     }
00107 };
00108     
00109 Micro_esb micro_esb;    
00110     
00111 
00112 void uesb_event_handler()
00113 {
00114     static uint32_t rf_interrupts;
00115     static uint32_t tx_attempts;
00116     
00117     micro_esb.uesb_get_clear_interrupts(&rf_interrupts);
00118     
00119     if(rf_interrupts & UESB_INT_TX_SUCCESS_MSK)
00120     {   
00121     }
00122     
00123     if(rf_interrupts & UESB_INT_TX_FAILED_MSK)
00124     {
00125         micro_esb.uesb_flush_tx();
00126     }
00127     
00128     if(rf_interrupts & UESB_INT_RX_DR_MSK)
00129     {
00130         micro_esb.uesb_read_rx_payload(&rx_payload);
00131         NRF_GPIO->OUTCLR = 0xFUL << 8;
00132         NRF_GPIO->OUTSET = (uint32_t)((rx_payload.data[2] & 0x0F) << 8);
00133     }
00134     
00135     micro_esb.uesb_get_tx_attempts(&tx_attempts);
00136     NRF_GPIO->OUTCLR = 0xFUL << 12;
00137     NRF_GPIO->OUTSET = (tx_attempts & 0x0F) << 12;
00138 }
00139 
00140 int main(void)
00141 {
00142     uint8_t rx_addr_p0[] = {0x12, 0x34, 0x56, 0x78, 0x9A};
00143     uint8_t rx_addr_p1[] = {0xBC, 0xDE, 0xF0, 0x12, 0x23};
00144     uint8_t rx_addr_p2   = 0x66;
00145     
00146     //nrf_gpio_range_cfg_output(8, 15);
00147     
00148     uesb_mainstate_t  m_uesb_mainstate = UESB_STATE_UNINITIALIZED;
00149     
00150     //m_interrupt_flags = 0;
00151     
00152     NRF_CLOCK->EVENTS_HFCLKSTARTED = 0;
00153     NRF_CLOCK->TASKS_HFCLKSTART = 1;
00154     while(NRF_CLOCK->EVENTS_HFCLKSTARTED == 0);
00155 
00156     uesb_config_t uesb_config       = UESB_DEFAULT_CONFIG;
00157     uesb_config.rf_channel          = 5;
00158     uesb_config.crc                 = UESB_CRC_16BIT;
00159     uesb_config.retransmit_count    = 6;
00160     uesb_config.retransmit_delay    = 500;
00161     uesb_config.dynamic_ack_enabled = 0;
00162     uesb_config.protocol            = UESB_PROTOCOL_ESB_DPL;
00163     uesb_config.bitrate             = UESB_BITRATE_2MBPS;
00164     uesb_config.event_handler       = uesb_event_handler;
00165     
00166     //uesb_init(&uesb_config);
00167 
00168     micro_esb.uesb_set_address(UESB_ADDRESS_PIPE0, rx_addr_p0);
00169     micro_esb.uesb_set_address(UESB_ADDRESS_PIPE1, rx_addr_p1);
00170     micro_esb.uesb_set_address(UESB_ADDRESS_PIPE2, &rx_addr_p2);
00171 
00172     tx_payload.length  = 8;
00173     tx_payload.pipe    = 0;
00174     tx_payload.data[0] = 0x01;
00175     tx_payload.data[1] = 0x00;
00176     tx_payload.data[2] = 0x00;
00177     tx_payload.data[3] = 0x00;
00178     tx_payload.data[4] = 0x11;
00179     
00180     while (true)
00181     {   
00182         //if(uesb_write_tx_payload(&tx_payload) == UESB_SUCCESS)
00183         //{
00184         //    tx_payload.data[1]++;
00185         //}
00186         nrf_delay_us(10000);
00187     }
00188 }
00189