Mikrocontroller Steuerung

[ansgar (Gast)]

Hallo,

ich habe folgendes Problem. Ich möchte eine Schaltung mit einem Attiny 
realisieren welche nach jedem Neustart des Systems einen anderen Zustand 
einnimmt. Neustart heißt die Spannungsversorung wird komplett getrennt 
und anschließend wieder verbunden. Es gibt insgesamt 3 Zustände.

Nach dem ersten Einschalten soll Zustand 1 aktiviert werden.
Nach dem nächsten aus/einschalten Zustand 2, nach dem nächsten 
aus/einschalten Zustand 3.
Danach soll bei jedem weiteren aus/einschalten zwischen Zustand 2 und 3 
toggeln.

Das lässt sich ja noch gut mit einer Flag realsieren realsieren, ich 
hoffe nur dass der EEPROM wirklich an die 100k Schreibzyklen mitmacht.

Das eigentliche Problem ist nun folgendes. Ich möchte dass nach einer 
gewissen Zeit im ausgeschalteten Zustand, also zB. 5 Minuten der 
Mikrocontroller nach dem Einschalten wieder in den Zustand 1 wechselt.

Ich weiß nur nicht wie ich das Clever lösen kann.
Was mir einfallen würde:
Spannung an einem Kondensator messen-> nach gewisser Zeit bestimmter 
Pegel unterschritten.

Oder irgendwie den µC über einen Goldcap solange versorgen und einen 
Timer laufen lassen.

So recht gefällt mir das aber nicht.

Wie könnte ich Das am geschicktesten lösen? Ihr habt da hoffentliche 
bessere Vorschläge?

Allgemein ist nur wenig Platz für zusätzliche Bauteile vorhanden.

Danke schonmal

Gruß Ansgar

[holger (Gast)]

>Wie könnte ich Das am geschicktesten lösen? Ihr habt da hoffentliche
>bessere Vorschläge?

Controller nicht wirklich ausschalten und neu starten sondern
in den Sleep Modus setzen. Ansonsten wird das wohl eher eklig.

[ansgar (Gast)]

danke für deine Antwort. Leider ist das Gerät Batteriebetrieben, und ich 
kann/will aus verschiedenen Gründen das Umschalten zwischen den 
Zuständen nur durch den Reset mittels "Spannung weg" realisieren. Ein 
Taster kommt nicht in Frage.

Danke

[Hop Triceratop (Gast)]

Was soll dieser tiny-Scheiss. Nimm einen richtigen Mega16 oder groesser. 
Die 2 Euro mehr koennen's nicht sein.

[Frank K. (fchk)]

EEPROM durch einen MCP79410 EEPROM/RAM/RTC ersetzen.

Beim Power-Off solltest Du schauen, ob Du einen Power-Off Interrupt 
hinbekommst, bei dem Du den aktuellen Zeitstempel im SRAM des MCP 
speicherst. Wenn Du das nicht schaffst, machst Du das halt periodisch 
alle 15s.
Beim Wiederanschalten prüfst Du den Zeitstempel gegen die aktuelle Zeit 
und führst die entsprechende Aktion aus. Den letzten Zustand speicherst 
Du auch im gepufferten SRAM.

fchk

[ansgar (Gast)]

Der Mehrpreis ist sicher nicht der Grund für den Tiny, sondern der nicht 
vorhandene Platz und der geringere Stromverbrauch.

Wie könnte denn ein Atmega mein Problem "lösen"?

Danke

Ansgar

[holger (Gast)]

>Leider ist das Gerät Batteriebetrieben

Ist doch ok. Im Sleep Modus zieht der uC nur ein
paar uA. Wenn überhaupt.

[skyperhh (Gast)]

Für den Zustandswechsel wie geschrieben das EEPROM nutzen... für den 
Rückfall nach 5min folgende Idee.

Mosfet der über den µC eingeschaltet werden kann und einen Kondensator 
lädt... im laufenden Betrieb evtl. immer mal wieder Nachladen, damit die 
Spannung am Kondensator nahe Betriebsspannung bleibt... wenn der µC 
abgeklemmt wird, entlädt sich der Kondensator langsam ... über den 
Widerstand/Kondensator kann man die Entladezeit festlegen. Ein 
Komperator oder Schmitt-Trigger vergleicht dann beim Einschalten die 
Spannung ...

[ansgar (Gast)]

@Frank

Vielen Dank für Deine Antwort. Leider benötige ich dafür wieder einige 
zusätzliche Bauteile, Quarz usw.
Den MCP müsste ich dann wohl noch über einen Goldcap versorgen, oder 
gibts da was besseres?

