"keine Änderung" des ADC soll zu Ereignis führen

[Ja (Gast)]

Hallo Freunde, ich stehe vor einem Problem:
Ich habe einen Beschleunigungssensor, den ich mit meinem Atmega8 via ADC 
verbunden habe. Anscheinend sind diese Beschleunigungssensoren nur 
bedingt Beschleunigungssensoren, da sie die Beschleunigung nur relativ 
zur Erdgravitation messen und keine eigentliche Beschleunigung an sich.
Wie auch immer, mein Problem:
Ich möchte, dass wenn es keine Änderung am ADC gibt (Toleranz =< 20, 
wegen Noise), der Wert also bspw. 500 - 520 für eine Minute (interne Uhr 
via Interrupts) beträgt, dass an PortB ein Output Pin aktiviert wird.
Wie vergleiche ich jetzt die Werte (in C) und halte sie fest?
Bitte um ernstgemeinte Hilfe
Danke!

[Kermit (Gast)]

Speichere alten ADC wert, lese neuen ADC Wert =>
Falls gleich (oder +/- 20) => Aktion 1
Falls ungleich (oder +/- 20) => Aktion 2

[Max D. (max_d)]

Das letzte mal als ich nachgesehen hab war jede Beschleunigung relativ.
Ungeachtet dessen: Du liest den ADC so oft wie sinnvoll (hängt stark von 
der Zielsetzung ab) ein und solange der gelesene Wert im Rahmen zählt 
ein Zähler hoch. Wenn der bei einer Minute angekommen ist, dann setzt du 
den Ausgang.
Wenn der Rahmen verlassen wird, dann setzt du den Zähler zurück und 
schiebst den Rahmen hinterher.

[Ja (Gast)]

Ich kann doch theoretisch auch den Referenz-ADC Wert, der keine Änderung 
aufzeigen soll, bei sekunde == 0 immer wieder neu setten oder?

[Max D. (max_d)]

Ja schrieb:
> Ich kann doch theoretisch auch den Referenz-ADC Wert, der keine
> Änderung
> aufzeigen soll, bei sekunde == 0 immer wieder neu setten oder?

Damit ist aber z.B. Nicht abgedeckt wenn von 0:01 bis 1:59 der gleiche 
Wert anliegt (und das obwohl fast 2 Minuten das gleiche anliegt).

[U. M. (oeletronika)]

Hallo,
> Ja schrieb:
> Hallo Freunde, ich stehe vor einem Problem:
> Ich möchte, dass wenn es keine Änderung am ADC gibt (Toleranz =< 20,
> wegen Noise), der Wert also bspw. 500 - 520 für eine Minute (interne Uhr
> via Interrupts) beträgt, dass an PortB ein Output Pin aktiviert wird.
> Wie vergleiche ich jetzt die Werte (in C) und halte sie fest?
ich schlage eine andere Signalverarbeitung vor.
Als erstes führe die rohmesswerte in ein dig. Tiefpassfunktion in der 
Art:
MW_tp = (MW_vorgänger x (TPF-1)+ MW_akt)/TPF  mit TPF = {1....n)

Je höher du die Zahl für TPF wählst, desto weniger rauscht das 
geglättete Signal noch. TPF stellt man dann so ein, dass die 
Ansprechgeschwindigkeit den Anforderungen der Anwendung noch genügt.

Wenn du jetzt Signalverändernungen detektieren willst, so kann man dies 
auch mit solchen Tiefpassfunktionen machen.

Führe 2 solcher Tiefpassfunktionen, eine mit einem hohen TPF und eine 
zweite mit einem eher geringen TPF-Wert.
Die Differenz von beiden zeigt temporäre Änderungen.
Die erst Funktion mit sehr hohem TPF-Wert kompensiert Drift des Sensors.
Gruß Öletronika

[Ja (Gast)]

Max D. schrieb:
> Damit ist aber z.B. Nicht abgedeckt wenn von 0:01 bis 1:59 der gleiche
> Wert anliegt (und das obwohl fast 2 Minuten das gleiche anliegt).

Wäre es dann vielleicht besser das bei jeden Wert, der nicht zwischen/in 
der Toleranz liegt als neuen Wert zu setten?

U. M. schrieb:
> MW_tp = (MW_vorgänger x (TPF-1)+ MW_akt)/TPF  mit TPF = {1....n)

Habe mich in meinem Leben niemals damit beschäftigt, das ist dann doch 
ein wenig zu hoch für mich (leider)..

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Ja schrieb:
> Habe mich in meinem Leben niemals damit beschäftigt, das ist dann doch
> ein wenig zu hoch für mich (leider)..

Falls du es nicht erkannt hast, das ist die normale Mittelwertbildung 
mit N Elementen. Ein simples Beispiel für 2 Elemente wäre:

