Speicherfunktion ???

[Nicole01]

Hallo zusammen,

ich würde gerne den letzten Zustand nach einem Tastendruck Speichern.

Es soll so funktionieren.

Strom am Attiny AN.
Jetzt leuchtet eine LED für 10 Sekunden.

Wenn ich jetzt den Taster mindestens 5 Sekunden drücke schreibt es mir einen neuen Wert in das Eeprom und bei einem Neustart leuchtet die LED nicht mehr da ja der neue Wert im Eeprom steht ( LED aus )

Wenn ich den Taster jetzt wieder für mindestens 5 Sekunden drücke schreibt er mir wieder den alten Wert ins Eeprom und nach einem Neustart leuchtet auch die LED wieder für 10 Sekunden.

Könntet Ihr mir bitte sagen wie ich das am einfachsten Umsetzen kann?

Ich weiß nicht welcher Weg der einfachste ist um ans Ziel zu kommen ?
Und wie genau lautet hier der Fachbegriff für diese Funktion?

[Bumbum]

Hallo,

wo hängt es denn? Hast du schon angefangen? Funktioniert schon ein Teil?

[Nicole01]

So wirklich viel habe ich leider noch nicht.


int main (void)
{
DDRB |= (1<<PB1); // Ausgang für LED
DDRB = ~(1<<PB0); // Eingang für Taster
PORTB |= (1<<PB0); // Pullup Einschalten

PORTB = (1<<PB1);
_delay_ms(10000);
PORTB &= ~(1<<PB1);

while (1)
{


}
}



Jetzt ist die Frage mit welcher Funktion kann ich zum Erfolg kommen ?
Natürlich benötige ich einen Taster das ist mir soweit klar.

Nur eben wie mache ich die Afrage das der Taster mindestens 5 Sekunden gedrückt wurde ?
Und wie sage ich ihm das er den neuen Wert auch nach dem Neustart speichern soll?

[shedepe]

Nun jetzt zerlegen wir dein Problem mal in einige kleine Teilprobleme:

1. Einlesen eines Tasters
//Entnommen hier raus: https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial


/* Fuehre Aktion aus, wenn Bit Nr. 1 (das "zweite" Bit) in PINC gesetzt (1) ist */
if ( PINC & (1<<PINC1) ) {
/* Aktion */
}


2. Zeit messen können.

Variante 1: Einfach 5 Sekunden schlafen und dann schauen ob der Taster immer noch High ist
Variante 2: Mit einem Timer der alle 10 Millisekunden eine Variable hochzählt die Zeit messen. Dazu merkt man sich in der Hauptschleife beim ersten mal Abfragen den Wert der Zeitvariable und prüft diese bei jeden Durchlauf ab. Wenn 5 Sekunden vergangen sind noch mal den Eingangspin des Tasters prüfen. (Hat den Vorteil man kann die Zeit auch noch anders verwenden)

3. In den EEPROM schreiben

Das lesen/ schreiben in den EEPROM ist vom Code her eine etwas aufwendigere Geschichte. Deshalb verweise ich an der Stelle nur auf die passende Stelle im AVR GCC Tutorial: https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEMEM
Ein Hinweis dabei: Man sollte das EEPROM ringweise beschreiben, da die einzelnen Zellen eine stark begrenzte Anzahl von Schreibzyklen haben.


Schreib einfach wenn du konkrete Fragen zu einem der Punkte hast.

[Nicole01]

Einlesen eines Tasters ist kein Problem.

Nur einen Timer der alle 10 Millisekunden eine Variable hochzählt und die Zeit mist ist ein Problem :confused:

Würde die Berechnung für die 10 ms so passen für den Timer ?


TCCR0 |= (1<<CS02) | (1<<CS00)
TCNT0 = 158

[shedepe]

Dann mach doch erst mal die Variante mit _delay_ms(5000).
Also


if(Pin HIGH)
{
_delay_ms(5000);
if(Pin ist immer noch HIGH)
{
//DO some stuff
//Und natürlich die Pin ist high abfrage durch den richtigen Code ersetzen ;)
}
}


Bezüglich Timer: Lies das Datenblatt, da wird das erklärt ;) Ich weiß es leider auch nicht auswendig.

[Holomino]

Um die Timerkonfig durchzugehen, müsstest Du schreiben, welchen genauen Typ Du verwendest (wahrscheinlich ATTiny11 oder 12???) und bei welcher Frequenz der Controller läuft (bei 16MHz würde die Konfiguration rechnerisch Sinn ergeben, es funktioniert aber bei den o.g. Typen nicht, weil die nur einen Overflow im TCNT0 signalisieren).

[Nicole01]

Das ist richtig, ich nutze einen Attiny85.

Der Controller wurde von mir nicht verändert.
Somit sollte er mit 1 MHz laufen denke ich :)

shedepe, wenn ich das richtig verstanden habe nützt es mir jetzt nichts, wenn ich einfach eine if Abfrage mit einbaue.

Warum ?

Ich habe ja dan über der If Abfrage meinen Code stehen ( siehe weiter oben )
Der Code wird jedes mal Abgearbeitet wenn der Controller Strom bekommt.

Somit darf doch der Code nicht über der If Abfrage stehen oder ?
Ich möchte ja per Taster sagen, wenn 5 Sekunden gedrückt Funktion deaktivieren.
Wenn wieder 5 Sekunden gedrückt wurde Funktion aktivieren.

Verstehe ich das falsch ?

[shedepe]

Ich glaube dir fehlt so ein bisschen das Grundverständnis für Mikrocontroller.

