-
Notifications
You must be signed in to change notification settings - Fork 0
ADC Example
This page contains information describing the provided ADC example. Code examples can be found within the examples
folder in the repository.
/********************************************************
* File Name: adc_ex.c
*
* Description:
* Main file
*
*
*********************************************************/
/*************************************************************************
System Includes
************************************************************************/
#include "sublibinal.h"
#include "sublibinal_config.h"
//forward declarations
void timer_callback(void);
void adc_callback(ADC_Node node);
/*************************************************************************
Main Function
************************************************************************/
int main(void) {
//buffers
uint8 uart_tx_buffer[128];
uint8 adc_work_queue[10*sizeof(ADC_Data)], adc_results_queue[10*sizeof(ADC_Data)];
//structures for configuring peripherals
UART_Config uart_config = {0};
Timer_Config timer_config = {0};
ADC_Config adc_config = {0};
Packetizer_Config packetizer_config = {0};
//disable interrupts
disable_Interrupts();
//setup peripherals
timer_config.frequency = 10; //Set the timer to operate at 10Hz
timer_config.pbclk = PB_CLK;
timer_config.which_timer = Timer_1; //Use timer 1
timer_config.callback = &timer_callback; //Hand a callback function for the ISR functionality
timer_config.enabled = 1; //Enable the timer
initialize_Timer(timer_config); //Initialize the timer module
uart_config.which_uart = UART_CH_1; //Specify UART channel 1 for us
uart_config.pb_clk = PB_CLK; //Tell the module the speed of our clock
uart_config.speed = 115200; //Specify the buadrate to be 115.2k
uart_config.tx_buffer_ptr = uart_tx_buffer; //Hand a data pointer to the transmission buffer
uart_config.tx_buffer_size = sizeof(uart_tx_buffer); //Tell the UART the size of the transmission buffer
uart_config.tx_en = 1; //Enable transmission
uart_config.tx_pin = Pin_RPB15;
initialize_UART(uart_config); //Initialize the UART module
packetizer_config.callback = NULL; //Specify that there is no callback function for the packetizer
packetizer_config.control_byte = '!'; //Specify that the ! symbol is our control byte for the packet
packetizer_config.uart_config = uart_config; //Hand the packetizer our UART configuration that the packetizer will use
packetizer_config.which_channel = PACKET_UART_CH_1; //Specify that this will use UART Channel 1 of rhte packetizer
initialize_packetizer(packetizer_config); //Initialize the packetizer moudule
adc_config.channels = (1 << ADC_CH_0) | (1 << ADC_CH_1); //Specify that we are using ADC channels 0 and 1
adc_config.work_buffer_ptr = adc_work_queue; //Hand a pointer for the work data
adc_config.work_buffer_size = sizeof(adc_work_queue); //Tell the ADC the size of the work data
adc_config.result_buffer_ptr = adc_results_queue; //Hand a data pointer for the results data
adc_config.result_buffer_size = sizeof(adc_results_queue); //Tell the ADC the size of the results buffer
initialize_ADC(adc_config); //Initialize the ADC module
//Global interrupt enable. Do this last!
enable_Interrupts();
while (1) {
bg_process_ADC(); //This process must be in the embedded loop for processing of completed data
}
return 0;
}
void timer_callback(void)
{
//Conduct a read of an ADC node
ADC_Node node = {0};
node.device_id = 0x01; //Specify an arbitrary ID for this device. We will use this for identification purposes later
node.channel = ADC_CH_0; //Specify which channel this device is on
node.callback = &adc_callback; //Specify a callback for when the data is completed
read_ADC(node); //Read the ADC node
node.device_id = 0x02; //Specify another arbitrary ID for this other device
node.channel = ADC_CH_1; //Specify that this will be read from channel 1
node.callback = &adc_callback; //Hand a callback function for when the data is completed
read_ADC(node); //Conduct a read of this different ADC node
}
//This function is called during the bg_process_ADC() function
//The purpose of this function is to do something meaningful with the data
void adc_callback(ADC_Node node)
{
uint8 send_data[3];
uint8 data_LB, data_HB;
//We will break apart the data in the node into a series of bytes
data_LB = node.data & 0xFF;
data_HB = node.data >> 8;
//We will populate an array with data for transmission
send_data[0] = node.device_id;
send_data[1] = data_LB;
send_data[2] = data_HB;
//Send a packet of information up the Packetizer
send_packet(PACKET_UART_CH_1, send_data, sizeof(send_data));
}
This example contains a number of crucial portions of code that are extremely important for ADC Configuration. In this example, a UART with packetizer implementation is initialized for transmission of converted ADC data, and a timer firing at a frequency of 1KHz is driving the ADC reads.
The first important section of code is the initialization of the ADC:
adc_config.channels = (1 << ADC_CH_0) | (1 << ADC_CH_1); //Specify that we are using ADC channels 0 and 1
adc_config.work_buffer_ptr = adc_work_queue; //Hand a pointer for the work data
adc_config.work_buffer_size = sizeof(adc_work_queue); //Tell the ADC the size of the work data
adc_config.result_buffer_ptr = adc_results_queue; //Hand a data pointer for the results data
adc_config.result_buffer_size = sizeof(adc_results_queue); //Tell the ADC the size of the results buffer
initialize_ADC(adc_config); //Initialize the ADC module
In this code section, we specify that we are using AN0 and AN1 pins and we provide work and result buffers to the ADC. We then call the ADC initialization to set up the ADC for conversion.
The next important section of code is located towards the end of the main program:
while (1) {
bg_process_ADC(); //This process must be in the embedded loop for processing of completed data
}
This is where the background process should be placed. This process must continually run so that converted data from the AC can be properly handled.
Another crucial portion of ADC implementation occurs within the timer callback function, where we create a node and place it in the work buffer to perform a read of the ADC:
void timer_callback(void)
{
//Conduct a read of an ADC node
ADC_Node node = {0};
node.device_id = 0x01; //Specify an arbitrary ID for this device. We will use this for identification purposes later
node.channel = ADC_CH_0; //Specify which channel this device is on
node.callback = &adc_callback; //Specify a callback for when the data is completed
read_ADC(node); //Read the ADC node
node.device_id = 0x02; //Specify another arbitrary ID for this other device
node.channel = ADC_CH_1; //Specify that this will be read from channel 1
node.callback = &adc_callback; //Hand a callback function for when the data is completed
read_ADC(node); //Conduct a read of this different ADC node
}
In this function, we are specifying that the first read will have an ID=1, will be read from channel 0, and will invoke the adc_callback
function when completed. We then place this node in the work buffer by calling the read_ADC(node);
line. This function also exemplifies that we may freely modify the node after placing it in the buffer without causing the ADC to malfunction. We then create another read with an ID=2, using channel 1, that also utilizes the adc_callback
function. We then enqueue this node for a read as well and return to normal program execution.
The final crucial portion of the ADC example occurs within the adc_callback
function.
void adc_callback(ADC_Node node)
{
uint8 send_data[3];
uint8 data_LB, data_HB;
//We will break apart the data in the node into a series of bytes
data_LB = node.data & 0xFF;
data_HB = node.data >> 8;
//We will populate an array with data for transmission
send_data[0] = node.device_id;
send_data[1] = data_LB;
send_data[2] = data_HB;
//Send a packet of information up the Packetizer
send_packet(PACKET_UART_CH_1, send_data, sizeof(send_data));
}
The first important observation is to see that this function returns nothing, but accepts a single ADC_Node
parameter. This parameter is used for providing the results and ID to the callback function. Within this function, we must break apart the results of the ADC into two separate bytes for transmission on the UART. We then construct a packet of information out of the device ID and the results and transmit this data up the UART. This shows that data can then be differentiated based on ID and the use of the ADC_Node
function parameter. If desired, a switch statement can be implemented to call different programs based upon the node ID. The callback function is invoked from the background process, so it is not contained within an interrupt and may be interrupted.
SUBLIBinal was created by the Palouse Robosub Club.