Pages: [1] 2   Go Down
Author Topic: Wie geht ihr ans Code schreiben ran?  (Read 924 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Full Member
***
Karma: 11
Posts: 149
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Hallo zusammen, ich würde gern Wissen, wie ihr euch vorbereitet beim Code schreiben.
Ich sitze vorm Rechner und weiß nicht so recht wie ich anfangen soll. Welche funktionien zuerst oder ist die Reihenfolge richtig, habe ich noch was vergessen. usw.
Wie fangt ihr mit sowas an, erstellt ihr erst auf dem Papier einen kleinen Code oder fangt ihr gleich am Rechner an oder macht ihr erst ein Flussdiagramm?  Wie gehts bei euch los?
Vielleicht könnt ihr mir ein paar Tipp´s geben?  smiley-grin
Ich habe schon ein paar sketche geschreiben und  auch mehrere Bücher gelesen aber ich tue mich immer recht schwer am Anfang.  smiley-cry

MfG  Marco
Logged

Münsterland
Offline Offline
Faraday Member
**
Karma: 48
Posts: 2832
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Direkt am PC schreiben finde ich als schlechteste Lösung. Auch wenn man alles editieren kann etc.
Ich für meinen Teil zeichne mir zuerst auf, wie der Ablauf in etwa von statten gehen soll. Ich glaub den Namen "Flussdiagram", bzw. PAP (Programmablaufplan) haben meine Skizzen aber nicht verdient. Die müsste man erst nach der Chaosregel zertifizieren.

Code schreibe ich nicht auf Papier. Lediglich PseudoCode und entsprechend vereinfachte Arraytabellen.



Logged

Gruß Stefan

Keine Code-Anfrage über die Persönlichen Nachrichten.

Offline Offline
God Member
*****
Karma: 11
Posts: 599
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Karopapier kann (!) helfen.

Letzten Endes muss aber jeder für sich entscheiden, welchen Weg er bei welcher Aufgabenstellung einschlägt.

"Ob mein Gott.. dass ich mal so einen spießigen Satz schreibe.. ich werd glaub so langsam echt alt."  smiley-razz

Gruß Chris
Logged


Münsterland
Offline Offline
Faraday Member
**
Karma: 48
Posts: 2832
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Karopapier kann (!) helfen.
Viel zu teuer smiley-razz Da nehm ich lieber Briefumschläge o.ä.. Die müssen sowie so in den Müll ^^
Logged

Gruß Stefan

Keine Code-Anfrage über die Persönlichen Nachrichten.

Offline Offline
Faraday Member
**
Karma: 128
Posts: 4124
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

So einfache Sachen kann ich im Kopf zusammenstellen und Visualisieren. Ich denke also etwas nach und dann programmiere ich.
Auf Papier Code zu schreiben hasse ich. Klassen- oder Fluss-Diagramme kann man natürlich machen wenn einem das hilft.

Bei bestimmen Algorithmen und Arrays nehme ich aber auch öfters Papier zu Hand.
Oder eventuell um kompliziertere Koordinaten auf einem TFT zu berechnen. Da musste ich ein normales kartesisches Koordinatensystem auf Display-Koordinaten umsetzen. Das hat dann mein Gehirn doch etwas überfordert smiley
Logged

Germany S-H
Offline Offline
Faraday Member
**
Karma: 168
Posts: 3203
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Wie fangt ihr mit sowas an, erstellt ihr erst auf dem Papier einen kleinen Code oder fangt ihr gleich am Rechner an oder macht ihr erst ein Flussdiagramm?  Wie gehts bei euch los?

Also ich setze mich (üblicherweise) gleich an den Rechner und schreibe nichts auf Papier vor.
Das erste am Programm ist (fast immer) ein "Serial.begin(9600)" in die setup-Funktion zu schreiben, für serielle Debug-Ausgaben.

Und dann versuche ich, das Programm ganz klassisch nach dem EVA-Prinzip in drei Teile aufzuteilen:
E - Eingabe
V - Verarbeitung
A - Ausgabe

Grobes Grundgerüst für ein Programm, bei dem ständig neue Daten eingehen und verarbeitet werden:
Code:
void setup() {               
  Serial.begin(9600);
  Serial.println("Start");
}

void eingabe() {};
void verarbeitung() {};
void ausgabe() {};


void loop() {
  eingabe();
  verarbeitung();
  ausgabe();
}

Oder für ein Programm, das nur arbeiten soll, wenn neue Daten eingegeben werden:
Code:
void setup() {               
  Serial.begin(9600);
  Serial.println("Start");
}

boolean eingabe() {return true;};
void verarbeitung() {};
void ausgabe() {};


void loop() {
  if (eingabe())
  {
    verarbeitung();
    ausgabe();
  }
}

Zum Bereich "Eingabe" gehört, sich eine für das Programm angemessene Datenstruktur zu überlegen für die Daten, mit denen dann gearbeitet werden soll. Im Bereich "Eingabe" werden die Daten dann initialisiert oder eingelesen oder bei interaktiven Programmen die Bedienelemente (Buttons, Drehgeber, Potis, Sensoren) abgefragt.

Zum Bereich "Verarbeitung" gehört es dann, die in die Datenstruktur eingelesenen Werte zu verarbeiten, Berechnungen durchzuführen und die Ausgabe vorzubereiten, z.B. die auszugebenden Daten in eine vorbereitete Ausgabedatenstruktur zu übergeben.

Und zum Bereich "Ausgabe" gehört es dann schließlich, die Daten auszugeben, auf eine serielle Schnittstelle, auf ein LCD-Display, LEDs ein- und auszuschalten oder blinken zu lassen, eine Datei auf SD-Karte zu erzeugen, die Daten per Funk zu versenden oder sie in eine HTML-Webseite zu leiten.

Die Funktionen heißen zwar nicht unbedingt Eingabe(), Verarbeitung() und Ausgabe(), aber so ist die modulare Aufteilung. Und wegen der Trennung in diese verschiedenen Teilaufgaben ist es auch relativ einfach möglich, die Arbeitsweise eines Moduls jederzeit auszutauschen.

Durch die modulare Aufteilung ist es möglich, dass eine Eingabefunktion, die später vielleicht seine Daten von einem Temperatursensor erhält,  dann ganz im Anfang nur so aussieht:
Code:
long readTemperature() // Temperatur in Zehntelgrad auslesen
{
   return 213;
}
Oder eine Funktion, die die Daten am Ende auf einem LCD ausgeben soll so:
Code:
long showTemperature(long temp) // Ausgabe auf LCD
// Parameter temp in Zehntelgrad
{
   Serial.print(temp/10);Serial.print(".");Serial.println(temp%10);
}
So dass vielleicht weder die Eingabe gleich zu Anfang so funktioniert wie es am Ende sein soll, noch die Ausgabe, sondern dass diese Funktionen am Anfang mehr oder weniger nur "simuliert" werden. Von einem ganz simpel hingeschriebenen Programmgerüst. Und dann im Rahmen einer "schrittweisen Verfeinerung" des Programms tatsächlich erst schrittweise  entwickelt wird, mit allem drum und dran.
Logged

Forum Moderator
BZ (I)
Offline Offline
Brattain Member
*****
Karma: 271
Posts: 21869
+39 349 2158303
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Das Problem in kleine Teile unterteilen.
zB jeden Teil des Projekts einzel ansteuern und dann langsam langsam zum Startteil die anderen hinzufügen. So kann man ohne größere Probleme Fehler relativ einfach eingrenzen.
zB
1) Display Ansteuerung
2) Eingabe
3) Datenverarbeitung
4) Leistungsteil ansteuern
5) ecc