@Holger
wie gesagt ich muss zum Wechseln zwischen den Zuständen die 
Spannungsversorung trennen.
Oder kann ich den Tiny 5 Minuten über einen Goldcap versorgen und einen 
Timer laufen lassen?

Danke

Ansgar

[ansgar (Gast)]

@skyperhh

ja an sowas ähnliches hatte ich auch gedacht. Aber ich weiß nicht wie 
zuverlässig das Ganze funktionieren würde.

Danke

Ansgar

[holger (Gast)]

>@Holger
>wie gesagt ich muss zum Wechseln zwischen den Zuständen die
>Spannungsversorung trennen.
>Oder kann ich den Tiny 5 Minuten über einen Goldcap versorgen und einen
>Timer laufen lassen?

Den kannst du im Sleep Modus ein paar Tage mit Goldcap laufen lassen.

[frame (Gast)]

> Das lässt sich ja noch gut mit einer Flag realsieren realsieren, ich
> hoffe nur dass der EEPROM wirklich an die 100k Schreibzyklen mitmacht.

Die minimale Anzahl an Lösch/Schreibzyklen ist über den gesamten 
Temperaturbereich garantiert, in diesem Fall für die Maximaltemperatur.
Bei 25°C sind (nicht garantiert) 1...5 Mio. Zyklen drin.

Du könntest z.B. nach einem Ausschalten die EEPROM-Bytes sukzessive auf 
0 setzen, die Null-Bytes zählen und das Ergebnis der Modulo 3 - Division 
als Startzustandsindikator verwenden.

Das setzt voraus, daß du nach dem Abschalten noch genügend 'Saft' zum 
Schreiben und ggf. vollständigen Löschen des EEPROMs hast.
Meine Firma verwendet eine ähnliche Methode in Geräten, die in 
Millionenstückzahlen verkauft werden.

[skyperhh (Gast)]

ansgar schrieb:
> ja an sowas ähnliches hatte ich auch gedacht. Aber ich weiß nicht wie
> zuverlässig das Ganze funktionieren würde.

Warum sollte das ganze nich funktionieren? Kleines C wählen, großer 
Widerstand...

[ansgar (Gast)]

@ frame

könntest Du das Verfahren mal näher erleutern?

@skyperhh

bei einigen Versuchen hat der Kondensator die Spannung keine 5 Minuten 
gehalten.
Möglicherweiße muss ich da mal noch verschiedene Typen testen.

[Frank K. (fchk)]

ansgar schrieb:
> @Frank
>
> Vielen Dank für Deine Antwort. Leider benötige ich dafür wieder einige
> zusätzliche Bauteile, Quarz usw.

1* 32kHz Quarz. 1* 100n Abblockkondensator 2* Pullup-R für den I2C
Das wars.

> Den MCP müsste ich dann wohl noch über einen Goldcap versorgen, oder
> gibts da was besseres?

Dein Gerät ist doch ohnehin batteriebetrieben, oder? Dann trenne nur die 
eigentliche Stromversorgung, nicht aber die Versorgung zu VBat vom MCP.

fchk

[Markus W. (Firma: guloshop.de) (m-w)]

Frank K. schrieb:
> 1* 32kHz Quarz. 1* 100n Abblockkondensator 2* Pullup-R für den I2C
> Das wars.

Ich weiß nicht, ich finde das reichlich kompliziert...

Für die gewünschte Funktion reicht ein ATtiny13A – ohne Quarz. Als 
Puffer für die Versorgungsspannung tuts für 5 Minuten im Sleepmode ein 
kleiner (!) Elko. EEPROM wird nicht benötigt.

Der ATtiny13A besitzt einen internen 128-kHz-Oszillator, den man per 
Vorteiler bis auf 500 Hz runtertakten kann. Dann braucht der 
Mikrocontroller eh kaum noch Strom.

Das Programm sollte kaum größer werden als ungefähr 30 Assembler-Zeilen.

Also, alles halb so wild, außer dem Mikrocontroller brauchst du 
eigentlich nur nen kleinen Elko, um die Spannung zu halten, und einen 
Kondensator in Reihe zum externen Interrupt-Eingang (mit Pulldown) – zum 
Aufwecken.

[frame (Gast)]

> @ frame
> könntest Du das Verfahren mal näher erleutern?

Eigentlich ist die Methode ursprünglich für Flash ausgelegt, den man nur 
blockweise löschen kann. Dabei werden Datenblöcke sukzessive in den 
Flash geschrieben, bis ein Block voll ist. Dann wird der nächste 
begonnen, und der übernächste voreilend gelöscht. Beim letzten Block 
wird dann wieder am Anfang begonnen.

