Attiny-Anfänger: Hilfe bei Tastensteuerung

[Hans (Gast)]

Hallo zusammen!

Ich versuche gerade mir einen Treiber für meine LED Taschenlampe zu 
programmieren, allerdings habe ich da so meine Probleme. Ich habe 
bereits einen veröffentlichten Code an meine Bedürfnisse angepasst, 
welcher allerdings die Modi durch Unterbrechung der Spannungsversorgung 
realisiert. Da ich allerdings für mein aktuelles Projekt einen 
SMD-Taster verwenden muss, habe ich versucht mir was eigenes zu 
Stricken.

Vorab kurz die Funktionsweise:

Attiny wird über eine Taste gesteuert.
PWM wird für die Ansteuerung des "Leistungsteils" verwendet.
Durch das Drücken des Tasters sollen die Modi gewechselt werden.
Da die Stromquelle / Akku nicht physikalisch getrennt wird, soll der 
Attiny in den Power-Down Modus versetzt werden und so den Akkus nur 
minimal zu entleeren.

DIe Funktion hatte ich mir wie folgt vorgestellt:

in der main-Routine wird über case/switch ein Modus gewählt und verfällt 
hier in eine Dauerschleife.

In einer Interrupt-Routine wird der Taster abgefragt, bzw. die Routine 
ausgelöst sobald dieser aktiviert wird. Zusätzlich wird eine Flagge 
gesetzt, welche die Dauerschleife in der main-Routine unterbricht und in 
den nächsten Modus geht.

Als letzter Modus wird das PWM Signal zu 0 gesetzt und der Power-Down 
Modus aktiviert.

Der Attiny wird bei einem erneuten Tastsignal geweckt und fährt im 
Programm fort.

Zusätzlich wollte ich in der WatchDog-Routine eine Akkuüberwachung 
implementieren.
(Dies habe ich aus einem lauffähigen Code so entnommen)


Jetzt zu meinem Problem: Das einzige was funktioniert ist die PWM, ein 
Umschalten der Modi funktioniert nicht.

Ich denke ich habe irgendwo einen Verständnisfehler. Allerdings hab ich 
keine Ahnung wo.
Für Kritik und Anregungen bin ich gerne offen.

//LED Treiber mit Attiny13; PWM Ausgang für LED Steuerung PB1; Akkuüberwachung über ADC PB2; Taster auf PB3

//########################################################################################### MODE/PWM SETUP 

#define outpin 1  // PWM Ausgang PB1
#define PWM OCR0B  //PWM-value

#define adcpin 2    //ADC PIN !  PB2
#define adcchn 1  //ADC Kanal ! ADC1

#define tasterpin 3  //PCINT3

#define portinit() do{ DDRB=(1<<outpin); PORTB=0xff-(1<<outpin)-(1<<adcpin)-(1<<tasterpin);  }while(0)//Port deklarieren


#define F_CPU 4800000    //CPU: 4.8MHz  PWM: 9.4kHz       ####### use low fuse: 0x75  #######   
//#define BATTMON  125//enable battery monitoring with this threshold


//###########################################################################################

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/eeprom.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>

#define byte uint8_t
#define word uint16_t

#define WDTIME 0b01000011  //125ms

#define sleepinit() do{ WDTCR=WDTIME; sei(); MCUCR=(MCUCR &~0b00111000)|0b00110000; }while(0) //WDT-int and Power Down-Sleep

#define SLEEP asm volatile ("SLEEP")

#define pwminit() do{ TCCR0A=0b00100001; TCCR0B=0b00000001; }while(0)  //chan A, phasePWM, clk/1  ->2.35kHz@1.2MHz

#define adcinit() do{ ADMUX =0b01100000|adcchn; ADCSRA=0b11000100; }while(0) //ref1.1V, left-adjust, ADC1/PB2; enable, start, clk/16
#define adcread() do{ ADCSRA|=64; while (ADCSRA&64); }while(0)
#define adcresult ADCH


