mega_1284p_xplained_example.c

Go to the documentation of this file.

#include "avr_compiler.h"
#include "usart.h"
#include "init.h"
#include "touch_api.h"

#define ADC_NUM_OVERSAMPLING            16

#define ASCII_BACKSPACE                 8
#define ASCII_CR                        13
#define ASCII_SPACE                     32
#define MAX_CMD_BUFFER_LEN              32

#define CMD_PROMPT                      "\r\nMEGA-1284P Xplained>"

#define FLASHCOUNT                      100

#define IDLE                            0x01  //!< Idle SMCR setting
#define POWER_DOWN                      0x05  //!< Power-Down SMCR setting
#define POWER_SAVE                      0x07  //!< Power-Save SMCR setting
#define STANDBY                         0x0D  //!< Standby SMCR setting
#define EXTENDED_STANDBY                0x0F  //!< Extended standby SMCR setting

#define NUM_COMMANDS                    12

// Forward declarations of command functions
static void print_help (void);
static void flash_leds_cmd (void);
static void read_ntc (void);
static void read_light_sensor (void);
static void light_sensor_demo (void);
static void crystal_start_cmd (void);
static void crystal_stop_cmd (void);
static void idle_mode_cmd (void);
static void power_save_cmd (void);
static void power_down_cmd (void);
static void standby_cmd (void);
static void ext_standby_cmd (void);

struct {
    char cmd[20];        // Command string
    char help[70];       // Help text
    void (* func)(void); // Function to call when command is entered
} commands[NUM_COMMANDS] = {
    { "help",                "Print this help",                                       print_help },
    { "flash leds",          "Toggles leds connected to PORTB0:3",                    flash_leds_cmd },
    { "read ntc",            "Returns NTC ADC code (ADC7)",                           read_ntc },
    { "read light sensor",   "Returns Light Sensor ADC code (ADC6)",                  read_light_sensor },
    { "light sensor demo",   "LED3:0 are dimmed according to the light sensor value", light_sensor_demo },
    { "start 32khz crystal", "Starts the 32.768kHz crystal",                          crystal_start_cmd },
    { "stop 32khz crystal",  "Stops the 32.768kHz crystal",                           crystal_stop_cmd },
    { "idle",                "MCU in idle mode. Wake up by pressing SW0",             idle_mode_cmd },
    { "power-save",          "MCU in Power-Save mode. Wake up by pressing SW0",       power_save_cmd },
    { "power-down",          "MCU in Power-Down mode. Wake up by pressing SW0",       power_down_cmd },
    { "standby",             "MCU in Standby mode. Wake up by pressing SW0",          standby_cmd },
    { "extended standby",    "MCU in Extended Standby mode. Wake up by pressing SW0", ext_standby_cmd },
};

static volatile bool light_sensor_demo_mode = false;

#define QT_KEY_DETECT() \
    (qt_measure_data.qt_touch_status.sensor_states[0] & 0x01)

#define NUMBER_OF_PORTS 1

uint16_t qt_measurement_period_msec = 25;

static volatile bool time_to_measure_touch = false;

static volatile uint16_t current_time_ms_touch = 0;

#if defined( __GNUC__ )

FILE usart1_str = FDEV_SETUP_STREAM((int(*)(char, FILE *))usart1_putchar, NULL, _FDEV_SETUP_WRITE);
#endif

enum adc_sources {
    FILTER_OUTPUT = 0x05, 
    LIGHT_SENSOR = 0x06,  
    NTC = 0x07           
};

ISR(PCINT1_vect)
{
    return;
}

ISR(TIMER1_OVF_vect)
{
    // Turn off LEDs
    PORTB |= (1 << PORTB3) | (1 << PORTB2) | (1 << PORTB1) | (1 << PORTB0);
    // PORTB0 set to input to enable sensing on SW0
    DDRB &= ~(1 << DDB0);

    asm("nop");
    // Stop demo mode if SW0 is pushed
    if (!(PINB & (1 << PINB0))) {
        light_sensor_demo_mode = false;
    }
}

ISR(TIMER1_COMPB_vect)
{
    // Turn on LEDs (make sure PORTB0 is set as output)
    DDRB |= (1 << DDB0);
    PORTB &= ~((1 << PORTB3) | (1 << PORTB2) | (1 << PORTB1) | (1 << PORTB0));
}

ISR(TIMER1_COMPA_vect)
{
    // Set flag, it's time to measure touch
    time_to_measure_touch = true;

    // Update the current time
    current_time_ms_touch += qt_measurement_period_msec;
}