G_wert = (G_Sensor + G_wert) >> 1;

Da wirst du mit keinem analog/digital Wandler drum herum kommen, denn 
keiner ist so perfekt, das er nicht um wenigstens ein Bit springt.

[Ja (Gast)]

Okay eine Frage noch: wie löse ich diesen Konflikt code-technisch:
Wenn sich Sekunde verändert (also bei jeder Änderung der Sekunde z.B von 
1 auf 2. oder von 59 auf 0) dann soll ein neuer Adc Wert ausgelesen 
werden und gespeichert werden?

[eProfi (Gast)]

> MW_tp = (MW_vorgänger x (TPF-1)+ MW_akt)/TPF  mit TPF = {1....n)

Diese Formel hat den Nachteil, dass das Ergebnis nie den Eingangswert 
erreicht. Daher verwende ich:
ADCsum += ADC - ADCsum / n
mit n = 1, 2, 4, 8, 16, 32 oder 64, damit es als shr ausgeführt werden 
kann. Oder man schreibt es gleich so hin:
ADCsum += ADC - (ADCsum >> m);    //m 1..6 ,  Klammer notwendig!

ADCsum steigt auf das n-fache von ADC an, was ein Vorteil für die 
Weiterverarbeitung (downscaling) sein kann.
bei einem 10bit-ADC reicht für ADCsum ein U16 für n bis 64.

Wenn man den Filter schnell setzen will, reicht ein
ADCsum = ADC << m;


> Wenn sich Sekunde verändert
if (sec != secOld){
  secOld = sec;
  storeData();
  }

Matthias, si tacuisses...
> Falls du es nicht erkannt hast, das ist die normale
> Mittelwertbildung mit N Elementen.
Es ist ein PT1-Glied. Der letzte Wert hat das stärkste Gewicht.

[Bernd K. (prof7bit)]

Max D. schrieb:
> Das letzte mal als ich nachgesehen hab war jede Beschleunigung relativ.

Wo hast Du das gelesen, das ergibt keinen Sinn.

Und die Beschleunigungssensoren die man so üblicherweise verwendet 
messen die absolute Beschleunigung. Und was der Threaderöffner mit 
Formulierungen wie "Beschleunigung nur relativ zur Erdgravitation" oder 
mit "nur bedingt Beschleunigungssensoren" oder "keine eigentliche 
Beschleunigung an sich" zum Ausdruck bringen wollte ist weitgehend 
rätselhaft.

[Ja (Gast)]

Wenn du das Ding an der x-Achse umdrehst, wird, wenn der Vorgang des 
umdrehens abgeschlossen ist, immer noch Beschleunigung (-xg) gemessen 
obwohl der Sensor selbst nicht mehr bewegt (=beschleunigte) wird.

[Bernd K. (prof7bit)]

Ja schrieb:
> Wenn du das Ding an der x-Achse umdrehst, wird, wenn der Vorgang des
> umdrehens abgeschlossen ist, immer noch Beschleunigung (-xg) gemessen
> obwohl der Sensor selbst nicht mehr bewegt (=beschleunigte) wird.

Ja, das ist auch normal, er erfährt ja immer noch die Erdbeschleunigung.

[Ja (Gast)]

Okay danke Leute, ich hab mir jetzt folgendes System überlegt:
Der Adc Wert wird bei jeder Sekundenänderung abgefragt. Also wenn 
Sekunde sich ändert, lese ADC aus und Speicher den Wert als Variable.
Wenn jetzt eine neue Sekunde anbricht, soll der ADC Wert ausgelesen 
werden und mit der Variable (vorheriger Wert) verglichen werden. Wenn 
neuer ADC mehr als +-20 abweicht, wird dieser als neuer ADC Wert 
gespeichert, sodass sich die Referenz sekündlich andert, wenn es so sein 
muss. Wenn der neue Wert nun im Rahmen liegt, so wird ein Zähler 
hochgezählt. Wenn dieser 60 erreicht hat, so setze Output 1.
hab ich da einen logischen Fehler drin?

[NSA (Gast)]

Und was passiert wenn der Zähler auf 30 zählt, sich der wert nun die 
nächsten 5 Minuten kontinuierlich ändert (Zähler zählt nicht) und 
anschließend wieder im Rahmen bleibt, bis der Zähler 60 erreicht hat?

[Ja (Gast)]

Wenn der Zähler schon hochgezählt hat oder auch nicht: wenn neuer ADC 
als Referenz (weil nicht im Rahmen), dann Zähler = 0.

[Udo S. (urschmitt)]

Ja schrieb:
> Wenn du das Ding an der x-Achse umdrehst, wird, wenn der Vorgang des
> umdrehens abgeschlossen ist, immer noch Beschleunigung (-xg) gemessen
> obwohl der Sensor selbst nicht mehr bewegt (=beschleunigte) wird.