Für deinen Fall wäre das simpler, z.B.:
Flash ist im unbeschriebenen Zustand 0xFF. Beim allerersten Start sind 
alle (verwendeten) Zellen 0xFF. Beim ersten Ausschalten setzt du die 
erste Zelle auf 0x00. Beim zweiten Ausschalten setzt du die erste Zelle 
wieder auf 0xFF, und die zweite auf 0x00. Und so weiter. Nach der 
letzten Zelle beginnst du wieder von vorn.
Das verteilt die Schreibzyklen gleichmäßig auf die Zellen, die du dafür 
verwenden willst - was auch den einzigen Vorteil gegenüber einem Zähler 
in einer Zelle darstellt.
Aus der Position der 0x00-Zelle kannst du die Anzahl bisheriger Starts 
ableiten, z.B. durch Modulo-Division.

Aber, wie gesagt, meine Firma nutzt Controller mit für 100k 
spezifizierten EEPROM-Schreibzyklen, bisher ohne Probleme.
100.000 Starts sind schon relativ viel, rechne das doch mal mit deiner 
angesetzten Schalthäufigkeit nach.

[Vlad T. (vlad_tepesch)]

frame schrieb:
> Das setzt voraus, daß du nach dem Abschalten noch genügend 'Saft' zum
> Schreiben und ggf. vollständigen Löschen des EEPROMs hast.

das brauchst du nicht.

folgender Ablauf:

Epprom inital nullen

startup: erste "nicht-0"-Zelle mit aktuellem Modus beschreiben.
irgendwann saft weg
nächster Startup. erste freie Zelle suchen, modus aus voriger Zelle 
berechnen und wieder wegschreiben.
Wenn ende des EEPROMS erreicht wieder komlett nullen und modus in erste 
Zelle schreiben.

so schreibt man immer nur ins eeprom, wenn man sicher Saft hat und 
verteilt die Schreibzugriffe auch optimal.

Das alles löst aber das 5min. Problem nicht.

Ich würde versuchen einen Kondensator zu nutzen.
wichtig ist, dass der µC den Spannungswegfall registriert und (zB per 
FET) sämtliche anderen Verbraucher vom Strom trennt. dann power down 
sleep aufsetzen und per Watchdog-Interupt weckenlassen und die ca 5min 
zählen. dannach einfach den internen Modus wieder auf Startwert setzen, 
falls vor dem irgendwann folgenden Brown-Out wieder angeschalten werden 
sollte.

Da braucht man auch gar kein eeprom.

[frame (Gast)]

Das Verfahren kommt von einem Gerät, daß diverse Zustände erst bei 
Netz-Aus und nicht dauernd sichert, weil wegen sich permanent ändernder 
Daten sonst die garantierte Anzahl an Lösch/Schreibzyklen schnell 
erreicht wäre.
Das Gerät muß aber einen Standard erfüllen, der die persistente 
Abspeicherung dieser Daten beinhaltet.
Deswegen ist die Netzversorgung auch auf eine Stützzeit von >300ms 
ausgelegt, um alle Daten sicher speichern zu können.

In wie weit diese Umstände auf das diskutierte Gerät zutreffen, muß der 
Fragesteller entscheiden.

[Bernhard S. (b_spitzer)]

Wenn eine Echtzeituhr (Batteriegepuffert mit kleinem RAM-Bereich) zu 
viel Aufwand ist, mach doch so:
Mach dem ersten einschalten läuft Betriebsart 1, danach legt sich der 
Controller schlafen und wird vom Timer regelmässig kurz geweckt. Wenn in 
der Zwischenzeit wieder Eingeschaltet wird, wechselt der Controller in 
Betriebsart 2/3/2/3 etc. Nach 5 min im Sleep/Aufwach-Betrieb schaltet 
sich der Controller aus und beim nächsten Einschalten ist daher wieder 
Betriebsart 1 dran. Dann brauchst Du eine Pufferung, die höchstens Strom 
für einige Minuten Sleep-Mode (5 Sleep plus Aufwachphasen) puffern muss.

[ansgar (Gast)]

Hallo,

danke für eure Unterstützung. Ich habe die Anforderungen jetzt etwas 
geändert.

Es gibt nur noch zwei Zustände. Die Zustände sollen nur zwei Ports 
umschalten.

Dass Trennen der Versorgungsspannung wird durch den ext. Interrupt 
detektiert, da er auf die fallende Flanke reagiert.
Der Interrupt lässt dann den Mode wechseln.