ISR(TIMER2_OVF_vect)
{
    // Toggle LEDs
    PINB |= (1 << PINB3) | (1 << PINB2) | (1 << PINB1) | (1 << PINB0);
}

static void flash_leds(uint8_t flashcount)
{
    uint8_t i;

    for (i = 0; i < flashcount; i++) {
        // toggle LEDs
        PINB |= (1 << PINB3) | (1 << PINB2) | (1 << PINB1) | (1 << PINB0);
        // wait a while
        delay_us(20000);
    }
    // make sure LEDs are off before we leave
    PORTB |= (1 << PORTB3) | (1 << PORTB2) | (1 << PORTB1) | (1 << PORTB0);
}

static uint16_t read_adc(enum adc_sources source)
{
    uint16_t adc_data = 0;

    // Clear old source and setup new source to sample from
    ADMUX &= 0xE0;
    ADMUX |= source;

    for (int i = 0 ; i < ADC_NUM_OVERSAMPLING ; i++) {
        //Start single conversion
        ADCSRA |= (1<<ADSC);

        //Wait for conversion complete
        while(!(ADCSRA & (1<<ADIF)));

        //Read ADC conversion result
        adc_data += ADC;
    }

    adc_data = adc_data/ADC_NUM_OVERSAMPLING;

    return adc_data;
}

static void read_ntc(void)
{
    uint16_t ntc_data;

    // Read NTC sensor
    ntc_data = read_adc(NTC);

    // Send NTC_data to PC
    printf("NTC ADC value: %4d\r\n", ntc_data);
}

static void read_light_sensor(void)
{
    uint16_t light_sensor_data;
    // Read LIGHT SENSOR
    light_sensor_data = read_adc(LIGHT_SENSOR);

    // Send LIGHT_SENSOR_data to PC
    printf("LIGHT SENSOR ADC value: %4d\r\n", light_sensor_data);
}

static void start32crystal(void)
{
    // Make sure clock to timer2 is enabled
    PRR0 &= ~(1 << PRTIM2);

    // Start Timer 2, prescale 8
    TCCR2B = (0 << WGM22) | (0 << CS22) | (1 << CS21) | (0 << CS20);

    // Enable clocking of timer2 using 32.768kHz crystal
    ASSR = (1 << AS2);
}

static void stop32crystal(void)
{
    // Disable clocking of timer2 using 32.768kHz crystal
    ASSR = (0 << AS2);

    // Stop Timer 2
    TCCR2B = (0 << WGM22) | (0 << CS22) | (0 << CS21) | (0 << CS20);

    // Turn off clock to timer2 as it's not in use anymore
    PRR0 |= (1 << PRTIM2);
}

static void enter_sleep(uint8_t sleepmode)
{
    uint8_t temp_timsk1;
    uint8_t temp_timsk2;
    uint8_t temp_portb;
    uint8_t temp_ddrb;
    uint8_t temp_prr0;

    // Push temp values and disable interrupts
    temp_timsk1 = TIMSK1;
    temp_timsk2 = TIMSK2;
    temp_portb = PORTB;
    temp_ddrb = DDRB;
    TIMSK1 = 0x00;
    TIMSK2 = 0x00;
    temp_prr0 = PRR0;

    // Enable PORTB0 as input with pull-up enabled
    PORTB |= (1 << PORTB0);
    DDRB &= ~(1 << DDB0);

    // Clear Pin Change Interrupt flag 1
    PCIFR = (1 << PCIF1);

    // Enable pinchange interrupt on SW0 (PCINT8/PB0)
    PCICR = (1 << PCIE1);
    PCMSK1 = (1 << PCINT10) | (1 << PCINT9) |(1 << PCINT8);

    // Configure sleep mode
    SMCR = sleepmode;

    // Enable power saving features before going to sleep
    power_reduction_enable();

    // Go to sleep
    sleep_enter();

    // Clear SMCR to avoid entering sleep unintended
    SMCR = 0x00;

    // Pull temp values
    PRR0 = temp_prr0;

    // Make sure interrupts flags are reset
    TIFR1 =(1 << OCF1B) | (1 << OCF1A) | (1 << TOV1);
    TIFR2 = (1 << TOV2);

    // Pull temp values
    TIMSK1 = temp_timsk1;
    TIMSK2 = temp_timsk2;
    PORTB = temp_portb;
    DDRB = temp_ddrb;
}