Letztendlich hat dein Code eine main Funktion



int main(void)
{

}


Wenn der Controller startet oder einen Reset durchführt schaut er im Speicher an einer bestimmten Stelle nach. Nämlich dort wo der Code für die Main Funktion liegt. Dieser Code wird dann ausgeführt.
D.h. effektiv wenn wir einfach nur eine Anweisung reinschreiben, dann wird diese ausgeführt und das Programm ist zu Ende.
Also z.B



int main(void)
{
DDRB = (1<<PB0);
//Und jetzt endet das Programm
}


Deshalb haben wir die Main schleife. Jede Anweisung darin wird so lange ausgeführt bis der Controller ausgeschaltet wird:
Also:



int main(void)
{
//Einmalige Setup Sachen (z.B. pin auf Eingang setzen)
while(1)
{
//Sachen die wiederholt getan werden sollen (Also z.B. Pin Zustand abfragen)
}
}


Für Deinen Fall bedeutet das jetzt, dass du in etwa sowas hier willst:



int main(void)
{
DDRB = (1<<PB0); //Entsprechende PINs auf Eingang setzen
//Weitere Setup Aktionen durchführen wie z.B. LED Pin auf Ausgang setzten
//Zustand aus dem EEPROM lesen
if(statusfromeeprom)
{
//LED an
//10 Sekunden warten
//LED aus
}
while(1)
{
//Hier jetzt den Taster abfragen:
if(PINB & (1<<PB0))
{
_delay_ms(5000); //5 Sekunden warten
if(PINB & (1<<PB0)) //Schauen ob der Pin immer noch High ist
{
//Jetzt wissen wir der Taster wurde für mindestens 5 sekunden gedrückt
//Also neuen Status in das EEPROM schreiben
}
}
}
}

Ich habe hier Pseudocode(als Kommentar) und realen Code gemischt

PS. Was ich vergessen habe: Tu dir selber den Gefallen und verbringe einfach mal paar Stunden zum einen damit das passende Datenblatt des Controllers zu lesen:
http://www.atmel.com/images/atmel-2586-avr-8-bit-microcontroller-attiny25-attiny45-attiny85_datasheet.pdf (Schau ob das das richtige ist!)
Und vorallem das AVR-GCC Tutorial: https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe
Dabei geht es gar nicht darum dass man danach alles weiß was drin steht, sondern in den Datenblättern/Tutorien wird auch allgemein einiges über Prinzipien und Abläufe erklärt. Wenn man sich die Mühe macht das mal durchzuarbeiten hat man danach einen viel tieferen Einblick was alles möglich ist und vorallem wie es möglich ist.

[i_make_it]

Das Konstrukt mit dem Delay sollte man wirklich ert mal machen und zum laufen bringen, also inklusive Abfrage des Zustandmerkers aus dem EEPROM und schreiben des selben.
Auch wenn das Delay nicht erkennt, wenn jemand den Taster drückt für 4,9 Sekunden loslässt und grade noch rechtzeitig vor Ende des Delays ein zweites mal drückt.
Das wird man dann später mit einem Interrupt der auf Pegeländerung des Tastereingangs reagiert und einem Timer abfangen können.

[Nicole01]

Habe das ganze jetzt mal versucht zu ändern.

Hier der Code.


#include <avr/io.h>
#include <util/delay.h>
#include <avr/eeprom.h>


int main(void)
{
DDRB |= (1<<PB1); // Ausgang für LED
DDRB = ~(1<<PB0); // Eingang für Taster
PORTB |= (1<<PB0); // Pullup Einschalten


if(statusfromeeprom) // Zustand aus dem EEPROM lesen
{
DDRB |= (1<<PB1); // LED Einschalten
_delay_ms(10000) // 10 Sekunden warten
DDRB &= ~(1<<PB1); // LED ausschalten

}
while(1)
{
//Hier jetzt den Taster abfragen:
if(PINB & (1<<PB0))
{
_delay_ms(5000); //5 Sekunden warten
if(PINB & (1<<PB0)) //Schauen ob der Pin immer noch High ist
{
//Wie soll ich hier den neuen Wert ins Eeprom schreiben ?
//Also neuen Status in das EEPROM schreiben
}
}
}
}


Das habe ich zum Eeprom lesen und schreiben gefunden.


// Byte aus dem EEPROM lesen
uint8_t EEPReadByte(uint16_t addr)
{
return eeprom_read_byte((uint8_t *)addr);
}

// Byte in das EEPROM schreiben
void EEPWriteByte(uint16_t addr, uint8_t val)
{
eeprom_write_byte((uint8_t *)addr, val);
}

Natürlich habe ich noch viel mehr zum Eeprom gefunden.
Nur ist es für einen Anfänger nicht gerade leicht das richtige zu finden.

Und ja, ich lese wirklich sehr sehr viel im Internet nur leider fällt es mir sehr schwer das ganze zu verstehen :(

PS: Welche Zugriffsart benötige ich bei meinem Programm?
Byte, word, dword, float oder block ?

[i_make_it]

Welche Zugriffsart Du benötigst, müsstest Du eigenlich wissen.

https://de.wikipedia.org/wiki/Byte

https://de.wikipedia.org/wiki/Datenwort

https://de.wikipedia.org/wiki/Gleitkommazahl

BLockread und Blockwrite nimmt man normalerweise für große Datenmengen wie ganze Dateien oder Datenströme.


Du willst doch eigenlich nur ein einzelnes Bit als Merker für den Systemzustand nutzen.
Nimm einfach das was am nächten an einem Bit dran ist.