Der Attiny wird während der Off Zeit aus einem Elko gepuffert. Damit der 
Elko reicht wird wechselt er in den Sleepmode Idle.

Jetzt möchte ich allerdings dass IMMER Mode 1 aktiviert wird wenn die 
Offzeit länger als 8 Sekunden dauert.
Dauert die Offzeit weniger als 8 Sekunden soll man durch 
trennen/wiederherstellen der Spannungsversorung die Stufen wechseln 
können.

Ich habe dazu noch den Timer aktiviert, und wollte das mit dem 
Timeroverflow Interrupt machen.

Leider bekomme ich es nicht hin dass die 8 Sekunden nur während der 
Offzeit gelten, sondern nur so dass er immer nach 8 Sekunden schaltet.

Ich kann leider keine zusätzlichen Bauteile mehr einbauen, und muss das 
über die Software hinbiegen.

Ich hoffe ihr könnt mir nochmal helfen.

Anbei mal mein letzter Codestand, so funktioniert der Timeroverflow 
natürlich gar nicht, war nur ein Versuch.


Vielen Dank

Ansgar

//Includes
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include "defines.h"
#include <avr/sleep.h>

/**********************************************/
#define F_CPU 128000UL  // 128kHz CPU Takt
#include <util/delay.h>

/**********************************************/
//Variablen
volatile uint8_t Zaehler = 0;
volatile uint8_t Mode =1;
volatile uint8_t b = 0;
volatile bool Abbruch = true;

//uint8_t EStatus EEMEM = 0; //EEPROM



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

//Hauptprogramm
int main(void)
     {
  
  /*************Zuordnungen********************/
  
      

      DDRB = ( 1 << PB0 ) |  ( 1 << PB2 );// Ausgänge PB0 und PB2
      PORTB=0b00000000; //Ausgänge: LOW / Eingänge: Pullups deaktiviert
    
      TCCR0B= (1<<CS02) |(0<<CS01) |  (1<<CS00); // Prescaler 1024
      
      
      
      GIMSK   |=  (1<<INT0); //externer INT0 auf PB1 freigeben
      MCUCR |= (1<<ISC01) | (0<<ISC00); //Interrup INT0: fallende Flanke
      
  
     // Analogcomparator ausschalten
     
     ACSR = 0x80;
     
     //Interrupts zulassen
    sei();

    //Sleepmode "IDLE2" wählen
    set_sleep_mode(SLEEP_MODE_IDLE);
    
  
    while(1)
    {
       switch (Mode) 
    {
      case 1:  //100%
      
      {
        Abbruch = true;
       Mode = 2;
        while(Abbruch)    //Endlosschleife bis Abbruch durch Interrupt INTO
        {
          TIMSK0 &=~ (1<<TOIE0); //Timer Overflow Interrupt sperren 

          PORTB &= ~(1<<PB0); //Analogschalter 1 geschlossen
          PORTB |= (1<<PB2); //Analogschalter 2 geöffnet

             sleep_mode();  //schlafen
        }
            
      }
      
      break;
      
      
      
      
      
      
      
      case 2:     //25%
       {
         Abbruch = true;
         Mode = 1;
         while(Abbruch)  //Endlosschleife bis Abbruch durch Interrupt INTO
         {
           TIMSK0 &=~ (1<<TOIE0);  //Timer Overflow Interrupt sperren 

           PORTB |= (1<<PB0); //Analogschalter 1 geöffnet
           PORTB &= ~ (1<<PB2); //Analogschalter 2 geschlossen 

              sleep_mode(); //schlafen
         }
               
       }
       
       break;
      
      
      
      
      
      
      
      default:
                PORTB &= ~(1<<PB0); //Analogschalter 1 geschlossen
                PORTB |= (1<<PB2); //Analogschalter 2 geöffnet
      
      
    }
  
  }
  
return 0;
}
//Ende Hauptprogramm




/*****************************************************************/
//Interrupt Routine

ISR(TIM0_OVF_vect) // Timer0 Overflow Interrupt wird alle 2048ms aufgerufen
{
  //PORTB |=(1<<PB3);
  if (Zaehler < 3)  
  {
      Zaehler++; 

    }
  else {
    Zaehler = 0;
     Mode=1;    //nach 8s Mode 1 aktivieren
  }
  


  
}


ISR(INT0_vect)  //  Interrupt fallende Flanke PB1
{
  Abbruch = false;
  Zaehler = 0;
  _delay_ms(200);
  TCNT0 = 0;
  TIMSK0 |= (1<<TOIE0); //Overflow Interrupt zulassen
  
}

[ansgar (Gast)]

