Quellcode

//Steuerprogramm Für TRENT 700 Modell
//(c) 2009 Stefan Weßels, all rights reserved
//$VERSION 0
//$MINOR 3

//defines
#ifndef F_CPU
    #define F_CPU 16000000UL
#endif
#define MAN 0
#define AUTO 1
#define OPEN 0
#define CLOSE 1

//end defines

//includes
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include "keys.h"
#include "servo.h"
#include <util/delay.h>
//end includes

//function prototypes
void init(void);
void manual_cont(void);
void auto_cont(void);
//end function prototypes

//variables
struct {
    unsigned s0mode:1;            //Laufrichtung, siehe servo.h
    unsigned s1mode:1;            //Laufrichtung, siehe servo.h
    unsigned door_direction:1;    //Richtung der Doors
    unsigned mode:1;            //Betriebsmodus
    unsigned pgm:1;                //Programmiermodus 0 -> nein, 1 -> ja
    unsigned valid_data:1;        //Sinnvolle daten EEPROM? 0 -> nein, 1 -> ja
} flags;

servo servo0;
servo servo1;
//end variables

int main(void) {

init();

PORTC |= (1<<PC2);    //Power LED an

while(1) {
    //Modus auswählen
    if(get_key_press(1<<KEY2)) {
        if(flags.mode == 0)
            flags.mode = 1;
        else if(flags.mode == 1)
            flags.mode =0;
    }
    
    //Manueller Modus
    if(flags.mode == MAN) {
        TIMSK1 &= ~(1<<TOIE1);    //Timer 1 Overflow Interrupt abschalten
        PORTC |= (1<<PC0);        //MAN LED an        
        PORTC &= ~(1<<PC1);        //AUTO LED aus
        manual_cont();
    }
    
    //Automatischer Modus
    else if(flags.mode == AUTO) {
        if(servo0.pos >= servo0.max || servo0.pos <= servo0.min || servo1.pos >= servo1.max || servo1.pos <= servo1.min) {
            if(flags.door_direction == OPEN) {
                flags.door_direction = CLOSE;
            }
            else if(flags.door_direction == CLOSE) {
                flags.door_direction = OPEN;
            }
        }
            _delay_ms(2000);
        TIMSK1 |= (1<<TOIE1);    //Timer 1 Overflow Interrupt einschalten
        PORTC |= (1<<PC1);        //AUTO LED ein
        PORTC &= ~(1<<PC0);        //MAN LED aus
    }
}
return(1);
}

void init(void) {

    //LED Port, OCR1x Ports auf Ausgang
    DDRC |= (1<<PC0) | (1<<PC1) | (1<<PC2) | (1<<PC3) | (1<<PC4) | (1<<PC5);
    PORTC = 0x00;
    DDRB |= (1<<PB1) | (1<<PB2);

    //Tasten
    keys_init();

    //Grundeinstellungen Flags
    flags.s0mode = REV;
    flags.s1mode = NORM;
    flags.door_direction = OPEN;
    flags.mode = MAN;
    flags.pgm = 0;
    flags.valid_data = 0;

    //Grundeinstellungen Servos
    /*
        TO DO: Abfrage auf sinnvolle EEPROM Daten
    */
    if(flags.valid_data == 0) {
        //sinnvolle defaults
        servo0.min = SERVOMIN;
        servo0.max = SERVOMAX;
        servo0.center = SERVOCENTER;
        servo0.pos = SERVOCENTER;
        servo1.min = SERVOMIN;
        servo1.max = SERVOMAX;
        servo1.center = SERVOCENTER;
        servo1.pos = SERVOCENTER;
    }
    else if(flags.valid_data == 1) {
        //TO DO
    }
    
    //Timer0, Mode PWM
    ICR1=SERVOFRAME;
    OCR1A=servo0.pos;
    OCR1B=servo1.pos;
    
    TCCR1A |= (1<<COM1A1) | (1<<COM1B1) |(1<<WGM11);
    TCCR1B |= (1<<WGM13) | (1<<WGM12) | (1<<CS11);

    //global Interrupt enable
    sei();
}    
void manual_cont(void) {
    //Wenn Taste 0 (Close) kurz gedrückt wird schrittweise zufahren
    if(get_key_short(1<<KEY0)) {
        if(flags.s0mode == NORM && servo0.pos < servo0.max) {
            servo0.pos +=STEP;
        }
        if(flags.s0mode == REV && servo0.pos > servo0.min) {
            servo0.pos -= STEP;
        }
        if(flags.s1mode == NORM && servo1.pos < servo1.max) {
            servo1.pos +=STEP;
        }
        if(flags.s1mode == REV && servo1.pos > servo1.min) {
            servo1.pos -= STEP;
        }
    }
    
    //Wenn Taste 0 (Close) lang gedrückt wird komplett zufahren
    if(get_key_long(1<<KEY0)) {
        if(flags.s0mode == NORM) {
            servo0.pos = servo0.max;
        }
        if(flags.s0mode == REV) {
            servo0.pos = servo0.min;
        }
        if(flags.s1mode == NORM) {
            servo1.pos = servo1.max;
        }
        if(flags.s1mode == REV) {
            servo1.pos = servo1.min;
        }
    }
            
    //Wenn Taste 1 (Open) kurz gedrückt wird schrittweise auffahren
    if(get_key_short(1<<KEY1)) {
        if(flags.s0mode == NORM && servo0.pos > servo0.min) {
            servo0.pos -=STEP;
        }
        if(flags.s0mode == REV && servo0.pos < servo0.max) {
            servo0.pos += STEP;
        }
        if(flags.s1mode == NORM && servo1.pos > servo1.min) {
            servo1.pos -=STEP;
        }
        if(flags.s1mode == REV && servo1.pos < servo1.max) {
            servo1.pos += STEP;
        }
    }        
            
    //Wenn Taste 1 (Open) lang gedrückt wird komplett auffahren
    if(get_key_long(1<<KEY1)) {
        if(flags.s0mode == NORM) {
            servo0.pos = servo0.min;
        }
        if(flags.s0mode == REV) {
            servo0.pos = servo0.max;
        }
        if(flags.s1mode == NORM) {
            servo1.pos = servo1.min;
        }
        if(flags.s1mode == REV) {
            servo1.pos = servo0.max;
        }
    }
    OCR1A = servo0.pos;
    OCR1B = servo1.pos;
}

