Uhr, Display und Relais kombiniert in einem ATmega.

[Felix H. (felix_h55)]

Hallo allerseits.

Ich stehe mal wieder vor einem kleinen Projekt.

Das ganze soll hutschienenmäßig untergebracht sein - a la LOGO!, aber 
eben keine "reine" SPS sein, sondern eine Eigenlösung. Diese soll Stück 
für Stück erweitert werden, aber die grundlegende Basis soll das hier 
darstellen.
Die Aufgaben des µC soll in erster Linie das Steuern von Relais sein - 
im Bereich weniger Sekunden bis hin zu mehreren Stunden.

Parallel sollen sowohl Uhrzeit als auch Schaltzustände der Relais auf 
einem LCD angezeigt werden.

Die Platinen entsprechend herzustellen mit Optokopplern etc pp stellt 
nicht die Schwierigkeit dar. Die Programmierung des LCD auch nicht 
unbedingt, genauso wenig das Schalten eines Ausganges.

Schwierig wird es bei mir, wenn ich eine Uhrzeit (RTC, Softclock, 
DCF77...) erstmal irgendwie über Taster einstellen können möchte, diese 
dann auslesen, ausgeben und je nach Zeit einen Ausgang schalten will.

Sprich die Integration einer Uhr, welche im Lauf von 24 Stunden mehrere 
Schaltzeiten zulässt für mehrere Ausgänge stellt mich vor ein großes 
Problem.

Und Codeschnipsel, die es reichlichst gibt, helfen mir auch nicht 
wirklich sonderlich, da ich die absolute Programmiertniete bin. Habs mal 
mit Flowcode versucht, aber auch da bin ich nicht der hellste, wie mir 
scheint.
Das schwierigste ist für mich, die Codeteile miteinander zu verbinden, 
sodass diese ineinandergreifen und sich nicht gegenseitig stören...

Hach, was ist das herrlich. Was wäre die Welt ohne dumme Menschen.

Naja, zu den Fragen:

Welchen Uhrentyp würdet ihr empfehlen?
Wie kann ich das mit dem Stellen etc. über LCD und Taster am besten 
realisieren?
und vor allem:
Wie werden die Teile verheiratet?!?

Danke für eure konstruktiven Antworten
Felix

[Karl H. (kbuchegg)]

Felix H. schrieb:

> Das schwierigste ist für mich, die Codeteile miteinander zu verbinden,
> sodass diese ineinandergreifen und sich nicht gegenseitig stören...

Wenn du dir das so vorstellst, dass du da einzelne Codeteile hast, die 
du nur zusammenkopieren musst, dann wird das meistens nichts.

Man kann selbstverständlich vorhandene Codeteile benutzen. Aber das 
sollte man eher so sehen, dass man ein neues Programm schreibt, mit 
einem komplett neuen Design. Und anstatt, dass man jedesmal den 
kompletten Code erneut runtertippt, holt man ihn sich aus den fertigen 
Codeschnipseln und passt ihn an die Gegebenheiten an.

> Welchen Uhrentyp würdet ihr empfehlen?

Um eine im µC laufende Uhr wirst du wahrscheinlich sowieso nicht 
rumkommen. Also würde ich da erst mal mit einem Timer eine Uhr bauen, 
die im µC vor sich hintickt.

> Wie kann ich das mit dem Stellen etc. über LCD und Taster am besten
> realisieren?

Ach, wenn man wüsste was 'am besten' ist, wärs super. Gib dich erst mal 
mit 'so dass ich es implementieren kann' zufrieden und frag nicht gleich 
nach 'am besten'.

Taster bedingen Entprellung. Und zur Entprellung sind die PeDa 
Routinen immer noch die einfachste Möglichkeit.

> und vor allem:
> Wie werden die Teile verheiratet?!?

Gar nicht.
Fang mit einem frischen Design an. Und dann fragst du dich: Hab ich 
Codeteile, die ich weiterverwenden kann. Der Ansatz: Ich hab das und das 
vorrätig und das muss ich jetzt irgendwie miteinander verbinden führt 
meistens ins Leere.


Also:
Vergiss erst mal deine Tasten, vergiss deine Relais.
Erst mal brauchst du ein LCD, welches du ansteuern kannst und auf dem du 
Ausgaben machen kannst. Damit gehts los.

Als nächstes kommt dann eine Uhr. Implementiert mit einem Timer. Die 
korrekte Funktion der Uhr wird dadurch demonstriert, dass sich die 
Uhrzeit auf dem LCD ändert (und zwar so, dass man eine Armbanduhr 
daneben halten kann und die beiden ticken gleich schnell).
Deswegen hast du auch mit dem LCD aungefangen: Damit du möglichst bald 
etwas hast, auf dem du Ausgaben machen kannst.

Läuft die Uhr, geht es um die Fragestellung: Wie stelle ich sie ein.
Und da kommen dann die Tasten ins Spiel. Die PeDa Entprellung nimmt dem 
ganzen dann schon etwas Schwierigkeit, weil man sich nur noch um die 
Logik der Tastenbedienung kümmern muss. Den schwierigen Teil der 
Hardwareauswertung hat man damit schon erledigt.

Ist man soweit, dass man die Uhr stellen kann, legt man den Teil erst 
mal zur Seite und überlegt sich am Papier
* wie funktioniert das eigentlich mit den Schaltzeiten
* wie soll sich das ganze dem Benutzer präsentieren
* wie stellt er die Dinge ein (GUI Konzept)

und je nachdem was dann da raus kommt, gehts weiter.

[Felix H. (felix_h55)]

Na gut, am besten ist tatsächlich hoch gegriffen, da gebe ich dir recht.