Ich habe mir gerade überlegt dass ich nach dem Interrupt fallende 
Flanke, den Interrupt auf steigende Flanke umstelle.
Somit könnte ich feststellen ob ich wieder eingeschaltet habe oder 
nicht.

Was meint ihr?

Danke

Ansgar

[ansgar (Gast)]

Hallo,

ich hab die Software jetzt so hinbekommen dass es scheinbar das macht 
was ich wollte.

Habt ihr noch Verbesserungsvorschläge?

Danke

Gruß Ansgar

//Includes
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include "defines.h"
#include <avr/sleep.h>

/**********************************************/
#define F_CPU 128000UL  // 128kHz CPU Takt
#include <util/delay.h>

/**********************************************/
//Variablen
volatile uint8_t Zaehler = 0;
volatile uint8_t Mode =1;
volatile uint8_t b = 0;
volatile bool Abbruch = true;

//uint8_t EStatus EEMEM = 0; //EEPROM



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

  //Funktionen
  void mode1(void)   //Mode1
  {
    PORTB &= ~(1<<PB0); //Analogschalter 1 geschlossen
    PORTB |= (1<<PB2); //Analogschalter 2 geöffnet
  }
  
  void mode2(void)   //Mode2
  {
    PORTB |= (1<<PB0); //Analogschalter 1 geöffnet
    PORTB &= ~ (1<<PB2); //Analogschalter 2 geschlossen
  }

  void interruptchange(void) //Externen Interrupt umschalten fallende/steigende Flanke
  {
     if ( !( MCUCR & (1<<ISC00) ) ) //falls Interrupt fallende Flanke
    {
       MCUCR |= (1<<ISC00);  //Interrupt auf steigende Flanke umstellen
       Zaehler = 0;
       TCNT0 = 0;
       TIMSK0 |= (1<<TOIE0); //Overflow Interrupt zulassen
    }
    else if(MCUCR & (1<<ISC00) )  //falls Interrupt steigende Flanke
   {
     MCUCR &= ~ (1<<ISC00); //Interrupt auf fallende Flanke umstellen
     TIMSK0 &=~ (1<<TOIE0); //Timer Overflow Interrupt sperren 
     Abbruch = false;
   }
  }
  //Funktionen Ende


//Hauptprogramm
int main(void)
     {
  
  /*************Zuordnungen********************/
  
      

      DDRB = ( 1 << PB0 ) |  ( 1 << PB2 ) | (1<<PB3);// Ausgänge PB0 und PB2
      PORTB=0b00000000; //Ausgänge: LOW / Eingänge: Pullups deaktiviert
    
      TCCR0B= (1<<CS02) |(0<<CS01) |  (1<<CS00); // Prescaler 1024
      
      GIMSK   |=  (1<<INT0); //externer INT0 auf PB1 freigeben
      MCUCR |= (1<<ISC01) | (0<<ISC00); //Interrup INT0: fallende Flanke
      
  
     // Analogcomparator ausschalten
     
     ACSR = 0x80;
     
     //Interrupts zulassen
    sei();

    //Sleepmode "IDLE" wählen
    set_sleep_mode(SLEEP_MODE_IDLE);
    
  
    while(1)
    {
       switch (Mode) 
    {
      case 1:  //100%
      
      {
        Abbruch = true;
       Mode = 2;
        while(Abbruch)    //Endlosschleife bis Abbruch durch Interrupt INTO
        {
                  mode1();
                  sleep_mode();  //schlafen
        }
            
      }
      
      break;
      
      
      
      
      
      
      
      case 2:     //25%
       {
         Abbruch = true;
         Mode = 1;
         while(Abbruch)  //Endlosschleife bis Abbruch durch Interrupt INTO
         {
           mode2();
            sleep_mode(); //schlafen
         }
               
       }
       
       break;
      
      default:
                PORTB &= ~(1<<PB0); //Analogschalter 1 geschlossen
                PORTB |= (1<<PB2); //Analogschalter 2 geöffnet
      
      
    }
  
  }

  
  
return 0;
}
//Ende Hauptprogramm


/*****************************************************************/
//Interrupt Routinen

ISR(TIM0_OVF_vect) // Timer0 Overflow Interrupt wird alle 2048ms aufgerufen
{
  
  
  if (Zaehler < 3)  
  {
      Zaehler++; 

    }
  else {
    Zaehler = 0;
     
     PORTB |=(1<<PB3);
     Mode=1;    //nach 8s Mode 1 aktivieren
  }
  


  
}


ISR(INT0_vect)  //  Interrupt fallende/steigende Flanke PB1
{
  
  _delay_ms(200);
  interruptchange();
  
}