Grüße Uwe
Logged

Offline Offline
Newbie
*
Karma: 0
Posts: 29
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Etwas was mir schon oft geholfen hat Chaos zu vermeiden, ist fast jede schliessende geschweifte Klammer zu kommentieren:

void loop() {

} //loop

So weiss ich ich immer welche zusammen gehören.

Karoblock und Kugelschreiber gehört fest auf den Schreibtisch, denn es ist ja nicht nur Programmcode, sondern auch Bauteile die gebraucht werden, da ist es sehr hilfreich schnell zu skizzieren welche Funktion die Beinchen haben und welches Pin 1 ist.
Logged

Münsterland
Offline Offline
Faraday Member
**
Karma: 48
Posts: 2832
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

void loop() {

} //loop
Das sollte doch eigentlich aus der Formatierung hervorgehen smiley-wink Wobei die Arduino Formatierung nicht gerade viele Leerzeichen/Tabs einsetzt.
Logged

Gruß Stefan

Keine Code-Anfrage über die Persönlichen Nachrichten.

Witten an der Ruhr
Offline Offline
God Member
*****
Karma: 7
Posts: 757
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

ich schreibe meine Sketche auch sofort am PC, Habe meist eine Idee die ich verwirklichen möcht und setze das dann am PC um. Was mir hilft, ist , das ich mir mehrere Ordner angelegt habe  für fertige Code, für Code in Arbeit , der ist für Code wo ich noch was dran verbessern möchte aber im Moment nicht die Lust oder Nerven habe und einen Ordner für Updates, worin ich den code den ich bearbeite mehrfach ablege. z,B. Lauflicht, Lauflicht1 und Lauflicht2.  Da ich nicht so wahnsinnig firm bin beim Programmieren, kommt es schon einmal vor das ich in meinem Eifer, beim Programmieren nicht sofort die richtige Lösung habe und der Sketch dann nicht so abläuft wie ich es mir vorstelle. Dann habe ich immer die Möglichkeit auf das Update zurück zu greifen und muss nicht immer löschen, neu beginnen  u.s.w. habe dann immer den teil zur Hand der schon läuft. Ansonsten ist es wohl wie bei allen Anderen auch, Da ja vorgegeben ist wo die Initialisierung, die Anweisung und die Ausführung hin gehört. Was ich mir angewöhnt habe ist, viel mit Funktionen zu arbeiten und lauffähige auch zu speichern so das ich nicht immer ds Rad neu erfinden muß, da ich dabei besser die Übersicht behalte. Papier brauche ich meist nur um mein Gedächniss zu unterstützen , für Arrays und solche Sachen wie für die Fernbedienungen die Hex Zahlen auf zu schreiben oder mir eine vorläufige Zeichnung an zu legen für das teil was ich gerade zusammen baue.
Logged

