Blame |
Last modification |
View Log
| RSS feed
/*****************************************************************************
* 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);
PORTD &= ~(1<<PORTD7);
#endif
#ifdef HWVERSION1_3
PORTD &= ~(1<<PORTD6);
PORTC &= ~(1<<PORTC2);
PORTD &= ~(1<<PORTD7);
#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);
PORTD |= (1<<PORTD7);
#endif
#ifdef HWVERSION1_3
PORTD |= (1<<PORTD6);
PORTD |= (1<<PORTD7);
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);
}