Massenanziehung (Gravitation) und Beschleunigung einer Masse sind 
ununterscheidbar.

[Karl H. (kbuchegg)]

Udo Schmitt schrieb:
> Ja schrieb:
>> Wenn du das Ding an der x-Achse umdrehst, wird, wenn der Vorgang des
>> umdrehens abgeschlossen ist, immer noch Beschleunigung (-xg) gemessen
>> obwohl der Sensor selbst nicht mehr bewegt (=beschleunigte) wird.
>
> Massenanziehung (Gravitation) und Beschleunigung einer Masse sind
> ununterscheidbar.

Zumindest solange, solange man nicht aus dem Fenster sehen kann. Etwas 
was Sensoren eher selten können.

[knallbär (Gast)]

Udo Schmitt schrieb:
> Ja schrieb:
>> Wenn du das Ding an der x-Achse umdrehst, wird, wenn der Vorgang des
>> umdrehens abgeschlossen ist, immer noch Beschleunigung (-xg) gemessen
>> obwohl der Sensor selbst nicht mehr bewegt (=beschleunigte) wird.
>
> Massenanziehung (Gravitation) und Beschleunigung einer Masse sind
> ununterscheidbar.

Jedenfalls in der newtonschen Mechanik. Relativistisch schon.

Auch wenn das OT ist:
- Beschleunigung ist definiert durch a = dv/dt
- Erdbeschleunigung ist nur im freien Fall eine Beschleunigung (dv/dt != 
0)
- Erdbeschleunigung beschleunigt eine Masse im freien Fall mit 9,81 
m/(s^2) innerhalb der newtonschen Mechanik. Im allgemeinen 
relativistischen Fall nicht (daher ist es allenfalls eine Hilfsgröße mit 
der sich bequem Gewichtskraft einer Masse innerhalb der newtonschen 
Mechanik berechnen lässt).

[Udo S. (urschmitt)]

knallbär schrieb:
> Jedenfalls in der newtonschen Mechanik. Relativistisch schon.

Wie bitte?

[knallbär (Gast)]

knallbär schrieb:
>> Massenanziehung (Gravitation) und Beschleunigung einer Masse sind
>> ununterscheidbar.

Die Aussage ist natürlich korrekt.
Meine Aussage bezog sich hauptsächlich auf:

Bernd K. schrieb:
> Ja, das ist auch normal, er erfährt ja immer noch die Erdbeschleunigung.

[Udo S. (urschmitt)]

Ok, ich dachte schon jetzt soll ich anfangen über schwaches und starkes 
Äquivalenzprinzip zu argumentieren.
Ist nämlich zu lange her, da bin ich nicht mehr sattelfest :-)

[Ja (Gast)]

Okay......

[Ja (Gast)]

Meine Frage: wie bekomme ich Tolreanz in den Code? Also der ADC Wert 
darf +- vom alten Referenzwert abweichen?

[Cyblord -. (cyblord)]

Ja schrieb:
> Meine Frage: wie bekomme ich Tolreanz in den Code? Also der ADC Wert
> darf +- vom alten Referenzwert abweichen?

Ist das dein Ernst? Weißt du was Subtraktion ist? Danach kannst du deine 
Abweichung ja mit der von dir gewünschten Toleranz vergleichen.

[Karl H. (kbuchegg)]

Voneinander abziehen und wenn das Ergebnis im Bereich -Toleranz bis 
+Toleranz liegt, dann waren auch die Werte nicht weiter voneinander 
entfernt.

(Die Verwendung der abs Funktion kann hier zb ganz hilfreich sein: Wenn 
der Absolutwert der Differenz kleiner als .... )

[Karl H. (kbuchegg)]

Man könnte auch sagen:

Wenn der neue Wert größer als der (Referenzwert minus der Toleranz) ist 
UND der neue Wert kleiner als der (Referenzwert plus der Toleranz) dann 
....


Wie machst du das denn händisch?

Bei einer Toleranz von 5, liegt 18 innerhalb oder ausserhalb der 
Toleranzgrenze, wenn der Referenzwert 20 ist? Wie hast du das 
festgestellt? Was hast du gemacht um zu deiner Aussage zu kommen? Und 
nein: ich hab scharf hingesehen gilt nicht! Du musst schon eine Regel 
angeben, die jeder ABC-Schütze, der gerade mal ein bischen rechnen kann 
anwenden kann.
Wenn du so etwas angeben kannst, dann kannst du es auch programmieren. 
Wenn du es nicht angeben kannst, dann musst du dich eben selbst 
beobachten, wie du so ein Problem löst und davon dann die Regel 
ableiten.

Manchmal (eigentlich ziemlich oft) hilft auch aufmalen.