Ich sitze seit ein paar Tagen hier und versuche seit heute, erstmal auf 
dem Papier ne Uhr zusammenzubauen.

Das ganze erstmal ohne Peripherie, denn ich denke dass mit nem CTC und 
entsprechender Einstellung das alles machbar und ausreichend sein 
sollte.

Die LCD-Ansteuerung hilft mir ja erstmal tatsächlichnur dabei, zu sehen, 
ob es funktioniert. Sprich Register auslesen und Inhalt als Dezimal 
anzeigen lassen - wenn ich das richtig begriffen hab.
Die Register lege ich entsprechend des Tut-Stückes hier an...

Und dann schaunwer mal weiter.

[Karl H. (kbuchegg)]

Felix H. schrieb:

> Ich sitze seit ein paar Tagen hier und versuche seit heute, erstmal auf
> dem Papier ne Uhr zusammenzubauen.

?
Deine ISR wird zum Beispiel 100 mal in der Sekunde aufgerufen.
Nach 100 Aufrufen erfolgt die Weiterschaltung einer Sekunde
Sind 60 Sekunden erreicht, wird 1 Minute weitergeschaltet.
....

Ist jetzt nicht wirklich Raketentechnik :-)

> Das ganze erstmal ohne Peripherie, denn ich denke dass mit nem CTC und
> entsprechender Einstellung das alles machbar und ausreichend sein
> sollte.

CTC ist schon ein gutes Stichwort.

> Die LCD-Ansteuerung hilft mir ja erstmal tatsächlichnur dabei, zu sehen,
> ob es funktioniert.

Tja. Genau darum geht es aber! Woher willst du denn wissen, ob deine Uhr 
funktioniert oder nicht, wenn du keine Anzeigemöglichkeit hast?
Das was du als allererstes sofort abstellen musst, ist das Stochern im 
Nebel. Ohne Anzeigemöglichkeit bist du verloren.

> Sprich Register auslesen und Inhalt als Dezimal
> anzeigen lassen - wenn ich das richtig begriffen hab.
> Die Register lege ich entsprechend des Tut-Stückes hier an...

Schreibst du in Assembler?
Mutig. Nichts gegen Assembler, aber wenn du sowieso nicht so der 
Programmiercrack bist, würde ich das nicht tun. Die ganze 
Relaissteuerung mit Verwaltung und Auswertung der Schaltzeiten wartet 
noch auf dich. Ist natürlich mit Assembler alles machbar (*), aber ein C 
Compiler nimmt dir dann doch schon ein schönes Stück Arbeit ab. Dort 
HAST du einfach ein Array mit den Schaltzeiten und wie und wo das im 
Speicher liegt und wie du auf die 5.te Schaltzeit zugreifst, 
implementiert der Compiler für dich. Du kümmerst dich um die Logik, um 
die lästigen Details, wie zb Zugriffe gestaltet sein müssen, soll sich 
der Compiler kümmern.

(*) wenn man über die notwendige Disziplin verfügt.

[Felix H. (felix_h55)]

Ich habe ja die Anzeigemöglichkeit. Das schrieb ich ja. Falls das anders 
rüberkam, mein Fehler.
LCD ist vorhanden ;) Und wirft auch was aus.

Assembler? Gottimhimmelnein.... :D

In C. Aber so nach dem Motto:

.def
sekunden = r21
minuten = r22
stunden = r23

Ich fand das sinnig. Ist es nicht? :-(

[Karl H. (kbuchegg)]

Felix H. schrieb:
> Ich habe ja die Anzeigemöglichkeit. Das schrieb ich ja. Falls das anders
> rüberkam, mein Fehler.
> LCD ist vorhanden ;) Und wirft auch was aus.
>
> Assembler? Gottimhimmelnein.... :D
>
> In C. Aber so nach dem Motto:
>
>

> .def
> sekunden = r21
> minuten = r22
> stunden = r23
>

>
> Ich fand das sinnig. Ist es nicht? :-(

Äh, nein.
In C brauchst du dich nicht um die Register r00 bis r31 kümmern. Die hat 
der Compiler unter seiner Fuchtel.

In C schreibst du

uint8_t Sekunden;    // Besorg mir Speicher, so dass ich dort einen
                     // 8 Bit Wert unterbringen kann. Wo dieser Speicher
                     // ist, interessiert mich nicht. Mich interessiert
                     // nur, dass du mir ein Byte im Speicher reservierst
                     // und fortan nenne ich dieses Byte 'Sekunden'
uint8_t Minuten;
uint8_t Stunden;

 ....

   Sekunden = Sekunden + 1;     // 1 Sekunde mehr
   if( Sekunden == 60 ) {       // 60 Sekunden erreicht?
     Sekunden = 0;              // Ja -> Sekunden fangen wieder bei 0 an
     Minuten = Minuten + 1;     //       dafür gibts jetzt 1 Minute mehr

     if( Minuten == 60 ) {
       Minuten = 0;
       Stunden = Stunden + 1;

       if( Stunden == 24 ) {
         Stunden = 0;
       }
     }
   }

 ...

und feritig ist die Logik, die das Hochzählen einer Uhr bewerkstelligt, 
wenn dieser Programmteil regelmässig alle 1 Sekunde ausgeführt wird (und 
an dieser STelle kommt dann der Timer mit dem CTC MOdus ins Spiel)

Du schreibst allerdings in Assembler und nicht in einer Hochsprache.

[Felix H. (felix_h55)]

Ups, falscher Zettel.
Man sollte nicht Uniprotokolle und solche Dinge parallel machen.

#define sollte es sein. Das andere war der Versuch, erstmal vollständig 
hinter die Struktur bei dem Tutorial hier zu steigen.

[Felix H. (felix_h55)]

Oh, hab den Code grad erst gesehen.
Danke!