13 Appendix
ADC Single Conversion Code Example
/*
\file main.c
\brief ADC Single Conversion
(c) 2019 Microchip Technology Inc. and its subsidiaries.
Subject to your compliance with these terms, you may use Microchip software and any
derivatives exclusively with Microchip products. It is your responsibility to comply with third-party
license terms applicable to your use of third-party software (including open source software) that
may accompany Microchip software.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY
IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS
FOR A PARTICULAR PURPOSE.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP
HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO
THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP’S TOTAL LIABILITY ON ALL
CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT
OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS
SOFTWARE.
*/
#define F_CPU 4000000UL /* Main clock frequency */
#define START_TOKEN 0x03 /* Start Frame Token */
#define END_TOKEN 0xFC /* End Frame Token */
/* Compute the baud rate */
#define USART1_BAUD_RATE(BAUD_RATE) (((float)F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
#include <avr/io.h>
#include <stdbool.h>
#include <avr/cpufunc.h>
void CLKCTRL_init(void);
void PORT_init(void);
void VREF0_init(void);
void ADC0_init(void);
void USART1_init(void);
uint16_t ADC0_read(void);
void ADC0_start(void);
void USART1_Write(const uint8_t data);
/* This function initializes the CLKCTRL module */
void CLKCTRL_init(void)
{
/* FREQSEL 4M */
ccp_write_io((void*)&(CLKCTRL.OSCHFCTRLA), (CLKCTRL.OSCHFCTRLA | CLKCTRL_FREQSEL_4M_gc));
}
/* This function initializes the PORT module */
void PORT_init(void)
{
/* Configure PC0 as output for USART1 TX */
PORTC.DIRSET = PIN0_bm;
/* Disable interrupt and digital input buffer on PD3 */
PORTD.PIN3CTRL &= ~PORT_ISC_gm;
PORTD.PIN3CTRL |= PORT_ISC_INPUT_DISABLE_gc;
/* Disable pull-up resistor */
PORTD.PIN3CTRL &= ~PORT_PULLUPEN_bm;
}
/* This function initializes the VREF module */
void VREF0_init(void)
{
VREF.ADC0REF = VREF_REFSEL_2V048_gc; /* Internal 2.048V reference */
}
/* This function initializes the ADC module */
void ADC0_init(void)
{
ADC0.CTRLC = ADC_PRESC_DIV4_gc; /* CLK_PER divided by 4 */
ADC0.CTRLA = ADC_ENABLE_bm /* ADC Enable: enabled */
| ADC_RESSEL_12BIT_gc; /* 12-bit mode */
ADC0.MUXPOS = ADC_MUXPOS_AIN3_gc; /* Select ADC channel AIN3 <-> PD3 */
}
/* This function initializes the USART module */
void USART1_init(void)
{
/* Configure the baud rate: 115200 */
USART1.BAUD = (uint16_t)USART1_BAUD_RATE(115200);
USART1.CTRLB = USART_TXEN_bm; /* Enable TX */
USART1.CTRLC = USART_CHSIZE_8BIT_gc; /* Configure character size: 8 bit */
}
/* This function returns the ADC conversion result */
uint16_t ADC0_read(void)
{
/* Wait for ADC result to be ready */
while (!(ADC0.INTFLAGS & ADC_RESRDY_bm));
/* Clear the interrupt flag by reading the result */
return ADC0.RES;
}
/* This function starts the ADC conversions*/
void ADC0_start(void)
{
/* Start ADC conversion */
ADC0.COMMAND = ADC_STCONV_bm;
}
/* This function transmits one byte through USART */
void USART1_Write(const uint8_t data)
{
/* Check if USART buffer is ready to transmit data */
while (!(USART1.STATUS & USART_DREIF_bm));
/* Transmit data using TXDATAL register */
USART1.TXDATAL = data;
}
int main(void)
{
uint16_t adcVal;
/* Initialize all peripherals */
CLKCTRL_init();
PORT_init();
VREF0_init();
ADC0_init();
USART1_init();
while (1)
{
/* Start the ADC conversion */
ADC0_start();
/* Read the ADC result */
adcVal = ADC0_read();
/* Transmit the ADC result to be plotted using Data Visualizer */
USART1_Write(START_TOKEN);
USART1_Write(adcVal & 0x00FF);
USART1_Write(adcVal >> 8);
USART1_Write(END_TOKEN);
}
}ADC Free-Running Conversion Code Example
/*
\file main.c
\brief ADC Free-Running
(c) 2019 Microchip Technology Inc. and its subsidiaries.
Subject to your compliance with these terms, you may use Microchip software and any
derivatives exclusively with Microchip products. It is your responsibility to comply with third-party
license terms applicable to your use of third-party software (including open source software) that
may accompany Microchip software.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY
IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS
FOR A PARTICULAR PURPOSE.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP
HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO
THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP’S TOTAL LIABILITY ON ALL
CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT
OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS
SOFTWARE.
*/
#define F_CPU 4000000UL /* Main clock frequency */
#define START_TOKEN 0x03 /* Start Frame Token */
#define END_TOKEN 0xFC /* End Frame Token */
/* Compute the baud rate */
#define USART1_BAUD_RATE(BAUD_RATE) (((float)F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
#include <avr/io.h>
#include <stdbool.h>
#include <avr/cpufunc.h>
void CLKCTRL_init(void);
void PORT_init(void);
void VREF0_init(void);
void ADC0_init(void);
void USART1_init(void);
uint16_t ADC0_read(void);
void ADC0_start(void);
void USART1_Write(const uint8_t data);
/* This function initializes the CLKCTRL module */
void CLKCTRL_init(void)
{
/* FREQSEL 4M */
ccp_write_io((void*)&(CLKCTRL.OSCHFCTRLA), (CLKCTRL.OSCHFCTRLA | CLKCTRL_FREQSEL_4M_gc));
}
/* This function initializes the PORT module */
void PORT_init(void)
{
/* Configure PC0 as output for USART1 TX */
PORTC.DIRSET = PIN0_bm;
/* Disable interrupt and digital input buffer on PD3 */
PORTD.PIN3CTRL &= ~PORT_ISC_gm;
PORTD.PIN3CTRL |= PORT_ISC_INPUT_DISABLE_gc;
/* Disable pull-up resistor */
PORTD.PIN3CTRL &= ~PORT_PULLUPEN_bm;
}
/* This function initializes the VREF module */
void VREF0_init(void)
{
VREF.ADC0REF = VREF_REFSEL_2V048_gc; /* Internal 2.048V reference */
}
/* This function initializes the ADC module */
void ADC0_init(void)
{
ADC0.CTRLC = ADC_PRESC_DIV4_gc; /* CLK_PER divided by 4 */
ADC0.CTRLA = ADC_ENABLE_bm /* ADC Enable: enabled */
| ADC_RESSEL_12BIT_gc /* 12-bit mode */
| ADC_FREERUN_bm; /* Enable Free-Run mode */
ADC0.MUXPOS = ADC_MUXPOS_AIN3_gc; /* Select ADC channel AIN3 <-> PD3 */
}
/* This function initializes the USART module */
void USART1_init(void)
{
/* Configure the baud rate: 115200 */
USART1.BAUD = (uint16_t)USART1_BAUD_RATE(115200);
USART1.CTRLB = USART_TXEN_bm; /* Enable TX */
USART1.CTRLC = USART_CHSIZE_8BIT_gc; /* Configure character size: 8 bit */
}
/* This function returns the ADC conversion result */
uint16_t ADC0_read(void)
{
/* Wait for ADC result to be ready */
while (!(ADC0.INTFLAGS & ADC_RESRDY_bm));
/* Clear the interrupt flag by reading the result */
return ADC0.RES;
}
/* This function starts the ADC conversions*/
void ADC0_start(void)
{
/* Start ADC conversion */
ADC0.COMMAND = ADC_STCONV_bm;
}
/* This function transmits one byte through USART */
void USART1_Write(const uint8_t data)
{
/* Check if USART buffer is ready to transmit data */
while (!(USART1.STATUS & USART_DREIF_bm));
/* Transmit data using TXDATAL register */
USART1.TXDATAL = data;
}
int main(void)
{
uint16_t adcVal;
/* Initialize all peripherals */
CLKCTRL_init();
PORT_init();
VREF0_init();
ADC0_init();
USART1_init();
/* Start the ADC conversions */
ADC0_start();
while (1)
{
/* Read the ADC result */
adcVal = ADC0_read();
/* Transmit the ADC result to be plotted using Data Visualizer */
USART1_Write(START_TOKEN);
USART1_Write(adcVal & 0x00FF);
USART1_Write(adcVal >> 8);
USART1_Write(END_TOKEN);
}
}ADC Differential Conversion Code Example
/*
\file main.c
\brief ADC Differential Conversion
(c) 2019 Microchip Technology Inc. and its subsidiaries.
Subject to your compliance with these terms, you may use Microchip software and any
derivatives exclusively with Microchip products. It is your responsibility to comply with third-party
license terms applicable to your use of third-party software (including open source software) that
may accompany Microchip software.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY
IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS
FOR A PARTICULAR PURPOSE.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP
HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO
THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP’S TOTAL LIABILITY ON ALL
CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT
OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS
SOFTWARE.
*/
#define F_CPU 4000000UL /* Main clock frequency */
#define START_TOKEN 0x03 /* Start Frame Token */
#define END_TOKEN 0xFC /* End Frame Token */
/* Compute the baud rate */
#define USART1_BAUD_RATE(BAUD_RATE) (((float)F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
#include <avr/io.h>
#include <stdbool.h>
#include <avr/cpufunc.h>
int16_t adcVal;
void CLKCTRL_init(void);
void PORT_init(void);
void VREF0_init(void);
void ADC0_init(void);
void USART1_init(void);
void ADC0_start(void);
bool ADC0_conversionDone(void);
int16_t ADC0_read(void);
void USART1_Write(const uint8_t data);
void SYSTEM_init(void);
void CLKCTRL_init(void)
{
/* FREQSEL 4M */
ccp_write_io((void*)&(CLKCTRL.OSCHFCTRLA), (CLKCTRL.OSCHFCTRLA | CLKCTRL_FREQSEL_4M_gc));
}
void PORT_init(void)
{
/* Configure PC0 as output for USART1 TX */
PORTC.DIRSET = PIN0_bm;
/* Disable interrupt and digital input buffer on PD3 */
PORTD.PIN3CTRL &= ~PORT_ISC_gm;
PORTD.PIN3CTRL |= PORT_ISC_INPUT_DISABLE_gc;
/* Disable interrupt and digital input buffer on PD4 */
PORTD.PIN4CTRL &= ~PORT_ISC_gm;
PORTD.PIN4CTRL |= PORT_ISC_INPUT_DISABLE_gc;
/* Disable pull-up resistor */
PORTD.PIN3CTRL &= ~PORT_PULLUPEN_bm;
PORTD.PIN4CTRL &= ~PORT_PULLUPEN_bm;
}
void VREF0_init(void)
{
VREF.ADC0REF = VREF_REFSEL_2V048_gc; /* Internal 2.048V reference */
}
void ADC0_init(void)
{
ADC0.CTRLC = ADC_PRESC_DIV4_gc; /* CLK_PER divided by 4 */
ADC0.CTRLA = ADC_ENABLE_bm /* ADC Enable: enabled */
| ADC_RESSEL_12BIT_gc /* 12-bit mode */
| ADC_CONVMODE_bm /* Differential Conversion */
| ADC_FREERUN_bm; /* Enable Free-Run mode */
ADC0.MUXPOS = ADC_MUXPOS_AIN3_gc; /* Select ADC channel AIN3 <-> PD3 */
ADC0.MUXNEG = ADC_MUXNEG_AIN4_gc; /* Select ADC channel AIN4 <-> PD4 */
}
void USART1_init(void)
{
/* Configure the baud rate: 115200 */
USART1.BAUD = (uint16_t)USART1_BAUD_RATE(115200);
USART1.CTRLB = USART_TXEN_bm; /* Enable TX */
USART1.CTRLC = USART_CHSIZE_8BIT_gc; /* Configure character size: 8 bit */
}
int16_t ADC0_read(void)
{
/* Clear the interrupt flag by reading the result */
return ADC0.RES;
}
void ADC0_start(void)
{
/* Start conversion */
ADC0.COMMAND = ADC_STCONV_bm;
}
bool ADC0_conversionDone(void)
{
/* Check if the conversion is done */
return (ADC0.INTFLAGS & ADC_RESRDY_bm);
}
void USART1_Write(const uint8_t data)
{
/* Check if USART buffer is ready to transmit data */
while (!(USART1.STATUS & USART_DREIF_bm));
/* Transmit data using TXDATAL register */
USART1.TXDATAL = data;
}
void SYSTEM_init(void)
{
CLKCTRL_init();
PORT_init();
VREF0_init();
ADC0_init();
USART1_init();
}
int main(void)
{
SYSTEM_init();
ADC0_start();
while (1)
{
if (ADC0_conversionDone())
{
/* Read the ADC result */
adcVal = ADC0_read();
/* Transmit the ADC result to be plotted using Data Visualizer */
USART1_Write(START_TOKEN);
USART1_Write(adcVal & 0x00FF);
USART1_Write(adcVal >> 8);
USART1_Write(END_TOKEN);
}
}
}ADC Sample Accumulator Code Example
/*
\file main.c
\brief ADC Sample Accumulator
(c) 2019 Microchip Technology Inc. and its subsidiaries.
Subject to your compliance with these terms, you may use Microchip software and any
derivatives exclusively with Microchip products. It is your responsibility to comply with third-party
license terms applicable to your use of third-party software (including open source software) that
may accompany Microchip software.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY
IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS
FOR A PARTICULAR PURPOSE.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP
HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO
THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP’S TOTAL LIABILITY ON ALL
CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT
OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS
SOFTWARE.
*/
#define ADC_SHIFT_DIV16 (4) /* where 4 is 2^4 = 16 */
#define F_CPU 4000000UL /* Main clock frequency */
#define START_TOKEN 0x03 /* Start Frame Token */
#define END_TOKEN 0xFC /* End Frame Token */
/* Compute the baud rate */
#define USART1_BAUD_RATE(BAUD_RATE) (((float)F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
#include <avr/io.h>
#include <stdbool.h>
#include <avr/cpufunc.h>
void CLKCTRL_init(void);
void PORT_init(void);
void VREF0_init(void);
void ADC0_init(void);
void USART1_init(void);
uint16_t ADC0_read(void);
void ADC0_start(void);
void USART1_Write(const uint8_t data);
/* This function initializes the CLKCTRL module */
void CLKCTRL_init(void)
{
/* FREQSEL 4M */
ccp_write_io((void*)&(CLKCTRL.OSCHFCTRLA), (CLKCTRL.OSCHFCTRLA | CLKCTRL_FREQSEL_4M_gc));
}
/* This function initializes the PORT module */
void PORT_init(void)
{
/* Configure PC0 as output for USART1 TX */
PORTC.DIRSET = PIN0_bm;
/* Disable interrupt and digital input buffer on PD3 */
PORTD.PIN3CTRL &= ~PORT_ISC_gm;
PORTD.PIN3CTRL |= PORT_ISC_INPUT_DISABLE_gc;
/* Disable pull-up resistor */
PORTD.PIN3CTRL &= ~PORT_PULLUPEN_bm;
}
/* This function initializes the VREF module */
void VREF0_init(void)
{
VREF.ADC0REF = VREF_REFSEL_2V048_gc; /* Internal 2.048V reference */
}
/* This function initializes the ADC module */
void ADC0_init(void)
{
ADC0.CTRLC = ADC_PRESC_DIV4_gc; /* CLK_PER divided by 4 */
ADC0.CTRLA = ADC_ENABLE_bm /* ADC Enable: enabled */
| ADC_RESSEL_12BIT_gc /* 12-bit mode */
| ADC_FREERUN_bm; /* Enable Free-Run mode */
ADC0.MUXPOS = ADC_MUXPOS_AIN3_gc; /* Select ADC channel AIN3 <-> PD3 */
ADC0.CTRLB = ADC_SAMPNUM_ACC64_gc; /* Set to accumulate 64 samples */
}
/* This function initializes the USART module */
void USART1_init(void)
{
/* Configure the baud rate: 115200 */
USART1.BAUD = (uint16_t)USART1_BAUD_RATE(115200);
USART1.CTRLB = USART_TXEN_bm; /* Enable TX */
USART1.CTRLC = USART_CHSIZE_8BIT_gc; /* Configure character size: 8 bit */
}
/* This function returns the ADC conversion result */
uint16_t ADC0_read(void)
{
/* Wait for ADC result to be ready */
while (!(ADC0.INTFLAGS & ADC_RESRDY_bm));
/* Clear the interrupt flag by reading the result */
return ADC0.RES;
}
/* This function starts the ADC conversions*/
void ADC0_start(void)
{
/* Start ADC conversion */
ADC0.COMMAND = ADC_STCONV_bm;
}
/* This function transmits one byte through USART */
void USART1_Write(const uint8_t data)
{
/* Check if USART buffer is ready to transmit data */
while (!(USART1.STATUS & USART_DREIF_bm));
/* Transmit data using TXDATAL register */
USART1.TXDATAL = data;
}
int main(void)
{
uint16_t adcVal;
/* Initialize all peripherals */
CLKCTRL_init();
PORT_init();
VREF0_init();
ADC0_init();
USART1_init();
/* Start the ADC conversions */
ADC0_start();
while (1)
{
/* Read the ADC result */
adcVal = ADC0_read();
/* divide by No of samples or 16, if No. samples > 16 */
adcVal = adcVal >> ADC_SHIFT_DIV16;
/* Transmit the ADC result to be plotted using Data Visualizer */
USART1_Write(START_TOKEN);
USART1_Write(adcVal & 0x00FF);
USART1_Write(adcVal >> 8);
USART1_Write(END_TOKEN);
}
}ADC Window Comparator Code Example
/*
\file main.c
\brief ADC Window Comparator
(c) 2019 Microchip Technology Inc. and its subsidiaries.
Subject to your compliance with these terms, you may use Microchip software and any
derivatives exclusively with Microchip products. It is your responsibility to comply with third-party
license terms applicable to your use of third-party software (including open source software) that
may accompany Microchip software.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY
IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS
FOR A PARTICULAR PURPOSE.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP
HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO
THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP’S TOTAL LIABILITY ON ALL
CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT
OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS
SOFTWARE.
*/
#define WINDOW_CMP_LOW_TH_EXAMPLE (0x100)
#define F_CPU 4000000UL /* Main clock frequency */
#define START_TOKEN 0x03 /* Start Frame Token */
#define END_TOKEN 0xFC /* End Frame Token */
/* Compute the baud rate */
#define USART1_BAUD_RATE(BAUD_RATE) (((float)F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
#include <avr/io.h>
#include <avr/cpufunc.h>
void CLKCTRL_init(void);
void PORT_init(void);
void VREF0_init(void);
void ADC0_init(void);
void USART1_init(void);
uint16_t ADC0_read(void);
uint8_t ADC0_resultReady(void);
void ADC0_start(void);
uint8_t ADC0_resultBelowTreshold(void);
void USART1_Write(const uint8_t data);
void LED0_init(void);
void LED0_on(void);
void LED0_off(void);
/* This function initializes the CLKCTRL module */
void CLKCTRL_init(void)
{
/* FREQSEL 4M */
ccp_write_io((void*)&(CLKCTRL.OSCHFCTRLA), (CLKCTRL.OSCHFCTRLA | CLKCTRL_FREQSEL_4M_gc));
}
/* This function initializes the PORT module */
void PORT_init(void)
{
/* Configure PC0 as output for USART1 TX */
PORTC.DIRSET = PIN0_bm;
/* Disable interrupt and digital input buffer on PD3 */
PORTD.PIN3CTRL &= ~PORT_ISC_gm;
PORTD.PIN3CTRL |= PORT_ISC_INPUT_DISABLE_gc;
/* Disable pull-up resistor */
PORTD.PIN3CTRL &= ~PORT_PULLUPEN_bm;
}
/* This function initializes the VREF module */
void VREF0_init(void)
{
VREF.ADC0REF = VREF_REFSEL_2V048_gc; /* Internal 2.048V reference */
}
/* This function initializes the ADC module */
void ADC0_init(void)
{
ADC0.CTRLC = ADC_PRESC_DIV4_gc; /* CLK_PER divided by 4 */
ADC0.CTRLA = ADC_ENABLE_bm /* ADC Enable: enabled */
| ADC_RESSEL_12BIT_gc /* 12-bit mode */
| ADC_FREERUN_bm; /* Free-run mode */
ADC0.MUXPOS = ADC_MUXPOS_AIN3_gc; /* Select ADC channel AIN3 <-> PD3 */
ADC0.WINLT = WINDOW_CMP_LOW_TH_EXAMPLE; /* Set conversion window comparator low threshold */
ADC0.CTRLE = ADC_WINCM_BELOW_gc; /* Set conversion window mode */
}
/* This function initializes the USART module */
void USART1_init(void)
{
/* Configure the baud rate: 115200 */
USART1.BAUD = (uint16_t)USART1_BAUD_RATE(115200);
USART1.CTRLB = USART_TXEN_bm; /* Enable TX */
USART1.CTRLC = USART_CHSIZE_8BIT_gc; /* Configure character size: 8 bit */
}
/* This function returns the ADC conversion result */
uint16_t ADC0_read(void)
{
/* Clear the interrupt flag by reading the result */
return ADC0.RES;
}
uint8_t ADC0_resultReady(void)
{
return (ADC0.INTFLAGS & ADC_RESRDY_bm);
}
/* This function starts the ADC conversions*/
void ADC0_start(void)
{
/* Start conversion */
ADC0.COMMAND = ADC_STCONV_bm;
}
uint8_t ADC0_resultBelowTreshold(void)
{
return (ADC0.INTFLAGS & ADC_WCMP_bm);
}
/* This function transmits one byte through USART */
void USART1_Write(const uint8_t data)
{
/* Check if USART buffer is ready to transmit data */
while (!(USART1.STATUS & USART_DREIF_bm));
/* Transmit data using TXDATAL register */
USART1.TXDATAL = data;
}
/* This function initializes the LED pin */
void LED0_init(void)
{
/* Configure the pin as output */
PORTC.DIRSET = PIN6_bm;
/* Configure the output high (LED == OFF) */
PORTC.OUTSET = PIN6_bm;
}
void LED0_on(void)
{
/* Configure the output low (LED == ON) */
PORTC.OUTCLR = PIN6_bm;
}
void LED0_off(void)
{
/* Configure the output high (LED == OFF) */
PORTC.OUTSET = PIN6_bm;
}
int main(void)
{
uint16_t adcVal;
/* Initialize all peripherals */
CLKCTRL_init();
PORT_init();
VREF0_init();
ADC0_init();
USART1_init();
LED0_init();
/* Start the ADC conversion */
ADC0_start();
while (1)
{
while (!ADC0_resultReady());
if (ADC0_resultBelowTreshold())
{
LED0_on();
}
else
{
LED0_off();
}
adcVal = ADC0_read();
/* Transmit the ADC result to be plotted using Data Visualizer */
USART1_Write(START_TOKEN);
USART1_Write(adcVal & 0x00FF);
USART1_Write(adcVal >> 8);
USART1_Write(END_TOKEN);
}
}
ADC Event Triggered Code Example
/*
\file main.c
\brief ADC Event Triggered by RTC Overflow
(c) 2019 Microchip Technology Inc. and its subsidiaries.
Subject to your compliance with these terms, you may use Microchip software and any
derivatives exclusively with Microchip products. It is your responsibility to comply with third-party
license terms applicable to your use of third-party software (including open source software) that
may accompany Microchip software.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY
IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS
FOR A PARTICULAR PURPOSE.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP
HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO
THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP’S TOTAL LIABILITY ON ALL
CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT
OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS
SOFTWARE.
*/
/* RTC Period */
#define RTC_PERIOD (511) /* RTC period */
#define F_CPU 4000000UL /* Main clock frequency */
#define START_TOKEN 0x03 /* Start Frame Token */
#define END_TOKEN 0xFC /* End Frame Token */
/* Compute the baud rate */
#define USART1_BAUD_RATE(BAUD_RATE) (((float)F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/cpufunc.h>
#include <stdbool.h>
volatile uint16_t adcVal;
volatile bool adcResultReady = 0;
void CLKCTRL_init(void);
void PORT_init(void);
void VREF0_init(void);
void ADC0_init(void);
void LED0_init(void);
void USART1_init();
void LED0_toggle(void);
void USART1_Write(const uint8_t data);
void RTC_init(void);
void EVSYS_init(void);
/* This function initializes the CLKCTRL module */
void CLKCTRL_init(void)
{
/* FREQSEL 4M */
ccp_write_io((void*)&(CLKCTRL.OSCHFCTRLA), (CLKCTRL.OSCHFCTRLA | CLKCTRL_FREQSEL_4M_gc));
}
/* This function initializes the PORT module */
void PORT_init(void)
{
/* Configure PC0 as output for USART1 TX */
PORTC.DIRSET = PIN0_bm;
/* Disable interrupt and digital input buffer on PD3 */
PORTD.PIN3CTRL &= ~PORT_ISC_gm;
PORTD.PIN3CTRL |= PORT_ISC_INPUT_DISABLE_gc;
/* Disable pull-up resistor */
PORTD.PIN3CTRL &= ~PORT_PULLUPEN_bm;
}
/* This function initializes the VREF module */
void VREF0_init(void)
{
VREF.ADC0REF = VREF_REFSEL_2V048_gc; /* Internal 2.048V reference */
}
/* This function initializes the ADC module */
void ADC0_init(void)
{
ADC0.CTRLC = ADC_PRESC_DIV4_gc; /* CLK_PER divided by 4 */
ADC0.CTRLA = ADC_ENABLE_bm /* ADC Enable: enabled */
| ADC_RESSEL_12BIT_gc; /* 12-bit mode */
ADC0.MUXPOS = ADC_MUXPOS_AIN3_gc; /* Select ADC channel AIN3 <-> PD3 */
ADC0.INTCTRL |= ADC_RESRDY_bm; /* Enable interrupts */
ADC0.EVCTRL |= ADC_STARTEI_bm; /* Enable event triggered conversion */
}
/* This function initializes the LED pin */
void LED0_init(void)
{
/* Configure the pin as output */
PORTC.DIRSET = PIN6_bm;
/* Configure the output high (LED == OFF) */
PORTC.OUTSET = PIN6_bm;
}
/* This function initializes the USART module */
void USART1_init()
{
/* Configure the baud rate: 115200 */
USART1.BAUD = (uint16_t)USART1_BAUD_RATE(115200);
USART1.CTRLB = USART_TXEN_bm; /* Enable TX */
USART1.CTRLC = USART_CHSIZE_8BIT_gc; /* Configure character size: 8 bit */
}
/* This function toggles the LED pin */
void LED0_toggle(void)
{
PORTC.OUTTGL = PIN6_bm;
}
/* This function transmits one byte through USART */
void USART1_Write(const uint8_t data)
{
/* Check if USART buffer is ready to transmit data */
while (!(USART1.STATUS & USART_DREIF_bm));
/* Transmit data using TXDATAL register */
USART1.TXDATAL = data;
}
ISR(ADC0_RESRDY_vect)
{
/* Clear the interrupt flag by reading the result */
adcVal = ADC0.RES;
/* Update the flag */
adcResultReady = 1;
}
/* This function initializes the RTC module */
void RTC_init(void)
{
/* Initialize RTC: */
while (RTC.STATUS > 0)
{
; /* Wait for all register to be synchronized */
}
RTC.CTRLA = RTC_PRESCALER_DIV32_gc /* 32 */
| RTC_RTCEN_bm /* Enable: enabled */
| RTC_RUNSTDBY_bm; /* Run In Standby: enabled */
RTC.PER = RTC_PERIOD; /* Set period */
RTC.CLKSEL = RTC_CLKSEL_OSC32K_gc; /* 32.768kHz Internal Crystal (OSC32K) */
}
/* This function initializes the EVSYS module */
void EVSYS_init(void)
{
/* Real Time Counter overflow */
EVSYS.CHANNEL0 = EVSYS_CHANNEL0_RTC_OVF_gc;
/* Connect user to event channel 0 */
EVSYS.USERADC0START = EVSYS_USER_CHANNEL0_gc;
}
int main(void)
{
uint16_t result;
/* Initialize all peripherals */
CLKCTRL_init();
PORT_init();
VREF0_init();
ADC0_init();
LED0_init();
USART1_init();
RTC_init();
EVSYS_init();
/* Enable Global Interrupts */
sei();
while (1)
{
if (adcResultReady == 1)
{
/* Store the result to avoid altering adcVal because of the interrupt. This operation must be atomic */
cli();
result = adcVal;
sei();
/* Update the flag value */
adcResultReady = 0;
/* Toggle the LED */
LED0_toggle();
/* Transmit the ADC result to be plotted using Data Visualizer */
USART1_Write(START_TOKEN);
USART1_Write(result & 0x00FF);
USART1_Write(result >> 8);
USART1_Write(END_TOKEN);
}
}
}ADC Temperature Measurement Code Example
/*
\file main.c
\brief ADC Temperature Measurement
(c) 2019 Microchip Technology Inc. and its subsidiaries.
Subject to your compliance with these terms, you may use Microchip software and any
derivatives exclusively with Microchip products. It is your responsibility to comply with third-party
license terms applicable to your use of third-party software (including open source software) that
may accompany Microchip software.
THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY
IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS
FOR A PARTICULAR PURPOSE.
IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP
HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO
THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP’S TOTAL LIABILITY ON ALL
CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT
OF FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS
SOFTWARE.
*/
#define F_CPU 4000000UL /* Main clock frequency */
#define START_TOKEN 0x03 /* Start Frame Token */
#define END_TOKEN 0xFC /* End Frame Token */
/* Compute the baud rate */
#define USART1_BAUD_RATE(BAUD_RATE) (((float)F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5)
#include <avr/io.h>
#include <stdbool.h>
#include <avr/cpufunc.h>
void CLKCTRL_init(void);
void VREF0_init(void);
void ADC0_init(void);
void USART1_init(void);
uint16_t ADC0_read(void);
int16_t temperatureConvert(uint16_t data);
void ADC0_start(void);
void USART1_Write(const uint8_t data);
/* This function initializes the CLKCTRL module */
void CLKCTRL_init(void)
{
/* FREQSEL 4M */
ccp_write_io((void*)&(CLKCTRL.OSCHFCTRLA), (CLKCTRL.OSCHFCTRLA | CLKCTRL_FREQSEL_4M_gc));
}
/* This function initializes the PORT module */
void PORT_init(void)
{
/* Configure PC0 as output for USART1 TX */
PORTC.DIRSET = PIN0_bm;
}
/* This function initializes the VREF module */
void VREF0_init(void)
{
VREF.ADC0REF = VREF_REFSEL_2V048_gc; /* Internal 2.048V reference */
}
/* This function initializes the ADC module */
void ADC0_init(void)
{
ADC0.CTRLC = ADC_PRESC_DIV4_gc; /* CLK_PER divided by 4 */
ADC0.CTRLA = ADC_ENABLE_bm /* ADC Enable: enabled */
| ADC_RESSEL_12BIT_gc /* 12-bit mode */
| ADC_FREERUN_bm; /* Free-run mode */
ADC0.MUXPOS = ADC_MUXPOS_TEMPSENSE_gc; /* Select ADC channel, Temp. */
}
/* This function initializes the USART module */
void USART1_init(void)
{
/* Configure the baud rate: 115200 */
USART1.BAUD = (uint16_t)USART1_BAUD_RATE(115200);
USART1.CTRLB = USART_TXEN_bm; /* Enable TX */
USART1.CTRLC = USART_CHSIZE_8BIT_gc; /* Configure character size: 8 bit */
}
/* This function returns the ADC conversion result */
uint16_t ADC0_read(void)
{
/* Wait for ADC result to be ready */
while (!(ADC0.INTFLAGS & ADC_RESRDY_bm));
/* Clear the interrupt flag by reading the result */
return ADC0.RES;
}
/* This function returns the temperature value in degrees C */
int16_t temperatureConvert(uint16_t data)
{
uint16_t sigrow_offset = SIGROW.TEMPSENSE1;
uint16_t sigrow_slope = SIGROW.TEMPSENSE0;
int32_t temp;
/* Clear the interrupt flag by reading the result (ADC0.RES) */
temp = sigrow_offset - data;
/* Result will overflow 16-bit variable */
temp *= sigrow_slope;
/* Add 4096/2 to get correct rounding on division below */
temp += 0x0800;
/* Round off to nearest degree in Kelvin, by dividing with 2^12 (4096) */
temp >>= 12;
/* Convert from Kelvin to Celsius (0 Kelvin - 273.15 = -273.1°C) */
return temp - 273;
}
/* This function starts the ADC conversions*/
void ADC0_start(void)
{
/* Start conversion */
ADC0.COMMAND = ADC_STCONV_bm;
}
/* This function transmits one byte through USART */
void USART1_Write(const uint8_t data)
{
/* Check if USART buffer is ready to transmit data */
while (!(USART1.STATUS & USART_DREIF_bm));
/* Transmit data using TXDATAL register */
USART1.TXDATAL = data;
}
int main(void)
{
int16_t temp_C;
uint16_t adcVal;
/* Initialize all peripherals */
CLKCTRL_init();
PORT_init();
VREF0_init();
ADC0_init();
USART1_init();
/* Start the ADC conversion */
ADC0_start();
while (1)
{
/* Read the conversion result */
adcVal = ADC0_read();
/* Convert the ADC result in degrees C */
temp_C = temperatureConvert(adcVal);
/* Transmit the ADC result to be plotted using Data Visualizer */
USART1_Write(START_TOKEN);
USART1_Write(temp_C & 0x00FF);
USART1_Write(temp_C >> 8);
USART1_Write(END_TOKEN);
}
}