Hier ist eine Zahlengerade mit den relevanten Markierungen

     13  14  15  16  17  18  19  20  21  22  23  24  25  26  27 
   ---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---

      ^       |           ^       ^                   |
      |       |           |       Referenzwert        |
      |       |           |                           |
      |       |           zu untersuchender Wert      |
      |       |                                       |
      |       |///////////////////////////////////////|
      |       |<-------- 5 ------>|<------- 5 ------->|
      |                   Toleranzbereich
      |
     zu untersuchender Wert

warum ist 18 im Toleranzbereich und 13 nicht? Welche Beziehungen gelten?

[Ja (Gast)]

Kann ich Betragsstriche setzen? Wenn ja wie? Ich meine, wenn der Wert 
vorher kleiner war als der 2., dann kommt da was negatives raus, und das 
kann dann außerhalb der Toleranz liegen und trotzdem akzeptiert werden 
von Code (600-670 =-70; -70<60, also würde Zaehler ++1 gehen, obwohl der 
Messwert eigentlich nicht in der Toleranz liegt..

[Karl H. (kbuchegg)]

Ja schrieb:
> Kann ich Betragsstriche setzen?

Nein.

> Wenn ja wie?

Indem du in deinem C-Buch den Vorrat an mathematischen Funktionen 
nachliest. Wie willst du denn programmieren, wenn du mehr als 80% deiner 
Programmiersprache und der Funktionen, die du zur Verfügung hast gar 
nicht kennst!
Die Funktion heisst abs()

http://www.tutorialspoint.com/c_standard_library/c_function_abs.htm

[Konrad S. (maybee)]

Udo Schmitt schrieb:
> Massenanziehung (Gravitation) und Beschleunigung einer Masse sind
> ununterscheidbar.

Ja, oft gehört und gelesen. Aber:

Betrachte die Vektoren zweier (geeignet) "nebeneinander" liegender 
Punkte. Bei der "Beschleunigung einer Masse" liegen die Vektoren 
parallel zueinander. Bei Gravitation zeigen sie auf einen gemeinsamen 
Punkt (Gravitationszentrum). Bei Zentrifugalkraft zeigen sie von einer 
gemeinsamen Geraden (Drehachse) weg.

[Cyblord -. (cyblord)]

Konrad S. schrieb:
> Bei Zentrifugalkraft zeigen sie von einer

Die Kraft gibt es nicht, das weißt du hoffentlich. Es ist mehr ein 
beobachtbarer Effekt. Keine Kraft. Ähnlich wie die Coreolis-"Kraft".

[Konrad S. (maybee)]

Yep, wollte aber nicht da auch noch Anführungszeichen setzen.

[Cyblord -. (cyblord)]

Konrad S. schrieb:
> Yep, wollte aber nicht da auch noch Anführungszeichen setzen.

Na gut ;-)

[Karl H. (kbuchegg)]

Konrad S. schrieb:
> Udo Schmitt schrieb:
>> Massenanziehung (Gravitation) und Beschleunigung einer Masse sind
>> ununterscheidbar.
>
> Ja, oft gehört und gelesen. Aber:
>
> Betrachte die Vektoren zweier (geeignet) "nebeneinander" liegender
> Punkte. Bei der "Beschleunigung einer Masse" liegen die Vektoren
> parallel zueinander. Bei Gravitation zeigen sie auf einen gemeinsamen
> Punkt (Gravitationszentrum). Bei Zentrifugalkraft zeigen sie von einer
> gemeinsamen Geraden (Drehachse) weg.

Der springende Punkt ist aber, dass ein Beschleunigungssensor immer nur 
die Summe der Beschleunigungen misst und es keinen Weg gibt, alleine nur 
mit dieser Information diese Summe in die einzelnen Komponenten 
aufzudröseln.

[Konrad S. (maybee)]

Karl Heinz schrieb:
> Der springende Punkt ist aber, dass ein Beschleunigungssensor immer nur

... an einem Punkt misst und die Auflösung, erst recht die Genauigkeit, 
bei Weitem nicht ausreichen, um einen praxistauglichen Sensor mit 
vernünftigen Abmessungen zu bauen. Mir ging es nur um die oft behauptete 
Ununterscheidbarkeit von Gravitation vs. Beschleunigung und diese 
Ununterscheidbarkeit gilt eben nur, wenn man nur einen Punkt 
betrachtet.

[Karl H. (kbuchegg)]

Konrad S. schrieb:

> Ununterscheidbarkeit von Gravitation vs. Beschleunigung und diese
> Ununterscheidbarkeit gilt eben nur, wenn man nur einen Punkt
> betrachtet.

... oder man es mit linearen Beschleunigungen zu tun hat.
In rotatorischen Bewegungen gelten wieder andere Regeln. Zumindest wenn 
man etwas über die Geometrie der Bewegung weiss.

