[Glückwunsch !]

Was haltet ihr von dem Programm?

0. Sieht gut aus, rein theoretisch beim Draufschauen fällt mir nichts Grobes auf, käme auf einen Versuch an. Glückwunsch !
Ich nehme mal an, das Poti soll für die Geschwindigkeit sein und kommt an A0

Ansonsten, Kleinkram:

1.Wie sth schon bemerkt hat: Schade, dass

Code:

delay(.01);

keinen Syntaxfehler bringt ...

2. Warum ruft ihr 

Code:

motor.step(1);
motor.setSpeed(RPM);

in dieser Reihenfolge auf ?

3. Für jeden Schritt des Motors eine Ausgabezeile, ist ein bisschen viel für meinen Geschmack.

4. Willst du auch Kommentare zu noch kleinerem Kleinkram ?
      const int forward = 2;
     ...
      boolean f = digitalRead(forward);

n. Du hast keine Code-Tags verwendet

Ansonsten: Wenn das Programm das macht was ihr wollt, ist es gut und wartet auf Verbesserungen.
Wenn es nicht das macht, was ihr wollt, was passiert dann ?

[char code[] = "0300300318";]

Dies habe ich auch hingekriegt, nur das wenn ich mehr als 16 String Array mit 5 10stelligen Zahlen
definiere mir der Arduino in die Knie geht(das nehme ich zumindest an).

Solch einen Verdacht wird dir keiner entkräften... (Vergiss Strings. Wenn du dich dran gewöhnt hast ohne Strings zu leben, ist alles einfacher)

Jetzt möchte ich die Kartennummern in HEX anlegen was mir auch gelungen ist...
Was ich allerdings nicht hinkriege ist die Umwandlung vom String in HEX den mir der Kartenleser ausgibt um danach
die Zahlen vergleichen zu können.  Wie muss ich das anstellen?

Du willst ein char array wie z.B. char code[] = "0300300318"; umwandeln in ein Byte Array,
das in HEX Darstellung so aussieht byte code1[] = { 0x03, 0x00, 0x30, 0x03, 0x18 };

Diese Speicherung ist zwar deutlich kleiner  (5 statt 11 Byte)  aber sonst hast du nicht viel gewonnen. 
Zum Vergleichen brauchst du auch eine Schleife.

Das Umwandeln ist einfach:

Code:

char* cp = code; // oder ausführlicher = & code[0];  // die erste Stelle des char array

for (int i = 0; i < 5; i++)
{
   byte hi = *cp-'0';
   cp++;
   code1[i] = hi*16 + *cp-'0';
   cp++;
}

Kann man kompakter schreiben, sollte so aber klar sein, oder ?

Mal ganz unabhängig von der Frage nach class Objekten ( warum nicht alles static, wennn es sowieso nicht mehrere Instanzen geben kann ?)

Code:

int zaehler = 0;
boolean ver;
while (zaehler != 250000) {
 digitalWrite(MORSE, ver = !ver );
 zaehler++;
}

geht schon irgendwie, leider nicht wie du erwartest:
int hat den Bereich  -32768  .. 32767, und wenn du es nicht speziell als long definierst ist  250000 == 9632
Käme jetzt auf die Umsetzung im Compiler an, welche "Tonhöhe" sich ergibt, und wie lange 9632/2 = 4816 Schwingungen dauern...

Wenn digitalWrite halbwegs ordentlich optimiert ist, sollte mir der Ton eher zu hoch sein, 300 Schwingungen  bei 1000 Hz fände ich angenehmer als
4800 bei 16000 Hz...

Und wie lang bzw. wo ist die Pause nach einem Ton.kurz() ? Damit nicht mehrere kurze zusammen einen langen ergeben ?

[statt]

Klar kann man 1 .. 12   auf 0 .. 11 mappen.

Nur statt der Modulo-Lösung die Uhr auf 12 Stunden-Format stellen, reicht nicht, um ein Ergebnis im Bereich 0 .. 11 zu erhalten.

Oder seine Ansteuerung kann auch 13 Einträge haben, und sowohl 0 als auch 12 könnten die gleiche LED ansteuern.

gilt für Tabelle und die "tausend if" Variante ...

Normalerweise verbindet man den Minus einer Batterie mit GND. Die + 9V sind aber zuviel für den Arduino.

Ich würde den R1 z.B. in einen 470 Ohm und einen 220 Ohm Widerstand aufteilen.
Also 9V Batterie + an 470 an (x) an 220 an LED + und LED - mit Batterie - and GND.
Wenn die LED ca.2V Spannungsabfall hat, teilen sich die restlichen 7 V ca 5 : 2 auf.
An (x) ist dann etwas mehr als 4V, das ist genau richtig für den Arduino.

So wie du es vorher hattest, war das Ganze ohne GND- Verbindung, d.h. mehr eine Antenne für irgendwas.
Sorry, hab ich nicht genau hingeguckt...

Der LED2 fehlt auch ein Vorwiderstand!

Tasten prellen

Du kannst auch den 12 Stunden Modus im DS1307 setzen. (Bit 6 des Registers 02). Dann wirrd Bit 5 des Registers nicht mehr die 2. Binärstelle der Zehner der Stunden sondern das AM/PM bit).

Achtung:
12 Stunden Uhren laufen von 01:00 bis 12:59
Ausserdem kommt nach 11:59 AM erstmal 12:00 PM, nach 12:59 PM kommt 1:00 PM   


