| /* |
| * ---------------------------------------------------------------------------- |
| * "THE BEER-WARE LICENSE" (Revision 42): |
| * <joerg@FreeBSD.ORG> wrote this file. As long as you retain this notice you |
| * can do whatever you want with this stuff. If we meet some day, and you think |
| * this stuff is worth it, you can buy me a beer in return. Joerg Wunsch |
| * ---------------------------------------------------------------------------- |
| * |
| * More advanced AVR demonstration. Controls a LED attached to OCR1A. |
| * The brightness of the LED is controlled with the PWM. A number of |
| * methods are implemented to control that PWM. |
| * |
| * $Id: largedemo.c 1190 2007-01-19 22:17:10Z joerg_wunsch $ |
| */ |
| |
| #include <stdint.h> |
| #include <stdlib.h> |
| |
| #include <avr/eeprom.h> |
| #include <avr/interrupt.h> |
| #include <avr/io.h> |
| #include <avr/pgmspace.h> |
| #include <avr/sleep.h> |
| #include <avr/wdt.h> |
| |
| /* Part 1: Macro definitions */ |
| |
| #define CONTROL_PORT PORTD |
| #define CONTROL_DDR DDRD |
| |
| #if defined(__AVR_ATtiny2313__) |
| /* no PD7 and no ADC available on ATtiny2313 */ |
| # define TRIGGER_DOWN PD2 |
| # define TRIGGER_UP PD3 |
| # define FLASH PD4 |
| # define CLOCKOUT PD6 |
| #else |
| # define TRIGGER_DOWN PD2 |
| # define TRIGGER_UP PD3 |
| # define TRIGGER_ADC PD4 |
| # define CLOCKOUT PD6 |
| # define FLASH PD7 |
| #endif |
| |
| #if defined(__AVR_ATmega16__) |
| # define PWMDDR DDRD |
| # define PWMOUT PD5 |
| #elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega48__) ||\ |
| defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) |
| # define PWMDDR DDRB |
| # define PWMOUT PB1 |
| #elif defined(__AVR_ATtiny2313__) |
| # define PWMDDR DDRB |
| # define PWMOUT PB3 |
| # define HAVE_ADC 0 |
| # define USART_RXC_vect USART_RX_vect |
| # define MCUCSR MCUSR |
| #else |
| # error "Unsupported MCU type" |
| #endif |
| |
| #if defined(__AVR_ATmega48__) || defined(__AVR_ATmega88__) ||\ |
| defined(__AVR_ATmega168__) |
| /* map ATmega8/16 names to ATmegaX8 names */ |
| # define USART_RXC_vect USART_RX_vect |
| # define UDR UDR0 |
| # define UCSRA UCSR0A |
| # define UCSRB UCSR0B |
| # define FE FE0 |
| # define TXEN TXEN0 |
| # define RXEN RXEN0 |
| # define RXCIE RXCIE0 |
| # define UDRE UDRE0 |
| # define U2X U2X0 |
| # define UBRRL UBRR0L |
| |
| # define TIMSK TIMSK1 |
| # define MCUCSR MCUSR |
| #endif |
| |
| #if !defined(HAVE_ADC) |
| # define HAVE_ADC 1 |
| #endif |
| |
| #define F_CPU 1000000UL /* CPU clock in Hertz */ |
| |
| #define SOFTCLOCK_FREQ 100 /* internal software clock */ |
| |
| /* |
| * Timeout to wait after last PWM change till updating the EEPROM. |
| * Measured in internal clock ticks (approx. 100 Hz). |
| */ |
| #define EE_UPDATE_TIME (3 * SOFTCLOCK_FREQ) /* ca. 3 seconds */ |
| |
| /* |
| * Timer1 overflow interrupt will be called with F_CPU / 2048 |
| * frequency. This interrupt routine further divides that value, |
| * resulting in an internal update interval of approx. 10 ms. |
| * (The complicated looking scaling by 10 / addition of 9 is |
| * poor man's fixed-point rounding algorithm...) |
| */ |
| #define TMR1_SCALE ((F_CPU * 10) / (2048UL * SOFTCLOCK_FREQ) + 9) / 10 |
| |
| /* Part 2: Variable definitions */ |
| |
| /* |
| * Bits that are set inside interrupt routines, and watched outside in |
| * the program's main loop. |
| */ |
| volatile struct |
| { |
| uint8_t tmr_int: 1; |
| uint8_t adc_int: 1; |
| uint8_t rx_int: 1; |
| } |
| intflags; |
| |
| /* |
| * Last character read from the UART. |
| */ |
| volatile char rxbuff; |
| |
| /* |
| * Last value read from ADC. |
| */ |
| volatile uint16_t adcval; |
| |
| /* |
| * Where to store the PWM value in EEPROM. This is used in order |
| * to remember the value across a RESET or power cycle. |
| */ |
| uint16_t ee_pwm __attribute__((section(".eeprom"))) = 42; |
| |
| /* |
| * Current value of the PWM. |
| */ |
| int16_t pwm; |
| |
| /* |
| * EEPROM backup timer. Bumped by the PWM update routine. If it |
| * expires, the current PWM value will be written to EEPROM. |
| */ |
| int16_t pwm_backup_tmr; |
| |
| /* |
| * Mirror of the MCUCSR register, taken early during startup. |
| */ |
| uint8_t mcucsr __attribute__((section(".noinit"))); |
| |
| /* Part 3: Interrupt service routines */ |
| |
| ISR(TIMER1_OVF_vect) |
| { |
| static uint8_t scaler = TMR1_SCALE; |
| |
| if (--scaler == 0) |
| { |
| scaler = TMR1_SCALE; |
| intflags.tmr_int = 1; |
| } |
| } |
| |
| #if HAVE_ADC |
| /* |
| * ADC conversion complete. Fetch the 10-bit value, and feed the |
| * PWM with it. |
| */ |
| ISR(ADC_vect) |
| { |
| adcval = ADCW; |
| ADCSRA &= ~_BV(ADIE); /* disable ADC interrupt */ |
| intflags.adc_int = 1; |
| } |
| #endif /* HAVE_ADC */ |
| |
| /* |
| * UART receive interrupt. Fetch the character received and buffer |
| * it, unless there was a framing error. Note that the main loop |
| * checks the received character only once per 10 ms. |
| */ |
| ISR(USART_RXC_vect) |
| { |
| uint8_t c; |
| |
| c = UDR; |
| if (bit_is_clear(UCSRA, FE)) |
| { |
| rxbuff = c; |
| intflags.rx_int = 1; |
| } |
| } |
| |
| /* Part 4: Auxiliary functions */ |
| |
| /* |
| * Read out and reset MCUCSR early during startup. |
| */ |
| void handle_mcucsr(void) |
| __attribute__((section(".init3"))) |
| __attribute__((naked)); |
| void handle_mcucsr(void) |
| { |
| mcucsr = MCUCSR; |
| MCUCSR = 0; |
| } |
| |
| /* |
| * Do all the startup-time peripheral initializations. |
| */ |
| static void |
| ioinit(void) |
| { |
| uint16_t pwm_from_eeprom; |
| |
| /* |
| * Set up the 16-bit timer 1. |
| * |
| * Timer 1 will be set up as a 10-bit phase-correct PWM (WGM10 and |
| * WGM11 bits), with OC1A used as PWM output. OC1A will be set when |
| * up-counting, and cleared when down-counting (COM1A1|COM1A0), this |
| * matches the behaviour needed by the STK500's low-active LEDs. |
| * The timer will runn on full MCU clock (1 MHz, CS10 in TCCR1B). |
| */ |
| TCCR1A = _BV(WGM10) | _BV(WGM11) | _BV(COM1A1) | _BV(COM1A0); |
| TCCR1B = _BV(CS10); |
| |
| OCR1A = 0; /* set PWM value to 0 */ |
| |
| /* enable pull-ups for pushbuttons */ |
| #if HAVE_ADC |
| CONTROL_PORT = _BV(TRIGGER_DOWN) | _BV(TRIGGER_UP) | _BV(TRIGGER_ADC); |
| #else |
| CONTROL_PORT = _BV(TRIGGER_DOWN) | _BV(TRIGGER_UP); |
| #endif |
| |
| /* |
| * Enable Port D outputs: PD6 for the clock output, PD7 for the LED |
| * flasher. PD1 is UART TxD but not DDRD setting is provided for |
| * that, as enabling the UART transmitter will automatically turn |
| * this pin into an output. |
| */ |
| CONTROL_DDR = _BV(CLOCKOUT) | _BV(FLASH); |
| |
| /* |
| * As the location of OC1A differs between supported MCU types, we |
| * enable that output separately here. Note that the DDRx register |
| * *might* be the same as CONTROL_DDR above, so make sure to not |
| * clobber it. |
| */ |
| PWMDDR |= _BV(PWMOUT); |
| |
| UCSRA = _BV(U2X); /* improves baud rate error @ F_CPU = 1 MHz */ |
| UCSRB = _BV(TXEN)|_BV(RXEN)|_BV(RXCIE); /* tx/rx enable, rx complete intr */ |
| UBRRL = (F_CPU / (8 * 9600UL)) - 1; /* 9600 Bd */ |
| |
| #if HAVE_ADC |
| /* |
| * enable ADC, select ADC clock = F_CPU / 8 (i.e. 125 kHz) |
| */ |
| ADCSRA = _BV(ADEN) | _BV(ADPS1) | _BV(ADPS0); |
| #endif |
| |
| TIMSK = _BV(TOIE1); |
| sei(); /* enable interrupts */ |
| |
| /* |
| * Enable the watchdog with the largest prescaler. Will cause a |
| * watchdog reset after approximately 2 s @ Vcc = 5 V |
| */ |
| wdt_enable(WDTO_2S); |
| |
| /* |
| * Read the value from EEPROM. If it is not 0xffff (erased cells), |
| * use it as the starting value for the PWM. |
| */ |
| if ((pwm_from_eeprom = eeprom_read_word(&ee_pwm)) != 0xffff) |
| OCR1A = (pwm = pwm_from_eeprom); |
| } |
| |
| /* |
| * Some simple UART IO functions. |
| */ |
| |
| /* |
| * Send character c down the UART Tx, wait until tx holding register |
| * is empty. |
| */ |
| static void |
| putchr(char c) |
| { |
| |
| loop_until_bit_is_set(UCSRA, UDRE); |
| UDR = c; |
| } |
| |
| /* |
| * Send a C (NUL-terminated) string down the UART Tx. |
| */ |
| static void |
| printstr(const char *s) |
| { |
| |
| while (*s) |
| { |
| if (*s == '\n') |
| putchr('\r'); |
| putchr(*s++); |
| } |
| } |
| |
| /* |
| * Same as above, but the string is located in program memory, |
| * so "lpm" instructions are needed to fetch it. |
| */ |
| static void |
| printstr_p(const char *s) |
| { |
| char c; |
| |
| for (c = pgm_read_byte(s); c; ++s, c = pgm_read_byte(s)) |
| { |
| if (c == '\n') |
| putchr('\r'); |
| putchr(c); |
| } |
| } |
| |
| /* |
| * Update the PWM value. If it has changed, send the new value down |
| * the serial line. |
| */ |
| static void |
| set_pwm(int16_t new) |
| { |
| char s[8]; |
| |
| if (new < 0) |
| new = 0; |
| else if (new > 1000) |
| new = 1000; |
| |
| if (new != pwm) |
| { |
| OCR1A = (pwm = new); |
| |
| /* |
| * Calculate a "percentage". We just divide by 10, as we |
| * limited the max value of the PWM to 1000 above. |
| */ |
| new /= 10; |
| itoa(new, s, 10); |
| printstr(s); |
| putchr(' '); |
| |
| pwm_backup_tmr = EE_UPDATE_TIME; |
| } |
| } |
| |
| /* Part 5: main() */ |
| |
| int |
| main(void) |
| { |
| /* |
| * Our modus of operation. MODE_UPDOWN means we watch out for |
| * either PD2 or PD3 being low, and increase or decrease the |
| * PWM value accordingly. This is the default. |
| * MODE_ADC means the PWM value follows the value of ADC0 (PA0). |
| * This is enabled by applying low level to PC1. |
| * MODE_SERIAL means we get commands via the UART. This is |
| * enabled by sending a valid V.24 character at 9600 Bd to the |
| * UART. |
| */ |
| enum |
| { |
| MODE_UPDOWN, |
| MODE_ADC, |
| MODE_SERIAL |
| } __attribute__((packed)) mode = MODE_UPDOWN; |
| uint8_t flash = 0; |
| |
| ioinit(); |
| |
| if ((mcucsr & _BV(WDRF)) == _BV(WDRF)) |
| printstr_p(PSTR("\nOoops, the watchdog bit me!")); |
| |
| printstr_p(PSTR("\nHello, this is the avr-gcc/libc " |
| "demo running on an " |
| #if defined(__AVR_ATmega16__) |
| "ATmega16" |
| #elif defined(__AVR_ATmega8__) |
| "ATmega8" |
| #elif defined(__AVR_ATmega48__) |
| "ATmega48" |
| #elif defined(__AVR_ATmega88__) |
| "ATmega88" |
| #elif defined(__AVR_ATmega168__) |
| "ATmega168" |
| #elif defined(__AVR_ATtiny2313__) |
| "ATtiny2313" |
| #else |
| "unknown AVR" |
| #endif |
| "\n")); |
| |
| for (;;) |
| { |
| wdt_reset(); |
| |
| if (intflags.tmr_int) |
| { |
| /* |
| * Our periodic 10 ms interrupt happened. See what we can |
| * do about it. |
| */ |
| intflags.tmr_int = 0; |
| /* |
| * toggle PD6, just to show the internal clock; should |
| * yield ~ 48 Hz on PD6 |
| */ |
| CONTROL_PORT ^= _BV(CLOCKOUT); |
| /* |
| * flash LED on PD7, approximately once per second |
| */ |
| flash++; |
| if (flash == 5) |
| CONTROL_PORT |= _BV(FLASH); |
| else if (flash == 100) |
| { |
| flash = 0; |
| CONTROL_PORT &= ~_BV(FLASH); |
| } |
| |
| switch (mode) |
| { |
| case MODE_SERIAL: |
| /* |
| * In serial mode, there's nothing to do anymore here. |
| */ |
| break; |
| |
| case MODE_UPDOWN: |
| /* |
| * Query the pushbuttons. |
| * |
| * NB: watch out to use PINx for reading, as opposed |
| * to using PORTx which would be the mirror of the |
| * _output_ latch register (resp. pullup configuration |
| * bit for input pins)! |
| */ |
| if (bit_is_clear(PIND, TRIGGER_DOWN)) |
| set_pwm(pwm - 10); |
| else if (bit_is_clear(PIND, TRIGGER_UP)) |
| set_pwm(pwm + 10); |
| #if HAVE_ADC |
| else if (bit_is_clear(PIND, TRIGGER_ADC)) |
| mode = MODE_ADC; |
| #endif |
| break; |
| |
| case MODE_ADC: |
| #if HAVE_ADC |
| if (bit_is_set(PIND, TRIGGER_ADC)) |
| mode = MODE_UPDOWN; |
| else |
| { |
| /* |
| * Start one conversion. |
| */ |
| ADCSRA |= _BV(ADIE); |
| ADCSRA |= _BV(ADSC); |
| } |
| #endif /* HAVE_ADC */ |
| break; |
| } |
| |
| if (pwm_backup_tmr && --pwm_backup_tmr == 0) |
| { |
| /* |
| * The EEPROM backup timer expired. Save the current |
| * PWM value in EEPROM. Note that this function might |
| * block for a few milliseconds (after writing the |
| * first byte). |
| */ |
| eeprom_write_word(&ee_pwm, pwm); |
| printstr_p(PSTR("[EEPROM updated] ")); |
| } |
| } |
| |
| #if HAVE_ADC |
| if (intflags.adc_int) |
| { |
| intflags.adc_int = 0; |
| set_pwm(adcval); |
| } |
| #endif /* HAVE_ADC */ |
| |
| if (intflags.rx_int) |
| { |
| intflags.rx_int = 0; |
| |
| if (rxbuff == 'q') |
| { |
| printstr_p(PSTR("\nThank you for using serial mode." |
| " Good-bye!\n")); |
| mode = MODE_UPDOWN; |
| } |
| else |
| { |
| if (mode != MODE_SERIAL) |
| { |
| printstr_p(PSTR("\nWelcome at serial control, " |
| "type +/- to adjust, or 0/1 to turn on/off\n" |
| "the LED, q to quit serial mode, " |
| "r to demonstrate a watchdog reset\n")); |
| mode = MODE_SERIAL; |
| } |
| switch (rxbuff) |
| { |
| case '+': |
| set_pwm(pwm + 10); |
| break; |
| |
| case '-': |
| set_pwm(pwm - 10); |
| break; |
| |
| case '0': |
| set_pwm(0); |
| break; |
| |
| case '1': |
| set_pwm(1000); |
| break; |
| |
| case 'r': |
| printstr_p(PSTR("\nzzzz... zzz...")); |
| for (;;) |
| ; |
| } |
| } |
| } |
| sleep_mode(); |
| } |
| } |