[Konrad S. (maybee)]

Karl Heinz schrieb:
> Konrad S. schrieb:
>
>> Ununterscheidbarkeit von Gravitation vs. Beschleunigung und diese
>> Ununterscheidbarkeit gilt eben nur, wenn man nur einen Punkt
>> betrachtet.
>
> ... oder man es mit linearen Beschleunigungen zu tun hat.

Die lineare Beschleunigung ist eben doch von der Gravitation 
unterscheidbar. (Oder habe ich dich jetzt missverstanden?)

[Karl H. (kbuchegg)]

Lass gut sein. Ich will jetzt nicht schon in wieder in diese Diskussion 
rein.
Du kannst das eben. Alle anderen können es nicht.

[Konrad S. (maybee)]

Denk in 'ner ruhigen Stunde noch mal über den Winkel der 
Beschleunigungsvektoren zueinander nach. Sooo schwierig ist das nicht. 
;-)

[Karl H. (kbuchegg)]

Konrad S. schrieb:
> Denk in 'ner ruhigen Stunde noch mal über den Winkel der
> Beschleunigungsvektoren zueinander nach. Sooo schwierig ist das nicht.
> ;-)

Ich denke eher schon, dass es ziemlich schwierig ist, in einem 
Kräfteparallelogramm nur mit der Kentniss der Resultierenden und einer 
Seitenlänge und ohne einen Winkel zu kennen, das Parallelogramm im 
allgemeinen Fall eindeutig zu rekonstruieren. Immerhin ist das der 
Versuch, ein Dreieck mit nur 2 Bestimmungsstücken zu konstruieren.

PS: wir reden hier von einer beliebigen Orientierung des Sensors in 
Bezug auf die Gravitationsrichtung. Hab ich diese Orientierung, dann ist 
die Sache leicht. Hab ich sie nicht, dann kann ich sie nur mit den Daten 
des Beschleunigungssensors nicht nicht ermitteln.

[Willi M. (lt1014)]

Hallo,
ich hab sowas ähnliches mal mit Hilfe der einfachen linearen Regression 
gelöst:
- Werte in array einlesen
- Regressionsgerade berechnen
- die Steigung dieser Geraden mit Schwelle vergleichen
Gruß
Willi

[Konrad S. (maybee)]

Kleine Skizze zur Veranschaulichung.
Ich spreche davon, dass man die Beschleunigung an zwei geeignet 
gewählten Punkten misst. In der Skizze hält das Männeken also in jeder 
Hand einen "Beschleunigungssensor". Und durch Betrachtung der Lage der 
Vektoren zueinander lassen sich die drei Fälle - Gravitation, lineare 
Bescchleunigung, "Zentrifugalkraft" - voneinander unterscheiden. Bis 
eben auf die kleine Einschränkung, dass real existierende Sensoren dafür 
nicht ausreichen dürften (OK, das mit der Zentrifuge würde noch 
klappen).

[Ja (Gast)]

Letzte Frage: ich habe Sekunden als Variablen im Timer. Wie schaff ich 
folgendes umzusetzen im c-Code:
Wenn Sekunde sich ändert, read ADC.
Also der Term "wenn Sekunde sich ändert"
Danke

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Lies gefälligst ein gutes Buch über C und verstehe dessen Inhalt. Lies 
ggf. noch Bücher über Algorithmen und Softwareentwicklung.

[Ja (Gast)]

Ich frage so nach einem Term was los

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Solch einen Ausdruck selbst zu formulieren ist eine Kleinigkeit, sobald 
Du die Grundlagen der Programmiersprache verstanden hast. Du besitzt 
jedoch keinerlei Grundlagen. Das musst Du nachholen.

[Karl H. (kbuchegg)]

Ja schrieb:
> Letzte Frage: ich habe Sekunden als Variablen im Timer. Wie schaff ich
> folgendes umzusetzen im c-Code:
> Wenn Sekunde sich ändert, read ADC.
> Also der Term "wenn Sekunde sich ändert"


Wie würdest DU das denn machen, wenn DU vor der Aufgabe stehst (und ein 
schlechtes Gedächtnis hast aber sauschnell bist)?

Also ich würde:
* mir Papier und Bleistift nehmen um mir was notieren zu können 
(Hinweis: sowas ist immer ein Hinweis darauf, dass man eine Variable 
braucht)

* dann würde ich zuerst mal auf meine Uhr sehen und mir die aktuelle 
Sekunde notieren. Die ist zb jetzt gerade 23

* in meiner laufenden Aktion würde ich immer wieder auf die Uhr sehen, 
die Sekunden ablesen und mit dem vergleichen, was auf dem Papier steht. 
Da ich sauschnell bin, lese ich von der Uhr zb ab: 23
Auf meinem Papier steht auch 23, also hat sich die Sekunde nicht 
verändert. Es ist immer noch dieselbe Sekunde.

