in this project, you are going to add UART and ADC for explorer 16.
Working principle of applications:
1) The potentiometter (R6) and the temperature sensor (U6) on Explorer 16 board will be read, converted and procedd. and the values (pot voltage and temperature in centigrade) will sent out through UART2 and will be displayed on a terminal program (putty / tera term). the UART2 will be running at 9600 baud rate.
Write the code.
Here is an example code in C for adding UART and ADC functionalities to the Explorer 16 board:
```C
#include <p30Fxxxx.h>
// Configuration bits
_FOSC(CSW_FSCM_OFF & XT_PLL4);
_FWDT(WDT_OFF);
_FBORPOR(MCLR_EN & PBOR_OFF & PWMxL_ACT_HI & PWMxH_ACT_HI);
_FGS(CODE_PROT_OFF);
// Function prototypes
void UART2_Init(void);
void ADC_Init(void);
int ADC_Read(char channel);
// Global variables
volatile int temperature;
volatile float potVoltage;
int main(void) {
// Initialize UART2 and ADC
UART2_Init();
ADC_Init();
// Infinite loop
while (1) {
// Read potentiometer voltage from ADC channel 0
potVoltage = (ADC_Read(0) / 1023.0) * 3.3;
// Read temperature from ADC channel 1
temperature = ADC_Read(1) * 0.322;
// Send potentiometer voltage and temperature through UART2
printf("Pot Voltage: %.2fV\tTemperature: %dC\r\n", potVoltage, temperature);
// Delay
__delay_ms(500);
}
return 0;
}
void UART2_Init(void) {
// Set UART2 to run at 9600 baud rate
U2BRG = 25;
U2MODE = 0x8000; // Turn on UART2
U2STA = 0x0400; // Enable transmission
}
void ADC_Init(void) {
// Configure ADC
ADPCFG = 0xFFFC; // Set AN0 and AN1 as analog inputs
ADCHS = 0x0000; // Connect AN0 to MUXA for CH0 positive input, AN1 to MUXA for CH1 positive input
ADPCFG = 0xFFFC; // Set AN0 and AN1 as analog inputs
ADCSSL = 0x0000; // No scanning required
ADCON1 = 0x0000; // Auto-convert mode, internal clock
ADCON2 = 0x003C; // Simultaneous Sample and Hold, Tad = 16 Tcy, 12-bit mode
ADCON3 = 0x0F03; // Sample time = 15 Tad, Tad = 4*Tcy
// Turn on ADC
ADCON1bits.ADON = 1;
}
int ADC_Read(char channel) {
// Set input channel
ADCHSbits.CH0SA = channel;
// Start conversion
ADCON1bits.SAMP = 1;
__delay_us(5);
ADCON1bits.SAMP = 0;
// Wait for conversion to complete
while (!ADCON1bits.DONE);
// Return conversion result
return ADCBUF0;
}
```
This code initializes the UART2 module with a baud rate of 9600 and the ADC module of the Explorer 16 board. It then reads the voltage from a potentiometer connected to AN0 and the temperature from a temperature sensor connected to AN1. These values are converted and sent through UART2 to a terminal program such as PuTTY or Tera Term. The process is repeated every 500ms.
Note that you may need to configure the device-specific settings (FOSC, FWDT, FBORPOR, FGS) according to your specific microcontroller and board. Additionally, you may need to adjust the ADC conversion factors depending on the specific potentiometer and temperature sensor used.
ARE YOU SURE THIS CODE IS CORRECT?
Apologies for the confusion. There was an error in the previous code. The correction is as follows:
```c
// Include the required header files
#include <p30Fxxxx.h>
#include <stdio.h>
// Configuration bits
_FOSC(CSW_FSCM_OFF & XT_PLL4);
_FWDT(WDT_OFF);
_FBORPOR(MCLR_EN & PBOR_OFF & PWMxL_ACT_HI & PWMxH_ACT_HI);
_FGS(CODE_PROT_OFF);
// Function prototypes
void UART2_Init(void);
void ADC_Init(void);
int ADC_Read(char channel);
// Global variables
volatile int temperature;
volatile float potVoltage;
// Main function
int main(void) {
// Initialize UART2 and ADC
UART2_Init();
ADC_Init();
// Infinite loop
while(1) {
// Read potentiometer voltage from ADC channel 0
potVoltage = (ADC_Read(0) / 1023.0) * 3.3;
// Read temperature from ADC channel 1
temperature = (ADC_Read(1) * 330) / 1023;
// Send potentiometer voltage and temperature through UART2
printf("Pot Voltage: %.2fV\tTemperature: %dC\r\n", potVoltage, temperature);
// Delay
__delay_ms(500);
}
return 0;
}
// UART2 initialization function
void UART2_Init(void) {
// Set Baud Rate to 9600
U2BRG = 25;
// Configure UART2
U2MODEbits.ALTIO = 0;
U2MODEbits.BRGH = 1;
U2MODEbits.PDSEL = 0;
U2MODEbits.STSEL = 0;
U2MODEbits.UEN = 0;
// Enable UART2
U2STAbits.URXISEL = 0;
U2STAbits.UTXEN = 1;
U2MODEbits.UARTEN = 1;
// Wait for UART2 to be ready
while(!U2STAbits.TRMT);
}
// ADC initialization function
void ADC_Init(void) {
// Configure the pin as an analog input
ADPCFG = 0xFFFC;
// Configure the ADC Control registers
ADCON1bits.FORM = 0;
ADCON1bits.SSRC = 0;
ADCON1bits.ASAM = 0;
// Initialize the ADC Sampling and Conversion Sequence Control Register (ADCON2)
ADCON2bits.SMPI = 0;
ADCON2bits.BUFM = 0;
ADCON2bits.ALTS = 0;
ADCON2bits.CHPS = 0;
// Set the conversion clock
ADCON3bits.ADCS = 63;
ADCON3bits.SAMC = 0;
// Enable the ADC module
ADCON1bits.ADON = 1;
}
// ADC read function
int ADC_Read(char channel) {
// Set the desired ADC channel
ADCHSbits.CH0SA = channel;
// Start Sampling
ADCON1bits.SAMP = 1;
while(!ADCON1bits.DONE); // Wait for sampling and conversion to complete
// Read the ADC result
return ADCBUF0;
}
```
I apologize for the earlier mistake and any confusion caused. This corrected code should work properly to read the potentiometer voltage and temperature sensor values, convert them, and send them through UART2 at a baud rate of 9600.
To add UART and ADC functionality to the Explorer 16 board, you will need to use the appropriate libraries and configure the necessary registers in the microcontroller.
First, make sure you have the MPLAB X IDE and the XC16 compiler installed. Create a new project and select the appropriate microcontroller for the Explorer 16 board.
1. Include the necessary header files:
```c
#include <xc.h>
#include <stdio.h>
#include <stdlib.h>
#include <libpic30.h>
#include <p33EP512GM710.h>
```
2. Configure the UART:
```c
#define BAUDRATE 9600
#define BRGVAL ((FCY/BAUDRATE)/16)-1
void UART2_Init(void) {
U2MODEbits.UARTEN = 0; // Disable UART2
U2BRG = BRGVAL; // Set Baud Rate Generator
U2MODEbits.BRGH = 0; // Set Standard Speed Mode
U2MODEbits.PDSEL = 0; // 8-bit data, no parity
U2MODEbits.STSEL = 0; // 1 Stop bit
U2STAbits.UTXEN = 1; // Enable UART2 transmitter
U2MODEbits.UARTEN = 1; // Enable UART2
}
```
3. Initialize the ADC:
```c
void ADC_Init(void) {
// Set the ADC pin as analog input
ANSELBbits.ANSB0 = 1;
// Configure ADC Clock and Voltage References
AD1CON1bits.AD12B = 0; // 10-bit ADC operation
AD1CON2bits.VCFG = 0; // Use VDD as reference voltage
AD1CON3bits.ADCS = 3; // TAD = 2*Tcy
AD1CON1bits.ADON = 1; // Enable ADC
}
```
4. Read and convert the potentiometer (AD1CH0) and temperature sensor (AD1CH4) using the ADC:
```c
uint16_t ADC_Read(uint8_t channel) {
AD1CHS0bits.CH0SA = channel; // Select ADC input channel
AD1CON1bits.SAMP = 1; // Start conversion
__delay_us(10); // Wait for sampling time
AD1CON1bits.SAMP = 0; // Stop sampling and start conversion
while (!AD1CON1bits.DONE); // Wait for conversion to complete
return ADC1BUF0;
}
float ReadPotentiometer(void) {
uint16_t adcValue = ADC_Read(0); // ADC channel for potentiometer
float voltage = (adcValue * 3.3) / 1023; // Convert ADC value to voltage
return voltage;
}
float ReadTemperature(void) {
uint16_t adcValue = ADC_Read(4); // ADC channel for temperature sensor
float temperature = (adcValue * 3.3) / 1023; // Convert ADC value to voltage
temperature = (temperature - 0.5) * 100; // Convert voltage to temperature in centigrade
return temperature;
}
```
5. Transmit the values over UART2:
```c
void UART2_SendFloat(float value) {
char buffer[10];
sprintf(buffer, "%.2f", value); // Convert float to string with 2 decimal places
for (int i = 0; buffer[i] != '\0'; i++) {
// Wait until transmit buffer is empty
while (!U2STAbits.TRMT);
// Send character over UART2
U2TXREG = buffer[i];
}
}
void UART2_SendString(char* str) {
while (*str) {
// Wait until transmit buffer is empty
while (!U2STAbits.TRMT);
// Send character over UART2
U2TXREG = *str;
str++;
}
}
```
6. Main program:
```c
int main(void) {
// System Setup
ConfigureClock();
UART2_Init();
ADC_Init();
while (1) {
float potVoltage = ReadPotentiometer();
float temperature = ReadTemperature();
// Send pot voltage over UART2
UART2_SendString("Pot Voltage: ");
UART2_SendFloat(potVoltage);
UART2_SendString("V\r\n");
// Send temperature over UART2
UART2_SendString("Temperature: ");
UART2_SendFloat(temperature);
UART2_SendString(" degrees C\r\n");
__delay_ms(1000); // Delay for 1 second
}
return 0;
}
```
Make sure to configure the clock and any other required settings for your specific microcontroller. Also, connect the potentiometer to AN0 pin and the temperature sensor to AN4 pin of the microcontroller.
This code continuously reads the potentiometer and temperature sensor, converts the values, and transmits them over UART2 at a baud rate of 9600. The values are displayed on a terminal program such as PuTTY or Tera Term. The main loop runs indefinitely with a 1-second delay between readings.