l.G.Jürgen

Verzeihe Deinen Feinden, aber vergesse nie Ihren Namen.

Dresden
Offline Offline
God Member
*****
Karma: 13
Posts: 820
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Ich tippe auch direkt drauflos.
Wobei ich es da halte, wie Uwe: klein anfangen, das Problem in mehrere Teile zerlegen und die dann nach und nach zusammensetzen.
So merkt man recht schnell, wenn man irgendwo Mist gebaut hat.
Als Hilfsmittel hab ich natürlich auch meinen Schmierzettel hier liegen, brauch ihn aber relativ selten- viel wichtiger ist nen Taschenrechner (der von Windows tuts da) der auch bin und hex kann.
Ablaufpläne sind was tolles, aber ich hab noch kein gratis-Programm gefunden, wo man sowas mal eben schnell erledigen kann, das, was mir da bisher so in die Finger kam war mir zu mühselig, da lasse ichs lieber.
Dafür teile ich meine Programme fast immer komplett auf: in der Hauptschleife steht meist nicht viel mehr als Unterprogramm-Aufrufe, und nen paar Entscheidungen.
Und: jede Menge Kommentare- ich kommentiere wohl ca. jede 5.Zeile.
Unterprogramme werden markiert:

void macheSonstwas() //************************* Sonstwas ******************************
{
}
void macheWasAnderes()//********************** mache was anderes *********************
{
}

So find ich schnell, was ich brauche. Kann man bestimmt auch mit Tabs machen, aber das ist mir irgendwie zu- weiss nicht, mags nicht.
Obendrein nutze ich die serielle Konsole relativ oft  beim programmieren, da kann man fein nachgucken, was denn der Sensor nun wieder redet...

Ab und zu schreib ich mir zwischendurch kleine Testprogramme, beispielsweise, um mal schnell zu gucken, bei welchem PWM-Wert denn der Motor nun überhaupt anläuft usw.
Oft aber tu ich sowas auch direkt im eigentlichen Programm, da ich ja eh fast jede Funktion einzeln im Hauptprogramm aufrufe, kann man die auch schnell mal auskommentieren.
Logged

------------
Grüssle, Sly