* ich mach ein bischen was anderes und schau dann wieder auf die Uhr. 
Ich lese ab: 24
Ein Blick auf mein Papier zeigt mir, dass die 23, die dort stehen nicht 
identisch sind zu den 24 die ich jetzt gerade abgelesen habe. Bingo! Die 
Sekunden haben sich offenbar verändert!
Also mach ich mein Ding, das ich jede Sekunde machen möchte und notiere 
mir auf dem Papier: 24

* nach kurzer Zeit schau ich wieder auf die Uhr und lese ab: 24
Ein Blick auf das Papier zeigt mir: 24. Die aktuelle Sekunde stimmt mit 
der notierten überein. D.h. seitdem ich das letzte mal die 
Sekundenaktion gemacht habe, ist nocht keine Sekunde vergangen.


und so geht das immer weiter dahin. Uhr ablesen und mit dem vergleichen, 
was auf dem Papier steht. Stimmen die beiden Zahlen überein, dann hat 
sich offenbar die Sekunde nicht verändert. Stimmen sie nicht überein, 
dann hat eine neue Sekunde begonnen, ich mach mein Dinge und notiere mir 
diese neue Sekundenzahl, damit ich bei der nächsten Ablesung wieder 
weiss, wann ich das letzte mal mein Ding gemacht habe.


Eigentlich ganz simpel. Selbst Kleinkinder können diese Strategie 
intuitiv anwenden.


Eine Veränderung festzustellen bedeutet IMMER, dass man sich irgendwo 
einen früheren Zustand merken muss. Ob sich das Bild einer Stadt im 
Laufe der Zeit verändert, kannst du nur feststellen, wenn du das heutige 
Bild mit einem Photo von früher vergleichst. Hier ist das Photo von 
früher genau das, was bei mir Papier und Bleistift war. Aber egal wie: 
um das Festhalten des aktuellen Zustands, damit man in der Zukunft mal 
mit diesem Zustand vergleichen kann, kommt man nicht rum. Das folgt 
schon daraus, dass man als Mann auf die Frage seiner besseren Hälfte 
"Schatz, fällt dir an mit irgendeine Veränderung auf" besser die 
Haarfarbe von gestern noch im Gedächtnis parat hat. Gedächtnis ist das, 
was man in einer Programmiersprache eine Variable nennt. Stellt man also 
für 'Haarfarbe_Frau' keine Gedächtnis Speicherzellen ab, dann hängt sehr 
bald der Haussegen schief, weil man dann eben eine entsprechende 
Veränderung nicht feststellen kann.

   Haarfarbe_Frau = Frau ansehen;

   while( laufend ) {

     Haarfarbe_jetzt = Frau ansehen;

     if( Haarfarbe_jetzt != Haarfarbe_Frau ) {
       Kompliment machen;
       Haarfarbe_Frau = Haarfarbe_jetzt;
     }

   }

Wobei das bei Frauen trickreich werden kann und die Frage als Fangfrage 
qualifiziert werden muss. War sie nicht beim Frisör und hat sich statt 
dessen ein neues Kleid gekauft, dann hängt nach einem Kompliment über 
die vermeintlich neue Haarfarbe erst recht der Haussegen schief. Aber 
das ist dann eine andere Geschichte und das zu vermeiden erfordert 
wieder andere Variablen, in denen man sich Dinge merken muss.

[Ja (Gast)]

volatile unsigned int sekunde;
volatile unsigned int sekundeCOM;
volatile unsigned int sekundeCOM2;

int main(void)
{
  sekundeCOM = sekunde }

while(1)
  {
    sekundeCOM2 = sekunde;
    if (sekundeCOM2 != sekundeCOM)
    {
      sekundeCOM = sekundeCOM2;
    
    } }
[....]

ISR(TIMER1_COMPA_vect)
{
  millisekunden++;
  if(millisekunden == 1000)
  {
    sekunde++;
    millisekunden = 0;
    if(sekunde == 60)
    {
      minute++;
      sekunde = 0;
    }
    if(minute == 60)
    {
      stunde++;
      minute = 0;
    }
    if(stunde == 24)
    {
      stunde = 0;
    }
  }
}

 ?

[Paul B. (paul_baumann)]

@Karl-Heinz

Wenn Du kein Ausbilder und/oder Lehrer bist, dann hättest Du es werden
sollen, ja eigentlich werden müssen. Ich habe noch Keinen gesehen, der 
so anschaulich erklären konnte.

(Das mußte ich mal sagen und nein: Das ist keine Schleimerei, das ist 
mein
Ernst)

MfG Paul

[Karl H. (kbuchegg)]

Ja schrieb:

> ?

