10 mal abgeschnitten und immer noch zu kurz…

Kennt Ihr den Satz? Ich auch. *grins

Mittlerweile haben einige den Controller in betrieb und so kommt auch immer mehr Rückmeldung. Dabei tauchen auch kleine Fehler auf die mir nicht aufgefallen sind, Ich aber dokumentieren möchte bevor ich sie fest ändere und somit auch ein bugfixen ohne komplettes löschen des Codes möglich ist.

1.: in der datei keypad.ino Zeile 35:
if(dimming[chanel].level==1){
dimming[chanel].level=0;
ledDriver.setLEDOff(chanel*2);
ledDriver.setLEDOff(chanel*2-1);
manualLight=true;
}else if(dimming[chanel].level==0){
dimming[chanel].level=1;
ledDriver.setLEDOn(chanel*2);
ledDriver.setLEDOn(chanel*2+1);
manualLight=true;
}

Wichtig hierbei die Zeile „ledDriver.setLEDOff(chanel*2-1);“. Es muss heißen
ledDriver.setLEDOff(chanel*2+1);

2.: Das manuelle Dimmen durchs Halten der Taster (wie hier beschrieben:
http://aqua-grow.de/jetzt-wird-es-ernst/) funktioniert gar nicht. -> Ja es musste leider deaktiviert werden durch speicher Probleme… Hoffe das es später mal wieder kommt.

3.: Die ausgabe im Serial Monitor ist wärend der Programmierung geändert, aber nicht dokumentiert wurden. Ich werde versuchen mal ne etwas sinnigerere Ausgabe zu schrteiben und diese dann ein zu bauen.

4.: Die LEDs sollten sich über den Serial Monitor einstellen lassen. Hier scheint es aber ein kleines Problem zu geben welches ich nicht genau gefunden habe. Verantwortlich ist die Zeile 29 aus Serial.ino:
case 2:
pin= input.substring(2,3).toInt();
val= input.substring(4,7).toInt();
setLED(pin,4095-int(val*40.95));
manualLight=true;
Serial.print(pin);
Serial.print(F(" -> "));
Serial.println(4095-int(val*40.95));
break;

Eigentlich stimmt der code. wenn man „2=2:90“ an den Controller schickt sollte dieser mit „2 -> 409“ antworten und dann auf 90% Licht dimmen. evt hilft ein verschieben der Zeile „manualLight=true;“ vor setLED(); (eins nach oben), ich werde das aber noch genau untersuchen und dann schauen.

5.: Wo wir bei den LEDs sind: Ich möchte nochmal drauf hinweisen das der Controller 16 Kanäle dimmen kann ABER nur 8 unabhängig von einander. Das heist Kanal 1 und 2 haben immer die gleiche Schaltzeit, zustand ect. Gleiche auch 3/4,5/6,7/8,…,13/14,15/16.

6.: Wo wir beim dimmen sind: Die Dimmzeit kann man nicht beeinflussen. Das kommt daher das der Contoller IMMER dimmt, von einem zum anderen wert. Also sagen wir um 10uhr habt ihr 20% eingestellt und um 11 soll es hell sein (100%) dann dimmt der von 10-11 von 20% zu 100%. bis 16uhr soll es so hell bleiben, dann 2 stunden runterdimmen: Dafür müsst ihr 16uhr mit 100% erneut angeben und dann 18uhr mit 10 oder 0%. In der Zeit von 11-16 „dimmt“ der controller von 100% zu 100%, ergo er ist immer ganz an. Die Dimmzeit ist also nur die Spanne zwischen einer Uhrzeit und der anderen. So könnt ihr aber auch ne „Kurvendimmung“ machen: (bisschen pseudocode)
10->0%
11->10%
12->30%
13->70%
14->100%
15->0%
19->100%
22->0%
Jetzt dimmt der 4 Stunden, erst langsam, dann schnell ein, eine stunde wieder auf 0, 4 stunden wieder auf ganz hell und 3 stunden langsam runter auf 0%.

Dann hat mir Stefan noch nen schönes Bild geschickt von seiner Lampe beim Testen des Controllers, welches ich finde sieht sehr gut aus und daher möchte ich es euch nicht vor enthalten:

IMG_20140701_215920

Jetzt wird es ernst

Der letzte Teil (erstmal) in der Tutorial-Reihe des DIY Minimalistik Controller.

Wir haben mittlerweile Arduino kennen gelernt, haben gebastelt und alles getestet, haben Dosierpumpen und LED Angeschlossen, nun wollen wir uns noch mit dem Keypad und dem Serial Monitor auseinander setzen.

Kommen wir zuerst zum Keypad:
Jede der 12 Tasten hat 2 funktionen (meistens). Eine wenn man sie drückt, eine wenn man sie gedrückt hält.
Für die Tasten 1-8: Klicken -> Kanal 1-8 (je nach Taste) geht ganz an/aus. Dabei wird in einen Manuellen Lichtmodus geschaltet. Wenn man die Taste gedrückt hält dimmt die KSQ runter und dann wieder hoch. Nach Loslassen geht es in die andere Richtung. Wieviel Prozent es grade sind seht ihr im Serial Monitor. Dazu gleich mehr.
Taste 9 schaltet die Automatische Dimmung wieder ein.

Die Tasten A-D,#,* steuern die Dosierpumpen. Wenn man klickt wird 1ml Dünger gepumpt. Wenn man länger hält wird die Anzeeige zum Dünger resettet. Ab da sind wieder 100% Dünger Vorat da und es wird runter gezählt.

Die Tasten 0 ist nicht belegt im Moment. Man kann Ihnen aber eigene Funktionen zuordnen. Schaut euch hierzu die Datei keypad.ino an:


}else if (key == '0') {
}

Wenn Ihr das einfügt könnt ihr so eine Funktion aufrufen.

Kümmern wir uns noch um den Serial Monitor. Diesen Erreicht Ihr wenn ihr im Arduino Menü auf Tools/SerialMonitor klickt. Im neuen Fenster seht Ihr eure Uhr laufen. Sollte die Zeit nicht stimmen könnt Ihr sie über die Obere Zeile einstellen. Tippt dafür Datum und Zeit im Format YYYY/MM/TT/SS:mm ein. also z.B. 2014/02/26/22:10. Davor gehört noch eine 1= daamit der Controller weiß das er eine Uhrzeit bekommt. Für heute und Jetzt (26.2.2014, 21:48) heißt die Zeile also:
1=2014/02/26/21:48
Achtet drauf das unten in dem Dropdown Feld steht das Ihr Umbruch und neue Zeile sendet (NL & CR). Mit Enter wird die Zeit gesendet und übernommen.

Außerdem kann man über den SerialMonitor auch alle LED Ausgänge steuern. Hierfür müsst Ihr eine „2=“ senden, gefolgt von dem Kanal und einer 3 Stelligen % Angabe. Wenn wir also Kanal 1 auf 40% dimmen wollen dann senden wir:
2=1:040
Danach können wir noch Kanal 8  auf 100% Dimmen und 1 ausschalten:
2=1:040
2=8:100
2=1:000
Bitte jede Zeile einzeln eintippen und absenden. Wenn Ihr normale Dimmung wieder haben wollt, drückt im Keypad die 9.

Die letzte hinterlegte Funktion ist dass kalibrieren der Pumpen. Dies ist nicht unbedingt nötig, verbessert aber die Genauigkeit der Düngermenge. Hierfür müssen wir zuerst eine 3 senden fürs kalibrieren und dann welche Pumpe und wie lange sie pumpen soll. Sgaen wir mal wir wollen die Pumpe eins auf 60 Sekunden kalibrieren:
3=1:60
Im Serial Monitor taucht nun die Meldung „P1 kalibriert“ auf und kurze Zeit später pumpt die Pumpe 60 Sekunden. Die Menge könnt ihr messen und dann im Pump Einstellungen eintragen.

Komponenten hinzufügen

Heute wollen wir uns einmal um das letzte Große Kapitel kümmern: Anschliessen der LEDs und Dosierpumpen. Nehmen wir uns zuerst die LEDs vor. Für den Controller mit der Dimmung sind alles LEDs und Treiber geeignet die über Konstantstrom betrieben werden und DC-DC Treiber mit DIM Anschluss. Getestet habe Ich bisher:

  • Meanwell LDD ( LDD-H / LDD-HW / LDD-L / LDD-LW  )
  • Anvilex ( CCS2 / CCS3 )
  • AquaGrow Treiber (Ja Ich habe mir meine eigenen Entwickelt)
  • Alle Treiber die auf den LED Chip PT4115 beruhen (Ebay)
  • Alle Treiber die LED aus gehen wenn man den DIM Anschluss mit Ground verbindet und max. 4V an diesem haben

2014-02-21 19.35.19 2014-02-21 19.34.21

Die LED werden in reihe Angeschlossen und mit dem Treiber verbunden. Der Treiber wieder wird mit dem Netzteil verbunden. Diese können alle parralel angeschlossen werden. Die DIM Leitungen werden dann mit dem PCA9865 verbunden. Zusätzlich muss eine Minus Leitung vom Netzteil zum Arduino gezogen werden (shared Ground). Den PCA9685 hab Ich einfach nur als verlängerung an das Keypad geklemmt. Dank des I²C Bus kann man die beliebig verlängern, erweitern und zusammen stecken solange man SDA und SCL nicht vertauscht.

2014-02-21 19.36.34 2014-02-21 19.36.23 2014-02-21 19.38.49

Wenn Ihr dies alles richtig gemacht habt sollten eure LEDs beim Testsketch dimmen. Machen wir weiter mit den Dosierpumpen: Hier haben wir ja schon die Treiberboards mit dem 12V Netzteil verbunden. Nun müssen wir vom 12V+ zu einer Seite der Pumpen ein Kabel legen. ACHTUNG: Die können in beide Richtungen drehen, achtet also drauf wierum für euch richtig ist. Die andere seite (Minus) verbindet Ihr mit den Pins des Motortreibers.

2014-02-21 19.38.08 2014-02-21 19.37.51 2014-02-21 19.37.07 2014-02-21 19.37.30

Konfiguration DIY Controller

*Update 18.04.2014*
*Update 23.07.2014*

Nachdem wir alle Komponenten getestet haben wollen wir nun einmal unseren richtigen Sketch laden, einstellen und testen.

Hierzu laden wir erstmal die DIYMinimalistikController.ino und wechseln zum Tab config.h.

config

Schauen wir uns die Datei mal im einzelnen an:

#define PUMPCOUNTS 4 // Number Pumps
#define LIGHT_CHANEL 8 // Anzahl LED Kanäle
#define LIGHT_VALUES 8 // Zeiten Pro Kanal
#define KEYPADI2C 0x20 // Adresse Keypad
#define LCD_ADR 0x27 // Adresse LCD
#define LED_DRV 0x40 // Adresse LED Driver, bei mehreren 0x70 eingeben für Broadcast adresse


PUMPCOUNTS steht für die Schaltzeiten. NICHT für die Anzahl der Pumpen. Wir können also z.B. 3 Pumpen je 2 mal am Tag Schalten oder 2 einmal und 2 2 mal.
LIGHT_CHANEL ist für die Verfügbaren Kanäle. 8 da wir immer 2 zusammen gefasst haben. Solltet Ihr diese Zahl verändern (auf 16 z.B.) müsst Ihr an anderer Stelle auch Dinge ändern. Das kommt später erst wie das geht.
LIGHT_VALUES ist die Anzahl an Programmierbaren Zeiten. Wenn Ihr z.b. nur einmal rauf und später wieder runterdimmen wollt reichen auch 4. Das spart Speicher.
KEYPADI2C Ist die Adresse des Port Expanders für das Keypad. Diese solltet Ihr euch mit dem I2C Scanner auslesen oder in der Beschreibung des Moduls schauen. Bei dem von mir bestellten und auf der Platine verbauten ist es 0x20.
LCD_ADR ist die Adresse des LCD Backpacks. Tragt die aus dem LCD Test ein.
LED_DRV steht für das PWM Driver Modul. Es hatte 2 Adressen, eine (0x70) ist die sogenannte Broadcast Adresse. wenn Ihr mehrere Module habt kann man darüber alle gleichzeitig ansprechen. Für uns relevant ist aber erstmal nur die andere.


#define NANO
//#define AGMINI

Hierdrüber „steuern“ wir welches Board wir besitzen und welches Pinmapping geladen wird. Wenn wir also den Nano verwenden wollen müssen wir nix machen. Sollten wir noch die erste Version des Minicontrollers besitzen müssen wir die // vor #define AGMINI weg nehmen und vor Nano setzen:

//#define NANO
#define AGMINI


/ PIN MAPPING NICHT ÄNDERN!!!
// Pin Mapping für Nano
#define PIN_TEMP 4 // Temperatur
#define DOSE1 6 // Dosierpumpe1 (Nahe an LED)
#define DOSE2 7 // Dosierpumpe
#define DOSE3 8 // Dosierpumpe
#define DOSE4 9 // Dosierpumpe
#define DOSE5 10 // Dosierpumpe
#define DOSE6 12 // Dosierpumpe6 (Nahe an + Pol / Keypad)
#define PIN_PWM 11 // PWM PIN // Lüfter


Hier werden die einzelnen Pins konfiguriert und was dort angeschlossen ist. Wer sich an meine Vorgaben hält muss hier nix ändern. Nach dem oben angegebenem Board wird automatisch das richtige geladen.

Nun geht es an den „richtigen“ Teil:
// Temperatur ab Wann Lüfter an gehen (Ganzzahl)
const int coolingTemp = 40;
const float cTemp = 60;
// Geschwindigkeit der Lüfter -> 0 Aus, 255 Maximale Geschwindigkeit
const int pwmValue = 255;

coolingTemp ist die Temperatur wo die Lüfter anfangen zu regeln. Wichtig ist das es eine „Ganzahl“ ist, also kein 32,5. Sollte diese Temperatur überschritten werden drehen die Lüfter auf. Falls die Lüfter zu schnell drehen oder zu laut sind könnt ihr sie mit pwmValue „drosseln“. Der wert muss zwischen 0 und 255 liegen und manche Lüfter starten erst bei 100 oder so. Testet einfach nen bisschen rum welches Value besser ist.
cTemp ist eine „Emergency Temperatur“ sollte dieser Wert erreicht werden (was ich nicht hoffe) schalten Die LEDs aus. 50°C ist dabei schon ein guter Max wert. denkt daran das die LED Wärmer werden als die Kühler Luft.

// Größe Vorratsflaschen Dünger in ml
const int dose_val = 500;
Hier können wir die Anzeige des Düngervorrats bestimmen. Tragt die ml Menge er Flaschen ein. Wer zum Beispiel die großen Aquasabi Flaschen hat 1000 für 1Liter. Hieraus errechnet sich dann wieviel % noch in den Flaschen sind und wann Ihr auffüllen müsst. Mit dem Keypad reset wird dieser wert wieder in den arduino speicher geschrieben. Wer 500ml und 1000ml Flaschen dran hat sollte 1000 rein schreiben und bei 50% auswechseln.


// Neu zuordnung der Pins für Dosierung
const int dosingPins[]={DOSE1,DOSE2,DOSE3,DOSE4};
// Milliliter per minute in Reihenfolge wie Pumpen oben
const int dosingMlMin[]={60,60,60,60};

Hier legen wir fest welche Pumpe wo angeschlossen ist. Sagen wir Ihr habt ausverehen die Ganz Rechte Pumpe an den 3ten Pin angchlossen, dann könnt Ihr das hiemit Korrigieren. In diesem Faalle Wäre es Dose3,Dose1,Dose2,Dose4.
Zum besseren Einstellen der ml kann man zusätzlich hinterlegen wieviel die Pumpen pro 60 Sekunden fördern. Diesen Wert kann man über Serial ermitteln und dann eintragen. Wichtig: Jeder Pumpe gehört ein Wert. Der erste Wert der Pumpe die unter Pins als erstes Steht (also Dose1).

Es ist eigentlich nur ne kleine Hilfe für den Code und müsste nicht verändert werden, außer ihr habt mehr Pumpen dran oder mit anschließen vertan.


// Pumpen Einstellungen
// Uhrzeit, Aktive, Name, Pin Adresse (von array oben 0 ist erste Pumpe "Dose1"), Status (ignorieren, nur wichtig für Programm), Milliliter pro Dosierungconst
PUMP dosing[] = {
{get_ts(10,0,0),1,"D1",0,5},
{get_ts(11,0,0),1,"D2",1,6},
{get_ts(11,25,0),0,"D3",2,3},
{get_ts(11,26,0),0,"D4",3,3},
//{get_ts(11,23,0),0,"D3",2,3},
//{get_ts(11,28,0),0,"D1",0,5},
};

Hier geht die Eigentliche Konfig der Pumpen los. Jede Zeile steht dabei für
Uhrzeit, ist Schaltzeit Aktive (1 für an, 0 für aus), Dünger Name (nur für euch zum merken, maximal auch nur 2 Zeichen), Welche Pume genutzt wird, Milliliter des Düngers was gedüngt werden soll.
Wenn wir zum Beispiel jeden Morgen um 10:30 4ml Eisen Düngen wollen auf der Pumpe die am Pin angeschlossen ist, der im Array dosingPins als erstes steht dann sieht die Zeile so aus:
{get_ts(10,30,0),1,"Ei",0,4},

Kommen wir zum Licht:
// Licht Einstellungen immer paar aus Uhrzeit und % angabe. Je reihe Zahl von LIGHT_VALUES, so viele Reihen wie in LIGHT_CHANEL
LIGHT light_channels[LIGHT_CHANEL][LIGHT_VALUES] ={
{{get_ts(0,1,0),0},{get_ts(10,0,0),0},{get_ts(11,30,0),100},{get_ts(19,0,0),100},{get_ts(20,0,0),0},{get_ts(21,30,0),0},{get_ts(23,30,0),0},{get_ts(23,32,0),0}},
{{get_ts(0,1,0),0},{get_ts(9,0,0),0},{get_ts(11,0,0),100},{get_ts(19,0,0),100},{get_ts(21,0,0),0},{get_ts(21,30,0),0},{get_ts(23,30,0),0},{get_ts(23,32,0),0}},
{{get_ts(0,1,0),0},{get_ts(10,0,0),0},{get_ts(11,30,0),100},{get_ts(19,0,0),100},{get_ts(20,0,0),0},{get_ts(21,30,0),0},{get_ts(23,30,0),0},{get_ts(23,32,0),0}},
{{get_ts(0,1,0),0},{get_ts(9,0,0),0},{get_ts(11,0,0),100},{get_ts(19,0,0),100},{get_ts(21,0,0),0},{get_ts(21,30,0),0},{get_ts(23,30,0),0},{get_ts(23,32,0),0}},
{{get_ts(10,30,0),0},{get_ts(11,30,0),0},{get_ts(12,30,0),0},{get_ts(13,30,0),0},{get_ts(14,30,0),0},{get_ts(15,30,0),0},{get_ts(16,30,0),0},{get_ts(17,30,0),0}},
{{get_ts(10,30,0),0},{get_ts(11,30,0),0},{get_ts(12,30,0),0},{get_ts(13,30,0),0},{get_ts(14,30,0),0},{get_ts(15,30,0),0},{get_ts(16,30,0),0},{get_ts(17,30,0),0}},
{{get_ts(0,1,0),0},{get_ts(8,30,0),0},{get_ts(9,0,0),20},{get_ts(9,30,0),0},{get_ts(20,0,0),0},{get_ts(20,30,0),70},{get_ts(21,0,0),0},{get_ts(23,30,0),0}}, //Rot
{{get_ts(8,30,0),5},{get_ts(9,30,0),0},{get_ts(20,30,0),0},{get_ts(21,0,0),40},{get_ts(21,30,0),20},{get_ts(21,50,0),10},{get_ts(21,55,20),10},{get_ts(23,55,20),5}} // Blau
};

Sieht kompliziert aus? Ist es aber nicht… Eigentlich kann man alles auf einen kleinen Block reduzieren der sich immer wieder wiederholt:
{get_ts(0,0,0),0}
Zuerst holen wir uns mit get_ts() eine Uhrzeit. In () steht nur Stunde,Minute,Sekunde. Also für 14:43:20 wäre das get_ts(14,43,20). Danach kommt ein „,“ und dann wie hell es sein soll. Das ganze ist in %, also 0-100%. Wenn wir um 14:43:20 zu 78% Dimmen wollen dann ist der Wert: {get_ts(14,43,20),78}.
Wichtig ist das der Controller immer zwischen 2 werten dimmt. Also wenn wir von o auf 50% dimmen wollen zwischen 12:00 und 13:30 dann ist das:
{get_ts(12,0,0),0},{get_ts(13,30,0),50}
Wenn wir die Helligkeit bis 20:00 Uhr haben wollen und dann um 23:30 das Licht aus sein soll ist das:
{get_ts(12,0,0),0},{get_ts(13,30,0),50},{get_ts(20,0,0),50},{get_ts(21,30,0),0}
Sollten wir die 20:00 vergessen fängt er ab 13:30 an aus zu dimmen.
Wichtig ist auch das die Zeiten chronologisch sind, also nicht 10uhr hinter 13 uhr steht ({get_ts(13,0,0),50},{get_ts(10,0,0),50}). Das lässt alles abstürzen.
Da wir nun wissen was ein Wert bedeutet können wir diesen einfach so oft hintereinander schreiben wie wir unter LIGHT_VALUES angegeben haben. Also in unserem Fall 8 mal. Dann kopieren wir die Zeile so oft wie wir Kanäle angegeben haben, also 8 mal. Die Einstellung im Code ist schon für 8×8 richtig. Tauscht nur Uhrzeiten und % aus. Daas Blau/Rot könnt Ihr ignorieren. Das kommt von meinem Becken.

Einzeltest der Platinen

Heute ist es soweit:

Wir wollen einmal testen ob alles soweit funktioniert was wir bisher gebastelt haben. Hierzu gehen wir erstmal auf das GitHub Verzeichniss und laden die Zip runter:
https://github.com/MajorMadness/ArduinoIDE

Wir laden die ganzen Dateien runter (Download ZIP) und entpacken diese auf dem Desktop oder einem anderen Platz. Danach öffnen wir den Ordner wo wir auch die Arduino IDE typischen Dateien und Ordner finden.

Nun Starten wir die Arduino IDE und klicken auf Datei/Beispiele. Dort finden wir nicht nur die fertigen Sketche für später sondern auch die Einzeltests der Platinenbauteile. Zuerst öffnen wir den „I2Cscanner“ und ladet den auf euren Arduino hoch. Wenn dies abgeschlossen ist öffnet Ihr den Serial Monitor und wartet ein paar Sekunden. Ihr solltet nun 6 Adressen sehen. 2 gehören der Uhr, eine dem Keypad, eine dem LCD, die anderen beiden dem PWM Board. Wenn dies nicht der Fall ist habt Ihr irgendwo nen Fehler gemacht. Checkt nochmal Power und ob SDA/SCL richtig verbunden sind. Testet auch wenn nur Keypad und nur LCD aangeschlossen sind ob diese die gleichen Adressen haben. Beide benutzen den selben Chip, daher kann es zu problemen kommen. Auf dem Keypad Extension Board sind jumper. Steckt einen in diesem Falle um und merkt euch die Adresse.

Screenshot 2014-02-11 21.28.48

Danach laden wir den Temperatur Sketch und Starten ebenfalls den Serial Monitor. Hier bekommt Ihr nen paar Daten zu diesem angezeigt, wichtig aber das Ihr die temperatur sehen könnt.

Screenshot 2014-02-11 21.31.23

Nun Testen wir noch den Uhren chip (RTC Test). Keine Sorge wenn hier die falsche Zeit angezeigt wird. wir müssen die erst noch richtig setzen. Dies geschied später über den Controller oder wir können dies jetzt schonmal machen mit der Zeile:
rtc.adjust(2014,1,23,23,57,0);
Nehmt die beiden // weg und schreibt eure Aktuelle Zeit rein. Danach hochladen, wieder die beiden // davor setzen und nochmal hochladen. Ansonsten wird bei jedem Reset die Uhr neu gesetzt.
Screenshot 2014-02-11 21.30.16

 

Dann fehlen noch die Dosierpumpen und der Lüfter. Hierfür ist die DosingTest da die wir auch öffnen und überspielen. Im Serial Monitor sehen wir welche Pumpe grade Aktive ist und was der Lüfter macht. Analoge dazu leuchten auch die LED auf dem Stepper Motor.

Screenshot 2014-02-12 06.29.33

Letzter Test ist das keypad. Achtet drauf dass das linke Ende (nahe *) an P0 angeschlossen ist. Danach die Keypad laden. Nach abschluss könnt ihr den Serial Monitor öffnen und bisschen rumdrücken. Jede Taste wird mit entsprechendem Zeichen ausgegeben.

Screenshot 2014-02-11 22.25.49

Das LCD könnt Ihr mit dem Beispiel Sketch testen. Hierbei gibt es etwas besonderes: Es gibt 3 oder mehr Backpacks für LCD. Diese unterscheiden sich in der Pinbelegung/Verdrahtung und in der Adresse. Standartmäßig erwartet die Lib andere Pins an den Ports des Chips. Deswegen müssen wir testen welche Pin belegung richtig ist für uns. Ich habe im Beispiel 3 gängie aufgeführt. Sollte der erste nicht klappen, versucht den nächsten. Außerdem hat das Backpack einen Kontrast Poti. Sollte euer Display schlecht lesbar sein oder garnichts anzeigen dreht diesen VORSICHTIG in beide richtungen bis ihr zumindest Klötze seht.

Sollte dies alles funktionieren kann es weiter gehen zum schönsten Teil: Entlich laden wir unseren Hauptsketch und stellen alles für die Steuerung ein.

Bastelstunde V2

Nachdem der erste Versuch mit vielen Funktionen leider aufgrund des Speichern nicht umsetzbar war müssen wir leider noch mal von vorne Basteln mit der angepassten Einkaufsliste.

Als erstes legen wir uns wieder alles bereit und Isolieren paar Kabel ab um sie am Terminal Board zu verbinden:
3x Rot, Blau
2x Schwarz, Grün, Gelb, Orange
3x Lila, Grau
1x Weiß, Braun

2014-02-04 22.34.12 2014-02-04 23.13.18

Rot, Orange, Schwarz und Blau müssen wir mit dem Netzteil verbinden. Rot = 5V+, Blau & Orange = Minus, Schwarz = 12V+. Außerdem verbinden wir dass Netzteil: 12V+ an VIN und 12V- mit Ground.
Die Gelben Kabel verbinden wir mit A4 und die Grünen mit A5. Lila und Grau wird immer abwechselnd mit 6/7, 8/9, 10/11 verbunden. Weiß kommt an Pin 12 und Braun an Pin 4.

Nun Können wir die Boards anschließen. Braun und Rot/Blau an den Temp Sensor, Lila/Grau abwechselnd an die Stepper Motoren und Orange/Schwarz für Strom. Das Gelbe Kabel wird mit SCL des PWM/Uhr, sowie Grün mit SDA von diesen verbunden. Außerdem bekommen die auch noch Strom.

2014-02-04 23.19.55 2014-02-04 23.23.23 2014-02-04 23.36.14 2014-02-04 23.35.27 2014-02-04 23.43.57 

Um ein bisschen Platz am Terminal Adapter zu sparen, schleifen wir SDA und SCL durch zu anderen Boards. Bei mir ist in Reihe verbaut: Keypad Adapter, LED Treiber, LCD:

2014-04-18 16.03.15 2014-04-18 16.02.55 2014-04-18 16.04.24 2014-04-18 16.04.52 2014-04-18 16.05.08

Nun kann der Arduino in den Sockel gesteckt werden und über USB mit dem PC verbunden werden.

2014-02-04 23.47.43

Wenn Minimal zu Minimal ist…

Ja manchmal kommt es anders als man denkt.

Viele Tage und vor allem Nächte habe Ich damit verbracht den Code für den DIY Minimalistik Controller zu schreiben. Dann kam Ich endlich an den Punkt wo alles getestet werden konnte und sieht da: Ich sah nix… Nichmal ein lebenszeichen.
Also wieder Fehlersuche, alles einzeln getestet, es funktionierte. Jedes einzelne Skript war lauffähig, aber warum dann nicht der Controller?

Am Ende konnte Ich den Fehler eingrenzen: Es war nicht der Flash speicher oder die Programmierung sondern schlichtweg der SDRAM des Nano’s. Also wurde viel Zeit und mühe dahin investiert jedes einzelne Byte an Speicher zu sparen, doch ohne Erfolg. Es ist nicht möglich die Fnktionen die geplant sind zu implentieren.
Aus diesem Grunde muss Ich das Projekt nun splitten. Es wird einmal einen Minimalistik Controller geben der Günstig und einfach ist und LED’s, Dünger und Ventilatoren steuert und eine Version die später auf Basis des Mega2560 umgesetztwird mit mehr funktionen. Welche das Genau sind kann Ich leider noch nicht Sagen, aber es ist geplant alles das Um zu seitzen was im Mini geplant war und evt noch mehr.

Bastelstunde

Achtung: Diese Anleitung ist nicht mehr Aktuell da der Controller so nicht funktioniert. Bitte lest Wenn Minimal zu Minimal ist und folgt den Korrekten Links auf der Seite DIY Controller.

So langsam sind alle Komponenten da und Ich möchte anfangen den Kontroller zu testen. Daher wurde heute fleissig gebastelt.

Am Anfang wurde erstmal alles vor bereitet, Kabel gesucht und alle Kabel an einem Ende ab Isoliert da Ich den Terminal Adapter verwenden wollte. Der Terminal Adapter wurde dann über VIN und Ground mit einem Stecker verbunden. So kann man diesen Nachher mit 6-12V betreiben (Später doch abgemacht und direkt an Netzteil dran gemacht). Danach wurden alle Kabel an den TA geschraubt. In A4 und A5 kommen jeweils 4 Kabel da diese für I²C sind und wir davon 4 Anschließen. Das Kabel an D13 ist mittlerweile an D4 für den Temperatur Sensor. D12 ist für den Lüfter und die 4 weißen an D8-D11 für Dosierpumpen. D7 und D6 sind die Relays und D5 das Fischfutter.

2014-01-23 15.27.26 2014-01-23 15.27.36 2014-01-23 15.37.03 2014-01-23 16.05.03

 

Wenn das geschafft ist ist das meiste/schwerste auch schon getan. Nun können wir die Stecker einfach auf die jeweiligen Boards stecken.
Fangen wir mit den I²C an. Gelb ist immer SCL und Orange immer SDA. Wir können also der Beschrifftung auf den Platinen folgen. Der Temperatur Sensor hat seine Datenleitung in der mitte, diese mit D4 Verbinden.
Die beiden Stepper Motor Driver werden einfach nur in Reihe mit den passenden Pins versorgt. Hierbei sieht man am Bild das Graue Kabel D12 an Pin1/IN1. IN5-7 bleibt leer.
Danach können wir das Relay anschließen. Da Ich nur nen 4-Fach hatte benutze ich das. IN1 an Orange, IN2 an braun.
Das war es auch schon. Alle Datenleitungen sind verbunden.

2014-01-23 16.08.59 2014-01-23 16.09.19 2014-01-23 16.09.11 2014-01-23 16.11.11

 

Nun geht es weiter mit den Stromleitungen. Alle Boards haben ein Rotes und blaues Kabel bekommen. Alle blauen sind Ground und wurden in eine Lüsterklemme gesteckt. (Wago Klemmen sind grade aus…) Die Roten wurden embenfalls verbunden AUSSER das vom Stepper Motor. Dieses wird getrennt angeschlossen da es an 12V kommt. (Achtet auf das Bild der Klemme.)

2014-01-23 16.39.30 2014-01-23 16.39.46

 

Hier dann nochmal ein paar Aufnahmen von allen Platinen und anschlüssen:

2014-01-23 16.38.29 2014-01-23 16.38.49 2014-01-23 16.39.20 2014-01-23 16.39.08

 

Am Ende ist ein ganz schönes Kabel wirrwarr entstanden und Ich weiß wieder warum Ich seinerzeitz das ganze auf einem Board unterbringen wollte… Letzter schritt war es den Arduino in den Sockel zu stecken und das Netzteil an zu schliessen. Da ich ein 2 Spannungsnetzteil aus dem PC Bereich (altes Netzteil einer 3,5″Zoll Festplatte) verwende wurde Rot mit 5Volt verbunden und 12V (Gelb) mit VIN und dem Stepper Motor VCC. Nun wird der Arduino, Stepper Motor mit 12V und alle Platinen mit 5V versorgt. Ground von allen Platinen und Arduino sind verbunden mit dem des Netzteils.

2014-01-23 16.32.48 2014-01-23 16.38.22 2014-01-23 16.40.39 2014-01-23 16.40.47

Nächster schritt ist dann unsere Verkabelung zu testen und alles einzeln einmal zu checken.

Terminal AdapterArduino Nano V3.0

Ein bisschen Basteln

*Update 18.04.2014 -> Es gibt wieder LCD.*

Der DIY Minimalistik Controller soll so gut es geht ohne löten auskommen. Leider gibt es 2 Teile die wir nicht fertig gelötet bekommen können:
Adafruit 16-Channel 12-bit PWM
16×2 HD44780 Character LCD Display mit I2C Serial Interface Board Module

Aus diesem Grund müssen wir im 2ten Schritt den Lötkolben anwerfen. Ihr braucht dazu keine richtige Lötstation, Ich empfehle aber einen Lötkolben mit über 50W. Dünnes Lötzinn ist außerdem gut, viele Ebay Angebote für ~15€ haben aber schon alles dabei und es reicht.

Fangen wir mit dem LCD Backpack an. Im ersten schritt stecken wir das Backpack einfach nur auf und überlegen wie wir es anbringen. Man könnte es ganz durch Stecken und auf der Display Seite verlöten, Ich möchte dort allerdings platz zum einbau lassen und montiere es daher etwas weiter hinten. Verlötet wird es dann erstmal auf der Rückseite. Wenn Ihr keine sehr feine Spitze habt, passt auf Lötbrücken auf. Evt in diesem Falle nicht zwischen den Pins löten.

2014-01-21 15.26.54 2014-01-21 15.29.26 2014-01-21 15.33.13
Wenn alles fertig ist kann man die Vorderseite Bündig abschneiden und auch nochmal minimal verlöten. So haben wir auf jeden Fall sichere Kontakte.

2014-01-23 09.31.40 2014-01-23 09.31.52

 

Dann geht es weiter mit dem PWM Board. Hier stecken wir zuerst den mitgelieferten Header auf. Ich hab noch nen Extra an der anderen Seite angebracht, der muss nicht unbedingt sein, Ihr bekommt sowas aber einfach beim Elektronik Laden um die Ecke mit dem großen C. Lötet zuerst einen Pin fest und kontrolliert ob es grade ist. Dann erst die 5 anderen. Als nächstes könnt Ihr die mitgelieferten 12er Header einlöten. Wir werden später nur den PWM nutzen, daher habe Ich auch nur diesen verlötet. Der Terminal Block bleibt ebenfalls nicht eingelötet.

2014-01-21 15.27.05 2014-01-21 15.40.49 2014-01-21 15.42.30
2014-01-21 15.43.13 2014-01-21 15.44.08 2014-01-21 15.47.00

 

Beide Boards erlauben es die Adresse zu wechseln über Lötbrücken bei A0-A2 bzw A5. Solltet Ihr dies machen müsst Ihr den Code später anpassen da Ich alle Lötbrücken offen habe.

Die ersten Schritte

Der DIY Controller ist ein Projekt mit dem möglichst viele Leute angesprochen werden sollen. Aus dem Grund fangen wir diesmal noch weit vorher an: Installation von Software und Treibern für Arduino und Laden unserer Software.

Dass ganze Tutorial gibt es natürlich auch auf der Arduino Homepage, Ich schreibe es hier aber nochmal mit meinen Worten und Screenshots um auch eine Fragemöglichkeit bei diesen Schritten zu schaffen.

Zuerst laden wir uns einmal unter http://arduino.cc/en/Main/Software#toc2 die Arduino Software runter, genauer gesagt, wir besorgen uns den ZIP File. Diesen speichern wir uns erstmal auf dem Desktop. Danach öffnen wir die Zip per Doppelklick auf den File und „ziehen“ den dadrin enthaltenen Ordner auf den Dektop. Windwos entpackt uns den dann Automatisch.

Screenshot 2014-01-12 19.58.14 Screenshot 2014-01-12 20.10.16 Screenshot 2014-01-12 20.13.18

 

Nun sollten wir den Arduino Nano an den Computer über USB anschließen. Im Gerätemanager (zum öffnen „Start“ klicken und in das Suchfeld einfach „devmgmt“ eingeben, dann Enter/Return drücken ) sehen wir dann ein unbekanntes Gerät. Der Treiber sollte sich automatisch installieren, ist dies nicht der Fall Rechtsklick auf das nicht erkannte Gerät und „Treibersoftware aktualisieren“ wählen. Dann „Auf dem Computer nach Treibern suchen“ wählen und „Durchsuchen“. Im neuen Fenstar wählt Ihr den Ordner „arduino-1.0.5-r2\drivers“ aus und markiert „Unterordner einbeziehen“. Dann „Weiter“ drücken und die Treiber installieren sich. Danach seht Ihr im Gerätemanager einen „USB Serial Port“ und dahinter einen Com Port (Bei mir an diesem PC Com19).
Screenshot 2014-01-12 20.34.16 Screenshot 2014-01-12 22.20.52

Nun können wir den eben Entpackten Ordner öffnen und die darin befindende Arduino.exe anklicken. Dies Startet die Arduino IDE. Jetzt gehen wir auf „Tools/Board“ und wählen „Arduino Nano w/ ATmega 328“ aus und „Tools/Serieller Port“, dann die Nummer die uns im Gerätemanager angezeigt wurde (es ist meist die unterste).
Screenshot 2014-01-12 22.23.36 Screenshot 2014-01-12 22.24.38 Screenshot 2014-01-12 22.25.17
Hiermit ist die Einrichtung fertig und wir können alles einmal schnell testen. Klickt dafür auf „Datei/Beispiele/01. Basics/Blink“. Ein neues Fester geht auf und Ihr habt einen sogenannten Sketch offen. Das ist Quasi ein Programm für den Controller. Alles was wir jetzt aber machen möchten ist den Sketch uploaden (auf den Arduino Nano überspielen) und schauen was passiert. Hierzu oben Links auf den Pfeil drücken (Upload). Nun wird der Sketch „kompiliert“ und danach auf den Nano geladen. Wenn dies fertig ist hört das Grüne Blinken auf und Ihr seht jede Sekunde eine Rote LED Blinken. Wenn das geklappt ist habt Ihr alles geschafft. Glückwunsch. Sollte etwas nicht klappen seht euch bitte die Problemlösung der Arduino HP an.

Screenshot 2014-01-12 22.31.54 Screenshot 2014-01-12 22.32.34

Im nächsten Teil lernen wir dann wie wir unseren Code öffnen, Einstellungen setzen und diesen Hochladen.