Offline Offline
Edison Member
*
Karma: 21
Posts: 1419
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Wie bereits von einigen geschrieben ist es immer gut, das Projekt in Teilaufgaben zu zerlegen, die man unabhängig voneinander bearbeiten kann. Es ist immer gut, sich die einzelnen Aufgaben aufzuschreiben, damit man nix vergisst.
Bewährt hat sich dabei auch, möglichst nicht nur ein konkretes Problem zu lösen, sonder gleich eine ganze Problemklasse. Z.B. ich muss einen String in unterschiedliche Teile zerlegen und z.B. Zahlenwerte daraus extrahieren.
Auch hier geht man wieder Schrittweise vor. Zuerst versucht man das konkrete Problem zu lösen. Wenn das klappt, überlegt man, wie man die Lösung so verallgemeinern kann, das man sie später wiederverwenden kann.
Beim String zerlegen wäre es z.b. denkbar das man das Trennzeichen variabel gestaltet oder das man Integer, float und Substrings extrahieren kann, obwohl man für die konkrete Aufgabe erstmal nur eines davon benötigt.
Das spart später Zeit, wenn man das nochmal benötigt.

Man schafft sich somit nach und nach ein praktisches Repository an Hilfsfunktionen, ähnlich wie die Libraries der IDE. Es lohnt sich natürlich immer auch mal zu schauen ob jemand anderes schon eine Lösung gebaut hat, die man verwenden kann.

Bei größeren Projekten gibt es allgemein zwei Herangehensweisen.