Haus in ein neues Projekt rein, schliess den Timer an, mach eine 
triviale Operation wenn sich die Sekunden verändert haben, zum Beispiel 
eine LED am Ausgang umschalten und wenn die LED im Sekundentakt blinkt, 
weisst du das alles in Ordnung ist.

Mehr Mut zum Risiko. Und mehr Mut auch mal ein Testprojekt zwischen zu 
schieben um eine bestimmte Technik zu testen. Mehr als das es nicht 
funktioniert kann dir nicht passieren! So lernt man. Wenn du dir hier 
jede 3 Zeilen Code absegnen lässt, lernst du genau gar nichts. Das 
Verfahren ist bekannt und es in Code zu giessen ist nicht schwer. Also: 
hau rein.

Man muss nicht alles gleich ins endgültige Projekt einbauen, wo es mglw. 
noch 200 andere Sachen geben kann, die schief gehen. Man kann ruhig für 
ein Detailproblem mal ein eigenes Projekt eröffnen, in dem man sich 
intensiv mit einer neuen Technik auseinandersetzt und die getrennt von 
der großen Aufgabenstellung durchtestet. Mit den heutigen IDEs dauert 
das generieren eines neuen Projektes keine 20 Sekunden. Das geht 
schneller, als du hier deine Frage posten kannst.

[Ja (Gast)]

Okay, danke! Echt vielen dank! Hast mir sehr geholfen, aber eine Frage 
hätte ich da noch: ich scheine immer das selbe falsch zu machen.
Hier Fehlermeldung +
hier der Code:

#define F_CPU 1000000UL     /* 1MHz */
 
#include <avr/io.h>
#include <util/delay.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>

 
 //Variablen für die Zeit
 volatile unsigned int millisekunden;
 volatile unsigned int sekunde;
 volatile unsigned int minute;
 volatile unsigned int stunde;

 

// Defines:
#define LED1    (1<<PD5)
#define LED2    (1<<PD6)
 
 // Timer 1 konfigurieren
 TCCR1B = (1<<WGM12);  // CTC Modus
 TCCR1B |= (1<<CS11); // Prescaler 8
 // ((1000000/8)/1000) = 125
 OCR1A = 125-1;
 
 // Compare Interrupt erlauben
 // Compare Interrupt erlauben
 TIMSK = (1<<OCIE1A);
 
 // Global Interrupts aktivieren
 sei();
 
int main()
{
  // LED-Pins als Ausgang definieren
  DDRD |= LED1 | LED2;
 
 
  while(1)
  {
    if (sekunde == 5)
    { 
    
    PORTD ^= LED1 | LED2;
    _delay_ms(200);
 
  
    }    
  }
}
 


ISR(TIMER1_COMPA_vect)
{
  millisekunden++;
  if(millisekunden == 1000)
  {
    sekunde++;
    millisekunden = 0;
    if(sekunde == 60)
    {
      minute++;
      sekunde = 0;
    }
    if(minute == 60)
    {
      stunde++;
      minute = 0;
    }
    if(stunde == 24)
    {
      stunde = 0;
    }
  }
}

Muss ich vor volatile noch etwas schreiben oder wie?

[Karl H. (kbuchegg)]

.....

// Defines:
#define LED1    (1<<PD5)
#define LED2    (1<<PD6)
 
 // Timer 1 konfigurieren
 TCCR1B = (1<<WGM12);  // CTC Modus
 TCCR1B |= (1<<CS11); // Prescaler 8
 // ((1000000/8)/1000) = 125
 OCR1A = 125-1;

....

Ähm.
In C sind ausführbare Anweisungen nur innerhalb von Funktionen erlaubt.
OK, ich geb zu die Fehlermeldungen sind etwas missverständlich. Dazu 
müsstest du die Definition von TCCR1B kennen um die zu verstehen. Tut 
hier nichts zur Sache, denn: ausführbare Anweisungen gehören in 
Funktionen.

(Du hast dich hier zu sehr vom Stichwort 'volatile' leiten lassen. Du 
musst mehr auf die Zeilennummern achten! Bringt dich denn ein 
Doppelklick auf die Fehlermeldung nicht zur bewussten Stelle mit dem 
Fehler? Sie ist zwar auch manchmal falsch, aber zumindest hättest du 
gesehen, dass deine volatile von der problematischen Stelle weit 
entfernt sind und sehr wahrscheinlich daher nichts damit zu tun haben)

[Ja (Gast)]

Karl Heinz schrieb:
> Ähm.
> In C sind ausführbare Anweisungen nur innerhalb von Funktionen erlaubt.
> OK, ich geb zu die Fehlermeldungen sind etwas missverständlich. Dazu
> müsstest du die Definition von TCCR1B kennen um die zu verstehen. Tut
> hier nichts zur Sache, denn: ausführbare Anweisungen gehören in
> Funktionen.

