0,0 → 1,289 |
/***************************************************************************** |
* Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net * |
* based on the key handling by Peter Dannegger * |
* see www.mikrocontroller.net * |
* Copyright (C) 2011 Christian Brandtner brandtner@brandtner.net * |
* * |
* This program is free software; you can redistribute it and/or modify * |
* it under the terms of the GNU General Public License as published by * |
* the Free Software Foundation; either version 2 of the License. * |
* * |
* This program is distributed in the hope that it will be useful, * |
* but WITHOUT ANY WARRANTY; without even the implied warranty of * |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
* GNU General Public License for more details. * |
* * |
* You should have received a copy of the GNU General Public License * |
* along with this program; if not, write to the * |
* Free Software Foundation, Inc., * |
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * |
* * |
* 22.03.2011 Zeitgesteuerte Displaybeleuchtung C.B. * |
* * |
*****************************************************************************/ |
|
#include <avr/io.h> |
#include <avr/interrupt.h> |
#include <avr/pgmspace.h> |
#include <string.h> |
|
|
#include "main.h" |
#include "timer.h" |
#include "eeprom.h" |
#include "lcd.h" |
|
volatile uint16_t timer; |
volatile uint16_t abo_timer; |
volatile uint8_t pwm1 = 255; |
|
#define FRAME_LENGTH 20 |
uint16_t icrval = (F_CPU / 64) * FRAME_LENGTH / 1000 ; |
uint16_t minocr_a = (F_CPU / 64) * 1 / 1000;// 312 |
uint16_t maxocr_a = (F_CPU / 64) * 2 / 1000;// 624 |
uint16_t minocr_b = (F_CPU / 64) * 1 / 1000;// 312 |
uint16_t maxocr_b = (F_CPU / 64) * 2 / 1000;// 624 |
|
|
uint8_t key_state = 0; // debounced and inverted key state: |
// bit = 1: key pressed |
uint8_t key_press = 0; // key press detect |
uint8_t key_rpt; // key long press and repeat |
uint16_t DisplayTime = 0; // Leuchtdauer |
volatile uint8_t Display_on;// Flag Display on/off |
|
|
|
//***************************************************************************** |
// |
|
|
#if defined (__AVR_ATmega32__) |
ISR(TIMER0_COMP_vect) // Timer-Interrupt (100 Hz) |
#else |
ISR(TIMER0_COMPA_vect) // Timer-Interrupt (100 Hz) |
#endif |
{ |
static uint8_t ct0 = 0; |
static uint8_t ct1 = 0; |
static uint8_t rpt = 0; |
uint8_t i; |
|
// Key handling by Peter Dannegger |
// see www.mikrocontroller.net |
i = key_state ^ ~KEY_PIN; // key changed ? |
ct0 = ~(ct0 & i); // reset or count ct0 |
ct1 = ct0 ^ (ct1 & i); // reset or count ct1 |
i &= (ct0 & ct1); // count until roll over ? |
key_state ^= i; // then toggle debounced state |
key_press |= (key_state & i); // 0->1: key press detect |
|
if (i!=0) |
{ // Displaylicht einschalten, und bzw. Timeoutzählerreset wenn Taste gedrückt wurde |
if (Display_on ==0) |
{ // einschalten |
// PORTD &= ~(1<<PORTD7); |
#ifdef HWVERSION1_2 |
PORTC &= ~(1<<PORTC0); |
PORTC &= ~(1<<PORTC1); |
#endif |
#ifdef HWVERSION1_3 |
PORTD &= ~(1<<PORTD6); |
PORTC &= ~(1<<PORTC2); |
#endif |
#ifdef HWVERSION3_1 |
set_D_LIGHT(); |
#endif |
|
} // if Display_on ==0 |
Display_on =1; // Flag Display on |
DisplayTime = 0; // Timer Reset |
|
} |
|
|
if ((key_state & REPEAT_MASK) == 0) // check repeat function |
{ |
rpt = REPEAT_START; // start delay |
} |
if (--rpt == 0) |
{ |
rpt = REPEAT_NEXT; // repeat delay |
key_rpt |= (key_state & REPEAT_MASK); |
} |
|
|
if (timer > 0) |
{ |
timer --; |
} |
|
if (abo_timer > 0) |
{ |
abo_timer --; |
} |
|
if (DisplayTimeout > 0) |
|
{ |
if (Display_on==1) |
{ |
DisplayTime++; |
if ((DisplayTime/100) == DisplayTimeout) //ISR läuft mit 100Hz |
|
{ //Displaylicht ausschalten |
// PORTD |= (1<<PORTD7); |
#ifdef HWVERSION1_2 |
PORTC |= (1<<PORTC0); |
PORTC |= (1<<PORTC1); |
#endif |
#ifdef HWVERSION1_3 |
PORTD |= (1<<PORTD6); |
PORTC |= (1<<PORTC2); |
#endif |
#ifdef HWVERSION3_1 |
clr_D_LIGHT(); |
#endif |
Display_on = 0; // Flag Display off |
} |
} |
|
} |
|
|
} |
|
|
void TIMER1_Init (void) |
{ |
|
DDRD |= (1<<PORTD4)|(1<<PORTD5); |
TCCR1A |= (1<<COM1B1) |(1<<COM1A1) | (1<<WGM11); |
TCCR1B |= (1<<CS11)|(1<<CS10)| (1<<WGM12)| (1<<WGM13); |
|
ICR1 = icrval; |
OCR1A = minocr_a + ((maxocr_a-minocr_a)/2); |
OCR1B = minocr_b + ((maxocr_b-minocr_b)/2); |
|
// OCR1A = minocr_a; |
// OCR1B = maxocr_b; |
|
} |
|
void set_pwm_a(uint16_t value) |
{ |
uint16_t setv = ((value * 9) / 10 ) + minocr_a; |
|
if((setv > 311)&&(setv < 637)) |
{ |
OCR1A = setv; |
} |
} |
void set_pwm_b(uint8_t value) |
{ |
uint16_t setv = ((value * 4 * 5 ) / 6 ) + minocr_b; |
if((setv > 200)&&(setv < 750)) |
{ |
OCR1B = setv; |
} |
} |
|
|
|
//***************************************************************************** |
// |
void TIMER0_Init (void) |
{ |
timer = 0; |
|
#if defined (__AVR_ATmega32__) |
TCCR0 = (1 << CS02) | (1 << CS00) | (1 << WGM01); // Prescaler 1024 |
OCR0 = (F_CPU / (100L * 1024L)) ; |
|
TIMSK |= (1 << OCIE0); // enable interrupt for OCR |
#else |
TCCR0A = (1 << WGM01); |
TCCR0B = (1 << CS02) | (1 << CS00); |
OCR0A = (F_CPU / (100L * 1024L)) ; |
|
TIMSK0 |= (1 << OCIE0A); // enable interrupt for OCR |
#endif |
} |
|
|
//***************************************************************************** |
// |
uint8_t get_key_press (uint8_t key_mask) |
{ |
uint8_t sreg = SREG; |
|
// disable all interrupts |
cli(); |
|
key_mask &= key_press; // read key(s) |
key_press ^= key_mask; // clear key(s) |
|
SREG = sreg; // restore status register |
|
return key_mask; |
} |
|
|
//***************************************************************************** |
// |
uint8_t get_key_rpt (uint8_t key_mask) |
{ |
uint8_t sreg = SREG; |
|
// disable all interrupts |
cli(); |
|
key_mask &= key_rpt; // read key(s) |
key_rpt ^= key_mask; // clear key(s) |
|
SREG = sreg; // restore status register |
|
return key_mask; |
} |
|
|
//***************************************************************************** |
// |
uint8_t get_key_short (uint8_t key_mask) |
{ |
uint8_t ret; |
uint8_t sreg = SREG; |
|
// disable all interrupts |
cli(); |
|
ret = get_key_press (~key_state & key_mask); |
|
SREG = sreg; // restore status register |
|
return ret; |
} |
|
|
//***************************************************************************** |
// |
uint8_t get_key_long (uint8_t key_mask) |
{ |
return get_key_press (get_key_rpt (key_mask)); |
} |
|
|
//***************************************************************************** |
// |
uint8_t get_key_long2 (uint8_t key_mask) |
{ |
return get_key_press (get_key_rpt (key_press^key_mask)); |
} |
|
|
//***************************************************************************** |
// |
uint8_t get_key_long_rpt (uint8_t key_mask) |
{ |
return get_key_rpt (~key_press^key_mask); |
} |