static void flash_leds_cmd (void)
{
    flash_leds(FLASHCOUNT);
}

static void light_sensor_demo (void)
{
    timer1_lightdemo_init();
    adc_init();
    light_sensor_demo_mode = true;
    printf("Light sensor demo mode enabled.\r\n");
    printf("Push SW0 to exit light sensor demo.\r\n");

    /*
    * Run light sensor demo as long as light_sensor_demo_mode is true.
    * The light sensor demo mode is disabled in the timer1 overflow ISR.
    */
    while(light_sensor_demo_mode) {
        // Update compare B value to adjust PWM according to light sensor value
        OCR1B = read_adc(LIGHT_SENSOR);
    }
    stop_timer1_lightdemo();
    printf("Light sensor demo mode stopped.\r\n");
}

static void crystal_start_cmd (void)
{
    start32crystal();
    // Enable timer2 overflow interrupt
    TIMSK2 |= (1<<TOIE2);
    printf("32.768kHz crystal started.\r\n");
}

static void crystal_stop_cmd (void)
{
    stop32crystal();
    // Disable timer2 overflow interrupt
    TIMSK2 &= ~(1<<TOIE2);
    // make sure LEDs are off before we leave
    PORTB |= (1 << PORTB3) | (1 << PORTB2) | (1 << PORTB1) | (1 << PORTB0);
    printf("32.768kHz crystal stopped.\r\n");
}

static void idle_mode_cmd (void)
{
    printf("Entering idle mode. Push SW0 to wake-up.\r\n");
    while (!(UCSR1A & (1 << TXC1)));
    enter_sleep(IDLE);
    printf("Woke up from idle mode.\r\n");
}

static void power_save_cmd (void)
{
    printf("Entering power-save mode. Push SW0 to wake-up.\r\n");
    while (!(UCSR1A & (1 << TXC1)));
    enter_sleep(POWER_SAVE);
    printf("Woke up from power-save mode.\r\n");
}

static void power_down_cmd (void)
{
    printf("Entering power-down mode. Push SW0 to wake-up.\r\n");
    while (!(UCSR1A & (1 << TXC1)));
    enter_sleep(POWER_DOWN);
    printf("Woke up from power-down mode.\r\n");
}

static void standby_cmd (void)
{
    printf("Entering standby mode. Push SW0 to wake-up.\r\n");
    while (!(UCSR1A & (1 << TXC1)));
    enter_sleep(STANDBY);
    printf("Woke up from standby mode.\r\n");
}

static void ext_standby_cmd (void)
{
    printf("Entering extended standby mode.\r\n");
    printf("Push SW0 to wake-up.\r\n");
    while (!(UCSR1A & (1 << TXC1)));
    enter_sleep(EXTENDED_STANDBY);
    printf("Woke up from extended standby mode.\r\n");
}

static void print_help()
{
    uint8_t cnt;

    printf("\r\n------------------------------------------------------------------------------\r\n");
    printf("#  COMMAND:             DESCRIPTION:\r\n");
    printf("------------------------------------------------------------------------------\r\n");
    for (cnt = 0; cnt < NUM_COMMANDS; cnt++) {
        printf("%-2d %-20s %s\r\n", cnt+1, commands[cnt].cmd, commands[cnt].help);
    }
    printf("------------------------------------------------------------------------------\r\n");
    printf("To perform a command, enter command number or command string\r\n");
}


static void process_command(const char *command)
{
    uint8_t cnt;
    uint8_t num_cmd = atoi(command);

    for (cnt = 0; cnt < NUM_COMMANDS; cnt++) {
        if ((strcmp(command, commands[cnt].cmd) == 0) || (num_cmd == cnt+1)) {
            commands[cnt].func();
            return;
        }
    }
    printf("Invalid command. Type 'help' for a list of available commands.\r\n");
}