Gut zu wissen, vielen Dank!

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Ja schrieb:
> Gut zu wissen, vielen Dank!

Diese Information hättest Du beim sorgfältigen Durcharbeiten jedes 
ordentlichen Lehrbuches von selbst erhalten.

[Ratgeber (Gast)]

Andreas Schweigstill schrieb:
> Diese Information hättest Du beim sorgfältigen Durcharbeiten jedes
> ordentlichen Lehrbuches von selbst erhalten.

Andreas Schweigstill schrieb:
> Lies gefälligst ein gutes Buch über C und verstehe dessen Inhalt. Lies
> ggf. noch Bücher über Algorithmen und Softwareentwicklung.

Andreas Schweigstill schrieb:
> Solch einen Ausdruck selbst zu formulieren ist eine Kleinigkeit, sobald
> Du die Grundlagen der Programmiersprache verstanden hast. Du besitzt
> jedoch keinerlei Grundlagen. Das musst Du nachholen.


Kannst Du bitte, bitte mal die Griffel von der Tastatur lassen, wenn Du 
nichts, aber auch gar nichts als diese ewige Lehrbuchplatte abzuspielen 
hast?

Danke.

[Karl H. (kbuchegg)]

Ratgeber schrieb:

> Kannst Du bitte, bitte mal die Griffel von der Tastatur lassen, wenn Du
> nichts, aber auch gar nichts als diese ewige Lehrbuchplatte abzuspielen
> hast?

Er hat allerdings recht.

Manche brauchen eben immer wieder einen Arschtritt, bis sie endlich 
begreifen, dass eine Programmiersprache zu erlernen etwas anderes ist 
als Briefmarkensammeln, bei dem man halt einfach mal anfängt und es wird 
schon irgendwie gehen. 2 Youtube Videos und 3 Webseiten (natürlich die 
mit nicht zu viel erklärendem Text, dann man will ja schliesslich nicht 
auch noch lesen) reichen eben nicht um wenigstens die einfachsten 
Grundlagen zu schaffen.

[Ratgeber (Gast)]

Karl Heinz schrieb:
> Er hat allerdings recht.

Nein, ER hat kein Recht -insbesondere deshalb nicht weil er im Gegensatz
zu Dir keine Hilfestellung und keinen nützlichen Rat parat hat, sondern
immer nur das Gleiche stupide wiederholt. Ich beobachte dieses Verhalten
schon eine ganze Weile, nicht erst in diesem Beitrag. Nun war der Punkt
erreicht, etwas dazu zu sagen.

[Ja (Gast)]

Okay, ich befürchte zwar zerfetzt zu werden, aber vielleicht kriege ich 
ja doch eine Antwort: ein Delay-Befehl also _delay_ms(200ms) zum 
Beispiel:
Verzögert dieser in einer Whileschleife den kompletten Ablauf oder wird, 
wenn dieser Befehl z.B. in einem if-Statement ausgeführt wird, nur die 
if-Zeile verzögert und der Rest läuft weiter so schnell ab?
Danke

[Bernd K. (prof7bit)]

Ja schrieb:
> Verzögert dieser in einer Whileschleife den kompletten Ablauf

Ja. Zumindest erstmal in erster Näherung (siehe unten)

> oder wird,
> wenn dieser Befehl z.B. in einem if-Statement ausgeführt wird, nur die
> if-Zeile verzögert und der Rest läuft weiter so schnell ab?
> Danke

Nein. Es gibt nur einen Punkt an dem Du Dich im Ablauf des Programmes 
befindest, wenns an dem Punkt nicht weiter geht dann hängts dort.

Wie eine Person beim Einkaufen die sequentiell den Einkaufszettel 
abarbeitet, wenn das Finden der Erdbeeren in der riesigen Obst und 
Gemüseabteilung 2 Minuten dauert dann kann sie nicht gleichzeitig noch 
den Punkt "wenn frische Erdbeeren da sind dann bring auch Schlagsahne 
mit" gleichzeitig abarbeiten. Das geht nicht. Erst die Erdbeeren, dann 
die Sahne.

Das geht nur wenn die Person zu zweit ist (Threads oder Interrupts). 
Aber auch die können sich gegenseitig blockieren und auch die sind nicht 
wirklich gleichzeitig (zumindest nicht auf Ein-Kern-CPUs) aber sie 
helfen zumindest indem man beim Nachdenken über das Problem und dem 
Schreiben des Programms zumindest aus logischer Sicht einfach so tun 
kann als würde man zwei separate Programme für zwei CPUs schreiben, das 
kann so manches komplexe Problem elegant entknoten, kann aber auch 
ungewünschte Seiteneffekte haben die man beachten muss wenn beide 
gelegentlich auf die selben Daten zugreifen sollen.