I have a fully functional code for 8-bit data acquisition using nrf24le1. Now i want to upgrade it to 12-bit resolution ,but i have problems in doing so .
In my project i am trying to read electrical signals through 7 channels using nrf24le1, this acquired data is sent wireless through a radio with a channel frequency of 2.4GHz and finally the signal is read in a computer. This is my code for 12-bit resolution and my errors: transmitter code:
/* Code for the transmitter: contains 2 continuous A/D conversion and transmit to base station, 2 bytes per packet.
*/ #include <Nordic\reg24le1.h> #include <stdint.h> #include "hal_nrf_hw.h" //#include "MyCustom.h" #include "hal_nrf.h" #include "hal_adc.h"
#define SAMPLING_INTERVAL_US 10000 //sampling rate is 10^6 / 10000 #define CHANNEL_NUMBER 7 #define PAYLOAD_LUMPS 3
#define TIMER_RELOAD_LSB (uint8_t)(0x10000-((SAMPLING_INTERVAL_US/3)*4)) #define TIMER_RELOAD_MSB (uint8_t)((0x10000 -((SAMPLING_INTERVAL_US/3)*4))>>8)
uint8_t adc_data_lsb;
uint16_t rf_payload[CHANNEL_NUMBER * PAYLOAD_LUMPS];//changing the Channel_number to payload_size
uint16_t dummy[CHANNEL_NUMBER * PAYLOAD_LUMPS];
uint8_t i, timer_set;
uint8_t timerSet = 0;
// ADC initialization
void adc_init()
{
hal_adc_set_input_channel(HAL_ADC_INP_AIN0);
hal_adc_set_reference(HAL_ADC_REF_VDD);
hal_adc_set_input_mode(HAL_ADC_SINGLE); // can be changed to differential
hal_adc_set_conversion_mode(HAL_ADC_SINGLE_STEP);
hal_adc_set_resolution(HAL_ADC_RES_12BIT);
hal_adc_set_data_just(HAL_ADC_JUST_RIGHT);
}
void main()
{
uint8_t i, j;
// Variable declarations.
//P3DIR = 0x00;
// Initialize the ADC.
adc_init();
// 1. To use the radio the radio clock must be enabled.
RFCKEN = 1;
TMOD = 0x01; // Timer 0 mode 1, 16-bit mode
TR0 = 1; // Start timer 0
ET0 = 1; // Enable timer 0 interrupt
// 2. If the RF interrupt should be used, remember to set both the global interrupt enable flag and the RF interrupt enable flag.
RF = 1;
EA = 1;
// 3. By default the radio will be in PTX mode, and powered down. The last thing needed is to power it up before it is ready for use.
hal_nrf_set_power_mode(HAL_NRF_PWR_UP);
//hal_nrf_enable_continious_wave (1) ;
// P0DIR = 0x00; // P0DIR = 0xFF;
while(1)
{
for( i =0; i < PAYLOAD_LUMPS; i++ )
{
while(!timerSet);
timerSet = 0;
//Main ADC sampling code
for( j = 0; j < CHANNEL_NUMBER; j++ )
{
hal_adc_set_input_channel(i);
hal_adc_start();
while( hal_adc_busy() );
rf_payload[j+i*CHANNEL_NUMBER] = hal_adc_read_LSB();
// rf_payload[j+i*CHANNEL_NUMBER] +=((unit16_t)hal_adc_read_MSB()) << 8;
dummy[j+i*CHANNEL_NUMBER] = (((uint16_t)hal_adc_read_MSB())<<8);
rf_payload[j+i*CHANNEL_NUMBER] = rf_payload[j+i*CHANNEL_NUMBER] + dummy[j+i*CHANNEL_NUMBER];
}
}
hal_nrf_write_tx_payload(rf_payload, CHANNEL_NUMBER * PAYLOAD_LUMPS);
CE_PULSE();
}
}
void timer0_irq() interrupt INTERRUPT_T0
{
TL0 = TIMER_RELOAD_LSB;
TH0 = TIMER_RELOAD_MSB;
timerSet = 1;
}
// It is recommended to use an interrupt to receive data sent (TX_DS), // data received (RX_DR) or max retransmit (MAX_RT) messages from the radio. void rf_irq() interrupt INTERRUPT_RFIRQ { // Read and clear IRQ flags from radio uint8_t irq_flags = hal_nrf_get_clear_irq_flags(); switch(irq_flags) { // Transmission success case (1 << HAL_NRF_TX_DS): //radio_busy = false; // Data has been sent break; // Transmission failed (maximum re-transmits) case (1 << HAL_NRF_MAX_RT): // When a MAX_RT interrupt occurs the TX payload will not be removed from the TX FIFO. // If the packet is to be discarded this must be done manually by flushing the TX FIFO. // Alternatively, CE_PULSE() can be called re-starting transmission of the payload. // (Will only be possible after the radio irq flags are cleared) hal_nrf_flush_tx(); //radio_busy = false; break; } }
ERRORS:
SEGMENT: ?DT?_HAL_NRF_SET_RF_CHANNEL?HAL_NRF
LENGTH: 0001H
*** ERROR L107: ADDRESS SPACE OVERFLOW
SPACE: DATA
SEGMENT: ?DT?_HAL_NRF_SETUP_DYNAMIC_PAYLOAD?HAL_NRF
LENGTH: 0001H
Program Size: data=164.0 xdata=0 code=2301
Target not created
RECEIVER CODE:
/* Code for the receiver: should be a continuous receiver that transmit the received packets to a PC through a UART communication. */ #include <stdio.h> #include <Nordic\reg24le1.h> #include <stdint.h> #include "hal_nrf_hw.h" //#include "MyCustom.h" #include "hal_uart.h" #include "hal_nrf.h"
#define CHANNEL_NUMBER 7 #define PAYLOAD_LUMPS 3 //#define PAYLOAD_SIZE 8 // difining a payload size different than channel_number
// Variable declarations. uint8_t rf_status; uint8_t rf_payload[CHANNEL_NUMBER * PAYLOAD_LUMPS]; uint8_t dataready = 0; bit data_received = 0;
void main()
{
uint8_t i;
// uint8_t cnt, i = 0;
// Enable RF interrupt and activate the global interrupt flag.
RF = 1;
EA = 1;
RFCKEN = 1;
// 1. By default the radio will be in PTX mode. This means we need to active PRX mode to use it as a receiver.
hal_nrf_set_operation_mode(HAL_NRF_PRX);
// 2. With the default settings Pipe 0 will be used to receive incomming packets. For the radio to receive the packets sent by
// project 03 it is important to configure the Pipe 0 with the right payload length (3 bytes).
hal_nrf_set_rx_payload_width(0, CHANNEL_NUMBER * PAYLOAD_LUMPS);
// Power up the radio.
hal_nrf_set_power_mode(HAL_NRF_PWR_UP);
// hal_nrf_enable_continious_wave (1) ;
// 3. To enable the receiver the Chip Enable signal should be set high permantently.
RFCE = 1;
//Setup the UART pins as outputs
// P0DIR = 0xDF; // P0DIR = 0xDF; P0DIR = 0x00;
// Init UART
//hal_uart_init();
hal_uart_init(UART_BAUD_38K4);
while(1)
{
if( data_received )
{
for( i = 0; i < CHANNEL_NUMBER * PAYLOAD_LUMPS; i++)
hal_uart_putchar(rf_payload[i]);
data_received = 0;
}
} }
// if(cnt = hal_uart_chars_available()) // { // for( i = 0; i < cnt; i++) // hal_uart_putchar( i ); // }
// } //}
// It is recommended to use an interrupt to receive data sent (TX_DS),
// data received (RX_DR) or max retransmit (MAX_RT) messages from the radio.
void rf_irq() interrupt INTERRUPT_RFIRQ
{
//uint8_t i;
//payload_counter = (payload_counter+1)%2;
// 4. The status of the interrupt flags should be read out and stored in the "rf_status" variable.
rf_status = hal_nrf_get_clear_irq_flags();
// It is common to use a switch to check which of the RF status bits were set.
// Since this example will only be used as a receiver we should only expect RX_DR interrupts, but the other interrupts
// are included for reference.
switch( rf_status )
{
case (1<<HAL_NRF_RX_DR):
// 5. The RF payload must be read out and put in a buffer.
hal_nrf_read_rx_payload(rf_payload);
// for( i = 0; i < CHANNEL_NUMBER * PAYLOAD_LUMPS; i++) // for( i = 0; i < CHANNEL_NUMBER * PAYLOAD_LUMPS; i++) // hal_uart_putchar(rf_payload[i]); data_received = 1;
break;
// A packet was sent.
case (1<<HAL_NRF_TX_DS):
break;
// A packet was sent, but no acknowledge was received.
case (1<<HAL_NRF_MAX_RT):
break;
}
}