( Zumindest echt amerikanische text-basierte Zeitzählung ist nicht einfach modulo 12 )

der braucht aber die gleiche Eingangsspannung wie der Arduino

Nicht ganz richtig:
Ein Optokoppler ist eingangsseitig eine LED, käme also auch mit weniger aus als der Arduino, verträgt aber auch bei entsprechendem Vorwiderstand mehr als der Arduino. Ein Klingeltrafo liefert eigentlich immer genug/zuviel Spannung für den Arduino direkt.

Einen Optokoppler kannst du ausgangsseitig als "Open Collector" direkt an den Input-Pin mit internem Pullup anschliessen.

Die 50 Hz Pulse kannst du auch ausnutzen, um zu zählen, wie lang die Klingel gedrückt wurde. Das vereinfacht die elektrische Seite, und ob du millis() oder 20millis Einheiten benutzt, ist ja praktisch egal.


Das Problem ist eher die zulässige Sperrspannung der Opto-LED --> Die erwähnte Diode (oder eine echte LED, dann sieht man auch was) antiparallel.

_{Nachtrag: s. Bild.}

1. Die ganze Zeile wird erst zum Arduino geschickt, wenn du Enter drückst. Wahlweise mit oder ohne dieses NeueZeile Zeichen.
Allerdings ist selbst 112500 langsamer als der Arduino. Du kannst nie sicher sein, dass alle Zeichen da sind, wenn Serial.available() > 0 liefert.

2. Ja

3. Write sendet einzelne Zeichen und Texte ( also char arrays mit Endekennung oder byte arrays, wenn du die Länge mit angibst )
Print wandelt Zahlen erst in lesbaren Text, kann aber auch - wie write - Texte senden.

println fügt ein NeueZeile Zeichen an, print nicht.
Mit print und write kannst du Ausgaben lückenlos zusammenfügen,das ist manchmal nett, manchmal muss man extra ein Serial.write(' '); einfügen.

Hmm, "jeder" ( ausser Java RxTxComm  ) sollte das können.

VisualStudio .net geht problemlos, z.B. in c#

Code:

using System.IO.Ports;
...
   SerialPort port = new SerialPort("COM8", 250000);
   port.Open();
   ...
   Byte data[]; //
   port.Write(data);
   ...

PureBasic habe auch gelesen, dass beliebige Geschwindigkeiten gehen...

1. multiplexen ist nicht kompliziert ( dein 3x3 geht ja schon )

2. Mit 8 Kathoden und 8 Anoden brauchst du 2 Schieberegister für 64 LED
   Das gleiche für Minuten +  in einem 5. Register 4*4 für die Stunden
   
  Bei der Methode kannst du dir die BitPosition auch ausrechnen, falls dir die Tabelle mit 60 Einträgen unheimlich ist
  Und je 1 LED leuchtet 100%.

oder

3.  Mit 12 x 12 hast du 144 LED in 3 Schieberegistern
     Musst allerdings die 3 LED nacheinander ansteuern.

Statt 132 if solltest du dir vielleicht mal switch () case anschauen, aber Stefans table lookup ist tatsächlich besser,
vor allem da du die Tabelle schon aufgeschrieben hast:

Probier mal sein

Code:

byte seks[9] = {
   0B00111000,   // 0
   0B00110100,   // 1
   0B00101100,   // 2
   0B01011000,   // 3
   0B01010100,   // 4
   0B01001100,   // 5
   0B10011000,   // 6
   0B10010100,   // 7
   0B10001100    // 8
};

mit deinem 3x3 Test und bau ihn dann auf 4x4 für 12 (16) Stunden aus...

RGB Led sind natürlich cooler, aber das wird dann eine andere Uhr

Thanks for that additional info.

I understand for signals in the 100kHz to 1 MHz range I can count pulses, but cannot get their individual pulse/pause lengths.

BTW: What happens if a UART ( more precisely: the UART inside an atmega328 ) does not get the expected stop bit?
Does it simply wait and resync with the next  0000-111-0 and interpret the 1-0 as a new start bit ?

This could give a rough estimate of pulse/pause lengths
or help detect an unknown but rather high asynchronuous baud rate ...

Thanks for your reply.
I see the difference, just have to find the exact difference how the counter is set up for both cases.

The first method (Input Capture) works well for "lower" frequencies or measuring individual pulse widths.

It requires an ISR for every pulse to process the counter value. Has the advantage that the timer value is preserved, compared to a pure ISR on pin change. An ISR takes at least some µs, so it's limited to frequencies of about 50kHz, but giving each single pulse width.

The second method (External Clock Source) works well for "higher" frequencies.

As a minimum an ISR for counter overflow is required, allowing to get the total pulse count as slowly as desired.

If I understand it right, even a prescaler can be applied , if the exact number of pulses is irrelevant ?
Pulses can be as fast as the clock speed ( 16 MHz ) ?

I learned best for counting and fast frequency measuring is usage of Timer/Counters.

Using the 16 bit Timer1 seems appropriate
I think I understand that stuff in general, e.g. setting a proper prescaler and mode in TCCR1A/B

I'm just confused about my findings, which is the proper pin to apply the pulses:
Some tell about
  PB0 = ICP1 = Pin 14 = Arduino D8
Nick Gammon refers to
  PD5 = T1 = Pin 11 = Arduino D5 

Am I mixing different counting/timing modes or do I) mix texts for different controllers  ?

If you can guess where my confusion comes from,
(and perhaps even can help clarify,)
any comment is appreciated.