#define ADCoff ADCSRA&=~(1<<7) //ADC off (enable=0);
#define ADCon  ADCSRA|=(1<<7)  //ADC on
#define ACoff  ACSR|=(1<<7)    //AC off (disable=1)
#define ACon   ACSR&=~(1<<7)   //AC on  (disable=0)


//______________________Taster entprellen_______________________________________________________________________________________________
/************************************************************************/
/*                                                                      */
/*                      Not so powerful Debouncing Example              */
/*                      No Interrupt needed                             */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                                                                      */
/************************************************************************/
// Target: ATtiny13
//http://www.mikrocontroller.net/attachment/highlight/67964

#define debounce( port, pin )            \
({                  \
  static uint8_t flag = 0;  /* new variable on every macro usage */  \
  uint8_t i = 0;              \
                  \
  if( flag ){      /* check for key release: */    \
    for(;;){      /* loop ... */        \
      if( !(port & 1<<pin) ){  /* ... until key pressed or ... */  \
  i = 0;      /* 0 = bounce */      \
  break;                \
      }                  \
      _delay_us( 98 );    /* * 256 = 25ms */      \
      if( --i == 0 ){    /* ... until key >25ms released */  \
  flag = 0;    /* clear press flag */      \
  i = 0;      /* 0 = key release debounced */    \
  break;                \
      }                  \
    }                  \
  }else{      /* else check for key press: */    \
    for(;;){      /* loop ... */        \
      if( (port & 1<<pin) ){  /* ... until key released or ... */  \
  i = 0;      /* 0 = bounce */      \
  break;                \
      }                  \
      _delay_us( 98 );    /* * 256 = 25ms */      \
      if( --i == 0 ){    /* ... until key >25ms pressed */  \
  flag = 1;    /* set press flag */      \
  i = 1;      /* 1 = key press debounced */    \
  break;                \
      }                  \
    }                  \
  }                  \
  i;        /* return value of Macro */    \
})


//_____________________________________________________________________________________________________________________

byte mypwm=0;
byte pmode=1;  //Start Mode
byte interrupt_flag=1;

#ifdef BATTMON
byte lowbattcounter=0;
#endif



ISR(WDT_vect) {  //WatchDogTimer interrupt / Akkuüberwachung

#ifdef BATTMON //code to check voltage and ramp down
  adcread(); 
  if (adcresult<BATTMON) { if (++lowbattcounter>8) {mypwm=(mypwm>>1)+3;lowbattcounter=0;} } //Halbiert PWM
  else lowbattcounter=0;
#endif
}



ISR(PCINT0_vect) {  //pin change interrupt
//PWM=30; //test 

if( debounce( PINB, tasterpin )){ //Taster entprellt
interrupt_flag=0; //aktuellen Modus verlassen
pmode++; //nächster Modus
}}

int main(void) {

  portinit(); //Ports
  sleepinit(); //Sleep
  ACoff;
#ifdef BATTMON
  adcinit();
#else
  ADCoff;
#endif
  pwminit(); //PWM

PCMSK = (1 << tasterpin); // Externer Reset auf tasterpin definieren
GIMSK = (1 << PCIE); // Pin Change Interrupt freigeben


while(1){
interrupt_flag=1; //Dauerschleife aktivieren

  switch(pmode){

    case 1:  mypwm=255;  while(interrupt_flag){PWM=mypwm;} break; //100%

    case 2:  mypwm=120;  while(interrupt_flag){PWM=mypwm;} break; //50%
              

    case 3:  mypwm=0;  //Ausgang auf 0%
  sleep_cpu();     //power down


  //--nach power down--

  pmode=1; //mit 1 Mode starten
  break; 
              


    default:   mypwm=5; while(interrupt_flag){PWM=mypwm;} pmode=1; break; //all other

  }//switch

}




  return 0;
}//main