Subversion Repositories Projects

/*****************************************************************************

 *   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);

}