ISR(TIMER1_OVF_vect) {
    if(flags.door_direction ==OPEN) {
        if(flags.s0mode == NORM && servo0.pos > servo0.min) {
            servo0.pos -=ASTEP;
        }
        if(flags.s0mode == REV && servo0.pos < servo0.max) {
            servo0.pos += ASTEP;
        }
        if(flags.s1mode == NORM && servo1.pos > servo1.min) {
            servo1.pos -=ASTEP;
        }
        if(flags.s1mode == REV && servo1.pos < servo1.max) {
            servo1.pos += ASTEP;
        }
    }
    
    if(flags.door_direction == CLOSE) {
        if(flags.s0mode == NORM && servo0.pos < servo0.max) {
            servo0.pos +=ASTEP;
        }
        if(flags.s0mode == REV && servo0.pos > servo0.min) {
            servo0.pos -= ASTEP;
        }
        if(flags.s1mode == NORM && servo1.pos < servo1.max) {
            servo1.pos +=ASTEP;
        }
        if(flags.s1mode == REV && servo1.pos > servo1.min) {
            servo1.pos -= ASTEP;
        }
    }    
    OCR1A = servo0.pos;
    OCR1B = servo1.pos;
}

Quellcode

/****************************************************************************************/
/*                                                                                        */
/*        Tastenentprellung  nach Peter Danneger, vielen Dank!        */
/*                                                                                        */
/****************************************************************************************/    

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include "keys.h"

//Keys
volatile uint8_t key_state;                                    // debounced and inverted key state:
                                                              // bit = 1: key pressed
volatile uint8_t key_press;                                    // key press detect
 
volatile uint8_t key_rpt;                                      // key long press and repeat

ISR( TIMER0_OVF_vect )                                        // every 1ms
{
    static uint8_t ct0, ct1, rpt;
    uint8_t i;

        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( (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;
        }
}
 
void keys_init(void)
{
    //Keys
    KEY_DDR |= ALL_KEYS;
    KEY_DDR &= ~ALL_KEYS;                    // konfigure key port for input
      KEY_PORT |= ALL_KEYS;                    // and turn on pull up resistors
     //configure Timer0, 10ms
    OCR0A=77;
      TCCR0A |= (1<<WGM01) | (1<<WGM00);
    TCCR0B |= (1<WGM02) |(1<<CS02) | (1<<CS00);                    
      TIMSK0 |= (1<<TOIE0);                        // enable timer interrupt
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask ) {
    cli();                                          // read and clear atomic !
    key_mask &= key_press;                          // read key(s)
    key_press ^= key_mask;                          // clear key(s)
    sei();
    return key_mask;
}

uint8_t get_key_short(uint8_t key_mask) {
    cli();
    return get_key_press(~key_state & key_mask);
}

uint8_t get_key_long(uint8_t key_mask) {
    cli();
    return get_key_press(get_key_rpt(key_mask));
}
 
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported beeing pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask ) {
    cli();                                          // read and clear atomic !
     key_mask &= key_rpt;                            // read key(s)
    key_rpt ^= key_mask;                            // clear key(s)
    sei();
    return key_mask;
}

Quellcode

#ifndef KEYS_H
#define KEYS_H

/****************************************************************************************/
/*                                                                                        */
/*        Tastenentprellung nach Peter Danneger, vielen Dank!                                */
/*                                                                                        */
/****************************************************************************************/    

#ifndef F_CPU
#error "F_CPU not defined!"
#endif


//Ports und Pins anpassen
//Taster
#define KEY_DDR         DDRD
#define KEY_PORT        PORTD
#define KEY_PIN         PIND
#define KEY0            7
#define KEY1            6
#define KEY2            5
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2) 
#define REPEAT_MASK     (1<<KEY0 | 1<<KEY1)     // repeat: key1
#define REPEAT_START    30                      // after 300ms
#define REPEAT_NEXT     10                      // every 100ms


// Timer 0 Initialisieren

extern void keys_init(void);

// check if a key has been pressed. Each pressed key is reported only once

extern uint8_t get_key_press( uint8_t key_mask );

extern uint8_t get_key_short(uint8_t key_mask);

extern uint8_t get_key_long(uint8_t key_mask);

// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported beeing pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
extern uint8_t get_key_rpt( uint8_t key_mask );

#endif //KEYS_H

Quellcode

#ifndef SERVO_H
#define SERVO_H

//servo values
#define SERVOMAX 3799
#define SERVOMIN 2199
#define SERVOCENTER 2999
#define SERVOFRAME 29999
#define NORM 0
#define REV 1
#define STEP 50
#define ASTEP 10
//
//types
typedef struct {
    uint16_t min;
    uint16_t max;
    uint16_t center;
    volatile uint16_t pos;
} servo;
//end types
#endif //SERVO_H