static void execute_demo_mode(void)
{
    // Status flags to indicate the re-burst for touch library
    uint16_t status_flag = 0;
    uint16_t burst_flag = 0;

    io_init_demo_mode();
    touch_init();
    sei();

    while (1) {
        if (time_to_measure_touch) {

            time_to_measure_touch = false;
            MCUCR |= (1 << PUD);

            do {
                // One time measure touch sensors
                status_flag = qt_measure_sensors(current_time_ms_touch);
                burst_flag = status_flag & QTLIB_BURST_AGAIN;
                if (QT_KEY_DETECT()) {
                    PORTB &= ~(1 << PORTB3);
                }
                else {
                    PORTB |= (1 << PORTB3);
                }

            } while (burst_flag);
        MCUCR &= ~(1 << PUD);
        }

        if (!(PINB & (1 << PINB0))) {
            // Turn LED0 on to indicate active mode
            DDRB |= (1 << DDB3) | (1 << DDB0);
            DDRB &= ~((1 << DDB2) | (1 << DDB1));
            PORTB &= ~(1 << PORTB0);
            PORTB |= (1 << PORTB2) | (1 << PORTB1);
        }

        if (!(PINB & (1 << PINB1))){
            // Turn LED2 on to indicate power-save mode
            DDRB |= (1 << DDB3) | (1 << DDB1);
            DDRB &= ~((1 << DDB2) | (1 << DDB0));
            PORTB &= ~(1 << PORTB1);
            PORTB |= (1 << PORTB2) | (1 << PORTB0);

            /*
             * Start asynchronous clocking of Timer/Counter 2 using
             * 32.768kHz crystal as clock source.
             */
            start32crystal();
            enter_sleep(POWER_SAVE);
            stop32crystal();
        }

        if (!(PINB & (1 << PINB2))) {
            // Turn LED3 on to indicate power-down mode
            DDRB |= (1 << DDB3) | (1 << DDB2);
            DDRB &= ~(1 << DDB1) & ~(1 << DDB0);
            PORTB &= ~(1 << PORTB2);
            PORTB |= (1 << PORTB1) | (1 << PORTB0);
            enter_sleep(POWER_DOWN);
        }

        if (!(PINB & (1 << PINB6))) {
            // Disable pinchange interrupts (SW0:2)
            PCICR = (0 << PCIE1);

            adc_init();
            timer1_lightdemo_init();

            // Enable output for LED control of LED0:3
            DDRB |= (1 << DDB3) | (1 << DDB2) | (1 << DDB1) | (1 << DDB0);

            // Run light sensor demo as long as PORTB6 is pulled low
            while (!(PINB & (1 << PINB6))) {

                /*
                 * Update compare B value to adjust PWM according
                 * to light sensor value
                 */
                OCR1B = read_adc(LIGHT_SENSOR);
            }

            stop_timer1_lightdemo();

            // Set back to input for demo mode
            DDRB &= ~(1 << DDB2) & ~(1 << DDB1) & ~(1 << DDB0);

            touch_init();

            // Clear Pin Change Interrupt flag 1
            PCIFR = (1 << PCIF1);
            // Enable pinchange interrupts (SW0:2)
            PCICR = (1 << PCIE1);
        }
    }
}

static void execute_terminal_mode(void)
{
    // Variable used for USART communication
    uint8_t data = 0;
    // Command buffer pointer used for USART communication
    uint8_t cmd_buf_ptr = 0;
    // Command buffer used for USART communication
    char cmd_buffer[MAX_CMD_BUFFER_LEN];

    // misc initialization
    io_init_terminal_mode();
    usart1_init();
    adc_init();
    // Enable interrupts
    sei();

    flash_leds(20);
    print_help();
    printf(CMD_PROMPT);

    while (1) {

        // Read and handle incoming data on usart1
        data = usart1_getchar();
        switch (data)   {

        case ASCII_CR:
            if (cmd_buf_ptr > 0) {
                usart1_putchar('\n');
                cmd_buffer[cmd_buf_ptr] = '\0';
                process_command(cmd_buffer);
                cmd_buf_ptr = 0;
            }
            printf(CMD_PROMPT);
            break;

        case ASCII_BACKSPACE:
            if (cmd_buf_ptr == 0) {
                break;
            }
            printf("\b \b");
            cmd_buf_ptr--;
            break;

        default:
            if (cmd_buf_ptr >= MAX_CMD_BUFFER_LEN || data < ASCII_SPACE ) {
                // Break if command string is too long/ignore non-printable characters
                break;
            }
            cmd_buffer[cmd_buf_ptr++] = data;
            usart1_putchar(data);
            break;
        }
    }
}

int main(void)
{
#if defined( __GNUC__ )
    /* Setup stdout to point to the correct usart (USART1). This is needed to
     * use the fdev_setup_stream() macro in GCC.
     */
    stdout = &usart1_str;
#endif

    // Make sure to use lowest possible power consumption
    power_reduction_enable();

    // Enter terminal mode if SW1 is pressed
    if (!(PINB & (1 << PORTB1))) {
        execute_terminal_mode();
    }   else {
        execute_demo_mode();
    }
}