Zum Einen Bottom-Up und zum Anderen Top-Down: (http://de.wikipedia.org/wiki/Top-down_und_Bottom-up)

Beim Bottom-Up zerlegt man alles in kleine Häppchen und fängt bei den Basis-Funktionen / Funktionalitäten an. Aus diesen baut man dann immer komplexere Dinge (wie beim Lego), bis man am Ende das gewünschte Programm hat.

Beim Top-Down fängt man von "Oben" an. Man baut das "Hauptprogramm" und überlegt sich, welche Funktion würde ich jetzt aufrufen, um eine bestimmte Funktion umzusetzen. Diese "top-level" Funktion schreibt man dann. Diese Funktion wird wiederum andere Funktionen brauchen, da man ja auch bei diesem Ansatz das Problem in kleinere Aufgaben zerlegt. Wenn es zu viele Funktionen auf einmal werden die man schreiben müßte, kann man mit sogenannten "Stubs" arbeiten. Dabei definiere ich eine Funktion mit ihrem Namen, den Parametern und dem Rückgabewert, programmiere die Funktion aber noch nicht aus, sondern lasse sie erstmal nur einen "dummy"-Wert (Test-Wert) zurückliefern, damit ich die übergeordneten Funktionen und Abläufe testen kann. Wenn die eine Ebene soweit funktioniert, dann fülle ich die darunter liegende Ebene von Funktionen mit "Leben". So hangelt man sich von Oben nach unten durch (Top-Down) und hat trotzdem immer ein funktionierendes Programm, das man testen kann.

Welche Methode für ein Projekt besser geeignet ist, hängt stark von den persönlichen Vorlieben und der Erfahrung ab.

Mario.
Logged

Germany
Offline Offline
Faraday Member
**
Karma: 59
Posts: 3071
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Quote
... hat trotzdem immer ein funktionierendes Programm, das man testen kann.
Das ist für meinen Geschmack das Wichtigste: Anstelle erst mal drauflos zu schreiben und nach einer Woche zu hoffen, dass alles läuft, "immer" das jeweils geschriebene gleich compilieren und testen.
Dadurch ergibt sich oft eine Kombination aus TopDown und BottomUp:
Z.B.
Erstmal eine Einzelfunktion, bei der man noch erforschen muss wie es geht, in einer Testumgebung ( Bottom Up )
Dann den Gesamt-Rahmen mit funktionslosen Prototypen und der schon erforschten Einzelfunktion ( Top Down )
Dann eins nach dem anderen die Dummy-Funktionen mit Leben füllen.
Und immer gleich testen.
Bei unerklärlichen Problemen ist evtl. wieder eine separate TestUmgebung hilfreich.

Was anstelle von einem separaten Stück Karo-Papier auch gut ist: Hardware im Code dokumentieren ( nicht nur Pin-Belegung, auch was genau dran angeschlossen ist ( Speziell bei Breadboard - Konstruktionen ). Ob man das mit einem Schaltplan, Fritzing oder ASCII - Grafik, oder nur Text macht, hängt immer vom jeweiligen Fall und Geschmack ab. Meist mach ich zu wenig, merke ich hinterher. smiley-wink
Das geht dann nahtlos in die Frage über: Wie dokumentiert ihr einen Breadboard-Aufbau oder ein testweise zusammengelötetes Protoboard ?
Schaltplan mit LTSpice hat den Vorteil, dass man, wenn man sich Mühe gibt, das elektrische Verhalten einigermassen simulieren kann. Ist aber Mühe ...
Logged

Germany, Dresden
Offline Offline
Sr. Member
****
Karma: 16
Posts: 457
30 Jahre Elektronikbastelei, Programmieren null Ahnung!
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Da ich noch nicht so firm bin, alles frei weg zu programmieren, gucke ich erst mal, was es für mein Problem so an Libs und Lösungen gibt. Dann wird ein halbwegs passendes Beispiel aufgebaut und so lange modifiziert, eine weitere Lib mit eingebunden, Code hinzugefügt, bis es meinen Zweck erfüllt.
Standard ist bei mir quasi, die LCD Lib auszukommentieren und statt dessen die LiquidCrystal_I2C Lib dafür einzubinden.  Meist habe ich 2-3 ähnliche Sachen mit den Libs, die ich verwendenden will offen und kopiere mir dort Zeilen raus.
So lernt man auch was. Früher habe ich mal in einem Projekt einen berechneten Temperaturwert mit zig Nachkommastellen auf einem LCD Display ausgeben wollen. Ich hatte aber keinen Plan, wie ich die sinnlosen Nachkommastellen einkürzen kann. Also habe ich mit set Cursor einfach °C über den Nachkommaschwanz drübergeschrieben  smiley-evil
Jetzt habe ich zufällig wo gefunden, das lcd.print(t ,1); die Variable t mit lediglich einer Nachkommastelle ausgibt. Selbst da mußte ich erst mal tüfteln, denn der Denkanstoß kam aus einem GPS Code, wo durch Division erst mal das Komma gesetzt wurde und gleichzeitig dann der Schwanz eingekürzt wurde.
Das sind kleine Schritte, aber wenn man auch noch was anders zu tun hat und nur ab und zu sich ans Breadboard und den Code setzt, dann freut man sich auch über jeden kleinen Erfolg.  smiley
Ansonsten Stift und Papier eigentlich nur für irgendwelche Arrys und Pinbelegungen.
Wenns läuft, dann wird nochmal aufgeräumt und auskommentierter Code rausgeschmissen und alles ein bisschen gestrafft oder Leerzeilen für logische Blöcke eingefügt usw.

Gruß Gerald
Logged

rot ist blau und Plus ist Minus

Offline Offline
Full Member
***
Karma: 11
Posts: 149
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

So, danke erstmal für die ganzen guten Tipps. Ich möchte nun mal einen Code anhängen den ich gerade fertig geschrieben habe und noch etwas unübersichtlich ist. Aber er funktioniert! Wie kann ich ihn besser "aufräumen"? leserlicher machen oder ein paar funktionen erstellen( zusammenfassen).
Wer kann mir sagen, wie ich  3 Schiebregister(oder mehr) ansteuern  kann? Ich meine den bitwert (glaube ich) >>8, das verstehe ich noch nicht,  aber & 255 setzt den rest und was muss ich bei 3 Registern schreiben? Im Code habe ich es auskommentiert.

Code:
#include <Bounce.h>



const int takt_Pin = 8; //Schieberegister Takt, Speicher, Daten  Pin:
const int speicher_Pin = 9;
const int daten_Pin = 10;
const int Taster1_Pin = 4; //Schalter 1  ==  AN / AUS alle
const int Taster2_Pin = 3; //Schalter 2 == Muster rauf
const int Taster3_Pin = 2; //Schalter 3 == Muster runter

int Taster1_wert = 0; // Werte für Schalter
int Taster2_wert = 0;
int Taster3_wert = 0;

int altTaster1_wert = 0; // Werte für vorher Schalterwerte
int altTaster2_wert = 0;
int altTaster3_wert = 0;

unsigned int zaehler1 = 0;   // zaehler 1 und 2
unsigned int zaehler2 = 0;

int wert_led =0;
int alt_wert_led = 0;
long zufall;
unsigned long letzteZeitmessung = 0;

int LampenPin [8] = {  0B0000000000000000,  //alle AUS
  0B1111111111111111, // Bitmuster für Schieberegister ---alle AN
  0B1111111100000000,            //hälfte AN hinten
  0B0000000011111111,            // häfte AN vorn
  0B0011001110010011,            //schräg
  0B1100110001101100,
  0B1111100111111001,
  0B0110011000110110,
  };            
 



Bounce Taster1 = Bounce(Taster1_Pin, 10 ); //Bounce = entprellen der Schalter
Bounce Taster2 = Bounce(Taster2_Pin, 10 );
Bounce Taster3 = Bounce(Taster3_Pin, 10 );

void setup()
{
pinMode(takt_Pin, OUTPUT);
pinMode(speicher_Pin, OUTPUT);
pinMode(daten_Pin, OUTPUT);
Serial.begin(9600);
Serial.println("Programm Start");
randomSeed(analogRead(0));
}

void loop()
{
Taster1.update(); // update für Schalter
Taster2.update();
        Taster3.update();

  Taster1_wert = Taster1.read();
    if (altTaster1_wert != Taster1_wert)
    {
if(Taster1_wert == HIGH) {zaehler1 ++;}
    }
    if(zaehler1 >= 2) {zaehler1 = 0;}


  Taster2_wert = Taster2.read();
if (altTaster2_wert != Taster2_wert)
{
if (Taster2_wert == HIGH)  { zaehler2++; }
}

  Taster3_wert = Taster3.read();
if (altTaster3_wert != Taster3_wert)
{
if (Taster3_wert == HIGH) { zaehler2--; }
}
altTaster1_wert = Taster1_wert;
altTaster2_wert = Taster2_wert;
altTaster3_wert = Taster3_wert;
Serial.println(zaehler2);


if(zaehler2 >= 8) {zaehler2 = 0;}

if (zaehler1 == 0 && zaehler2 >=0) {wert_led = 0;}      // Zählerwerte in Variable schreiben und  an sendeLampen übergeben
if (zaehler1 == 1 && zaehler2 >=0) {wert_led = 1;}
if (zaehler1 == 1 && zaehler2 ==1) {wert_led = 2;}
if (zaehler1 == 1 && zaehler2 ==2) {wert_led = 3;}
if (zaehler1 == 1 && zaehler2 ==3) {wert_led = 4;}
if (zaehler1 == 1 && zaehler2 ==4) {wert_led = 5;}
if (zaehler1 == 1 && zaehler2 ==5) {wert_led = 6;}
if (zaehler1 == 1 && zaehler2 ==6) {wert_led = 7;}
if (zaehler1 == 1 && zaehler2 ==7) {discolicht();}

if (alt_wert_led != wert_led)
{
sendeLampen(wert_led);
}
alt_wert_led = wert_led;

if(zaehler1 == 0){zaehler2 = 0;}  // Zähler 2 auf 0 setzten, wenn zähler 1 auch null ist
}
void discolicht()
{ for (int i = 0; i <= 16; i++)
   {
    zufall = random(18);
if (millis() - letzteZeitmessung > 70)
{
letzteZeitmessung = millis();
sendeLampen(zufall);
}

Serial.println(zufall);

   }
}


void sendeLampen(int wert)
{
digitalWrite(speicher_Pin, LOW); // Ansteuerung der 2 Schieberegister
shiftOut(daten_Pin, takt_Pin, LSBFIRST, LampenPin[wert] >> 8);
shiftOut(daten_Pin, takt_Pin, LSBFIRST, LampenPin[wert] & 255);
// shiftOut(daten_Pin, takt_Pin, LSBFIRST, LampenPin[wert] &???????????); welchen wert muss hier hin bei 3 und mehr Registern
digitalWrite(speicher_Pin, HIGH);

}


Danke

MfG Marco
Logged

Pages: [1] 2   Go Up
Jump to: