INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Temp/RLF Graph auf SainSmart Mega 2560 R3
29.05.2014, 13:25 (Dieser Beitrag wurde zuletzt bearbeitet: 29.05.2014 13:42 von ArduTux.)
Beitrag #1
Temp/RLF Graph auf SainSmart Mega 2560 R3
Hallo Ardinos
Ich habe ja das SainSmart Mega 2560 R3 mit dem Touch Screen Display als Freizeit Bastelprojekt. Und seid knapp 14 Monaten in meiner Bastelecke damit am Werkeln. Ich gebe zu das ich am Anfang kurz davor gewesen bin, das ganze zum Elektronik Recycling-Hof zu bringen. OK, so eine Phase haben wir Bastler wohl alle mal durch gemacht. Jetzt bin ich sogar entspannter geworden und irgendwie hat das Arduino auch eine Therapeutische Wirkung auf mich gehabt...

Jetzt kommt wieder meine übliche Einleitung:
Ich habe ja keine Ahnung von Arduino und deshalb muss ich immer wieder betonen das ich ein "Arduino Ratatouille-Coder" bin, d.h. ich bastel mir aus irgendwelchen Code-Schnipzeln irgend etwas zusammen mit der Hoffnung es wird schon klappen.

Hardware:
SainSmart Mega 2560 R3 ATmega2560-16AU + ATMEGA16U2 + USB Cabe For 2013 Arduino
2x 4 & 1x 2 Channel Relay Module 5V 4 Kanal Relais Modul für Arduino DSP AVR PIC ARM
1x RTC DS1307 Echtzeituhr-Modul
2x DHT11

Schaltnetzteil Netzteil mit einem schönen 5V--/2,3A Ausgang geglättet. (12V verheitzt mir etwas zuviel am Arduino Spanungsregler, das kan schon mal heiß werden das ding.)
+ diversen Kleinkram wie: Cable-Juper Male/Female (leider habe ich noch nichts 40pol gefunden für das TFT, so das diese blöden Cable-Jumper leider noch zum einsatz kommen.

HEADER:
Code:
//#####################################
//---------------------------------- -Library TFT Touch Screen
#include <UTFT.h>
#include <UTouch.h>
//---------------------------------- -Library Real-Time-Clock
#include <DS1307.h>
//---------------------------------- -Library Sensor for Temp-RLF
#include <dht11.h>
//---------------------------------- -Library for Our Relay Shields
#include <relay8.h>
//---------------------------------- -Library for SD Card read-write
#include <tinyFAT.h>
#include <UTFT_tinyFAT.h>
#include <avr/pgmspace.h>
//---------------------------------- -Library String to Integer
#include <stdio.h>
#include <stdlib.h>
//######################################
//######################################
//----------------------------------- -Declare Touch Screen LCD
UTFTtf  myGLCD(ITDB32S, 38, 39, 40, 41);
UTouch  myTouch(6,5,4,3,2);
//----------------------------------- -Declare RTC Instanz
DS1307 rtc(20, 21);
Time  t;
//------------- -Declare1 Temp-RLF Sensors-Data-Pin
dht11 DHT111;
#define DHT111PIN 11
//------------- -Declare2 Temp-RLF Sensors-Data-Pin
dht11 DHT112;
#define DHT112PIN 12
//------------ -Declare Our Relay Pins, (A0-A5=54-59
relay8 relay0(58, 59, 60, 61, 62, 63, 64, 65);  //A8-A15
relay8 relay1(56, 57);  //A6+A7
//--------------- -- -Call Fonts
extern uint8_t SmallFont[];
extern uint8_t BigFont[];
//#######################################

Los geht´s:
Wir haben ja irgendwo in unserem Code die Temp/RLF Erfasst und könneen jetzt unsere Daten optisch etwas aufwerten.
Als erstes habe ich mir mit meinem lieblings Grafik-Tool Gimp eine passende Grafik für meine Graphen erstellt. Insgesammt habe ich dann 2 Bildchen gemacht 1x Temperatur 1x Luftfeuchtigkeit den DewPoint lasse ich erstrmal weg, wobei in vielen Fällen ja genau der DewPoint das interessante ist.

   

Die fertigen Grafiken dann also auf die SD-Card geschoben und wir schauen uns den Code an den ich dazu gebastelt habe.
Als erstes habe ich neben den TEMP/RLF Variablen noch eine ganze Menge an Variablen dazu gepackt.
Code:
//################################################################################​###################
//********************************************************************************​******************** -TEMP-GRAPH Variable
int t1dp0y1,t1dp1y1,t1dp2y1,t1dp3y1,t1dp4y1,t1dp5y1,t1dp6y1,t1dp7y1,t1dp8y1,t1dp9y1,​t1dp10y1,t1dp11y1;
int t1dp12y1,t1dp13y1,t1dp14y1,t1dp15y1,t1dp16y1,t1dp17y1,t1dp18y1,t1dp19y1,t1dp20y1​,t1dp21y1,t1dp22y1,t1dp23y1;
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
int t1p0y1=187; int t1p1y1=187; int t1p2y1=187; int t1p3y1=187; int t1p4y1=187; int t1p5y1=187; int t1p6y1=187; int t1p7y1=187;
int t1p8y1=187; int t1p9y1=187; int t1p10y1=187; int t1p11y1=187; int t1p12y1=187; int t1p13y1=187; int t1p14y1=187; int t1p15y1=187;
int t1p16y1=187; int t1p17y1=187; int t1p18y1=187; int t1p19y1=187; int t1p20y1=187; int t1p21y1=187; int t1p22y1=187; int t1p23y1=187;
//################################################################################​###################
//********************************************************************************​********************** -RLF-GRAPH Variable
int h1dp0y1,h1dp1y1,h1dp2y1,h1dp3y1,h1dp4y1,h1dp5y1,h1dp6y1,h1dp7y1,h1dp8y1,h1dp9y1,​h1dp10y1,h1dp11y1;
int h1dp12y1,h1dp13y1,h1dp14y1,h1dp15y1,h1dp16y1,h1dp17y1,h1dp18y1,h1dp19y1,h1dp20y1​,h1dp21y1,h1dp22y1,h1dp23y1;
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
int h1p0y1=187; int h1p1y1=187; int h1p2y1=187; int h1p3y1=187; int h1p4y1=187; int h1p5y1=187; int h1p6y1=187; int h1p7y1=187;
int h1p8y1=187; int h1p9y1=187; int h1p10y1=187; int h1p11y1=187; int h1p12y1=187; int h1p13y1=187; int h1p14y1=187; int h1p15y1=187;
int h1p16y1=187; int h1p17y1=187; int h1p18y1=187; int h1p19y1=187; int h1p20y1=187; int h1p21y1=187; int h1p22y1=187; int h1p23y1=187;
//################################################################################​####################

Ich habe einmal "dp" zwischen Variablen nehmen müssen da sonst im folgenden Code der Graph-Point nicht korrekt erechnet wurde. Die =187 ist die Y Coordinate quasi die "Null-Line" der x/y Achse. Benötigt wird das nicht aber ansonsten würde bei 0 die Line ganz Oben am Screenrand gezeichent.

Temp/RLF Daten vom Sensor in Coordinaten Punkte setzen:
Code:
void Update_Graph(){
t = rtc.getTime();
//**************************************** -0 Uhr
if (t.hour == 0 && t.min == 0 && t.sec == 0){
//---------------------------------------------------------- -Temp
int t1p0 = Temp1;   //aktuellen Wert übergeben
t1p0y1 = 0;
for (int tp0y1 = 0; tp0y1 < t1p0; tp0y1++)
t1dp0y1 = 187-((tp0y1-14)*9);
t1p0y1 = t1dp0y1;
//----------------------------------------------------------- -RLF
int h1p0 = RLF1;   //aktuellen Wert übergeben
h1p0y1 = 0;
for (int hp0y1 = 0; hp0y1 < h1p0; hp0y1++)
h1dp0y1 = 187-((hp0y1-29)*9)/2;
h1p0y1 = h1dp0y1;
//------------------------------------------ -Save Graph Point-0
SAVE_GRAPH_POINT_0();
}
.......
}
Das ganze habe ich insgesamt 24x in der Update_Graph() Funktion gequetscht.
Jede volle Stunde einmal Daten erfassen und auf SD-CARD als Graph-Points gespeichert.
Das ich bei der RLF nocheinmal am Ende den Wert durch /2 teile ist weil ich auf dem Home-Screen beide Graphen darstelle, damit Temp und RLF die gleiche Skala benutzen können RLF aber x2 abgelesen werden muss. Das *9 ergibt sich aus meiner Grafik, dort müssen ja die Pixel auf der Y-Achse mit der Grafik passend zusammen Treffen. (in der Skala = 9pixel pro °C).
Die 14 und 29 sind einfach nur die sogenannten Null-Punkte, eine Darstellung der Daten unter diesen Werten is nicht nötig. Die Skala für Temp beginnd somit bei 15°C und die RLF wird ab 30% auf den Screen gezeichnet.

Jetzt müssen wir noch den Graph auf den Screen zeigen lassen:
Code:
void Draw_Temp_Graph(){
myGLCD.setColor(0,255,0);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 0.00 Uhr
myGLCD.drawLine(21,t1p0y1,33,t1p1y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 1.00 Uhr
myGLCD.drawLine(33,t1p1y1,45,t1p2y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 2.00 Uhr
myGLCD.drawLine(45,t1p2y1,57,t1p3y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 3.00 Uhr
myGLCD.drawLine(57,t1p3y1,69,t1p4y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 4.00 Uhr
myGLCD.drawLine(69,t1p4y1,81,t1p5y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 5.00 Uhr
myGLCD.drawLine(81,t1p5y1,93,t1p6y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 6.00 Uhr
myGLCD.drawLine(93,t1p6y1,105,t1p7y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 7.00 Uhr
myGLCD.drawLine(105,t1p7y1,117,t1p8y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 8.00 Uhr
myGLCD.drawLine(117,t1p8y1,129,t1p9y1);
//------------------------------------------------------------------------------------------------------------ -Draw Line at 9.00 Uhr
myGLCD.drawLine(129,t1p9y1,141,t1p10y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 10.00 Uhr
myGLCD.drawLine(141,t1p10y1,153,t1p11y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 11.00 Uhr
myGLCD.drawLine(153,t1p11y1,165,t1p12y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 12.00 Uhr
myGLCD.drawLine(165,t1p12y1,177,t1p13y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 13.00 Uhr
myGLCD.drawLine(177,t1p13y1,189,t1p14y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 14.00 Uhr
myGLCD.drawLine(189,t1p14y1,201,t1p15y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 15.00 Uhr
myGLCD.drawLine(201,t1p15y1,213,t1p16y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 16.00 Uhr
myGLCD.drawLine(213,t1p16y1,225,t1p17y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 17.00 Uhr
myGLCD.drawLine(225,t1p17y1,237,t1p18y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 18.00 Uhr
myGLCD.drawLine(237,t1p18y1,249,t1p19y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 19.00 Uhr
myGLCD.drawLine(249,t1p19y1,261,t1p20y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 20.00 Uhr
myGLCD.drawLine(261,t1p20y1,273,t1p21y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 21.00 Uhr
myGLCD.drawLine(273,t1p21y1,285,t1p22y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 22.00 Uhr
myGLCD.drawLine(285,t1p22y1,297,t1p23y1);
//----------------------------------------------------------------------------------------------------------- -Draw Line at 23.00 Uhr
myGLCD.drawLine(297,t1p23y1,309,t1p0y1);
//------------------------------------
}
Hier ist jeweils 21,33,45,57,69 .... 309 die Aufteilung der X-Achse 24 std (0-23) für die richtigen Pixel.
Das ganze noch für die RLF Coden und mein Anfänger Graph ist fertig.

Jetzt habe ich viele Zeilen Code und einen Temp/RLF Graph, bestimmt lässt sich der Code vereinfachen aber verstehe ich dann noch alles?

So habe ich viel Tipp-Arbeit gehabt aber ich kann den Code nachvollzeihen. Ich habe schon in der Schule damals einie Feindschaft mit Algebra aufgebaut, darum tue ich mich heute schwerer als andere beim Arduino-Coden.
Jetzt wird auch klar warum ich mehr als 400 Files auf der SD-Card speichern möchte. Nur im Moment ist nach 17. Files schluss.

gruß

In unserer Gesellschaft ist das Gehirn am gerechtestesten Verteilt! Jeder glaubt, er habe genug davon.
Hardware: SainSmart Mega 2560 R3 + 3,2" LCD-Touch-Screen
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.05.2014, 15:52 (Dieser Beitrag wurde zuletzt bearbeitet: 29.05.2014 15:53 von rkuehle.)
Beitrag #2
RE: Temp/RLF Graph auf SainSmart Mega 2560 R3
Mmhhh,

erlaubt seien folgende Bemerkungen / Fragen (auch auf die Gefahr hin, dass ich völlig daneben liege) Huh

- du zeichnest Daten auf SD auf und möchtest sie (fortlaufend) darstellen ?
- warum nutzt du dann nicht die Möglichkeiten des Mega + UTFT ?
- sowohl das Gitternetz (oder wie immer es heißt) als auch die Graphen selbst kann man live aus abgespeicherten Werten darstellen
- selbst das nett geschriebene Wort "Temperatur" kann man so rauf bringen.

Wenn ich dich richtig verstehe gehts doch um folgendes:
- Daten erfassen -> auf SD mit Zeitangabe ablegen. Dateinamen aus Datum bilden
- Darstellung der erfassten Werte inklusive Gitternetz mit aus den abgelegten Werten berechneter Skalierung
- vielleicht noch Auswahl des Datums von dem die Werte dargestellt werden sollen?
- löschen alter Dateien ?

Ist alles machbar auf der Hardware ohne die Grafiken selbst, sondern nur die Werte zu speichern.
Aber wie gesagt: nur ein Kommentar, keine WertungExclamation
In jedem Fall: Alle Achtung vor der Leistung, die du reingesteckt hast
Grüße Ricardo

Nüchtern betrachtet...ist besoffen besser Big Grin
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
29.05.2014, 21:36
Beitrag #3
RE: Temp/RLF Graph auf SainSmart Mega 2560 R3
(29.05.2014 15:52)rkuehle schrieb:  Mmhhh .....

Hallo Ricardo
Sorry aber ich hab dann doch zu wenig Hintergund Infos mit reingeschrieben. Ich versuche es mal ...

-Ich Speichere die Graph Daten und alles andere eigentlich nur für den Fall das Reset oder Stromausfall eintritt.
-Wärend der normalen Betriebszeit sind ja die Variablen gefüllt.
-Die Grafiken habe ich gebastelt weil ich denke dadurch spare ich ja auch Code schreiberei.
Auch wenn es für viele von den Pros ne einfache Sache ist oder gar eleganter, wollte ich mich nich mit vielen verschiedernen Themen befassen müssen.
Das mit den Grafiken hat sich am Anfang so ergeben, da ich von NULL auf garnix im Arduino-Wissen eingestiegen war. Und wozu nen Touch Screen wen da nich schöne Bildchen drauf zu sehen sind Smile

Die Grafiken haben mir da viel Arbeit abgenommen... lol wobei das mit Gimp heraus zu finden auch nicht so fix ging ....

- MIt dem Darsstellen der Graphen ist das nicht Live?
... also wenn kein Stromausfall ist aktualisiert er ja jede volle Stunde die Graphen auf SD.

-Malen auf dem Home-Screen tut er die jede Minute mal neu, da ja das update interval auch jede minute rennt.
Da werden dann die live daten aktualisiert aber speichern mache ich nur einmal die Std.
Surfe ich dann zum Statistik Screen sehe ich ja die Live Graphen separiert in der gebastelten Grafik.
Vor-Zurück Button sind drin und Zurück zum Home-Screen is auch nen Icon links inner Ecke rechts inner ecke is ja zurück zum Statistik Main-Tab.

- Die Daten mit Zeiangabe und dem ganzen Statistischen zeug wollte ich als weitergehende Lektion in mein Code einpflegen Wink
Zur Zeit ist das ja extremst Anfänger Status.
Habe mein Code am laufen nun kommen die Feinheiten. Darum auch meine Anwesenheit hier im Forum.

Ich finds voll Super das jemand da ist der auch ein Mega2560 am Start hat. Smile und auch noch viel mehr Plan hat!

Ich werd noch mehr von mein Projekt hier Diskutieren in der Hoffnung ich kanns auch im laufe der Monate verbessern. Ist ja auch immer eine frage der Zeit.

Interessieren würde mich jetzt als erstes das Prob mit den Files die ich nicht ins root bekomme ohne Fehler dabei zu haben.
Das Prob hab ich kurz im anderen Thred erwähnt. Stelle dazu aber noch ne Spezielle Frage mit den nötigen Hintergrund Infos Wink

gruß

In unserer Gesellschaft ist das Gehirn am gerechtestesten Verteilt! Jeder glaubt, er habe genug davon.
Hardware: SainSmart Mega 2560 R3 + 3,2" LCD-Touch-Screen
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Datenübertragung vom Arduino Mega 2560 zu Hterm Datatom 1 99 13.11.2016 23:08
Letzter Beitrag: hotsystems
  Arduino Mega 2560 läuft nicht Wolfgang50 6 185 13.11.2016 10:50
Letzter Beitrag: Wolfgang50
  Arduino Mega 2560 Manfred1981 4 196 11.11.2016 18:07
Letzter Beitrag: hotsystems
  Dallas Temp Library und LiquidCrystal_i2c relay 20 468 27.10.2016 12:20
Letzter Beitrag: hotsystems
  Attiny45 Bootloader brennen mit Funduino Mega toto1975 63 2.220 23.10.2016 17:08
Letzter Beitrag: hotsystems
Question Mega 2560 defekt? triode 11 366 29.09.2016 07:21
Letzter Beitrag: hotsystems
  nrf24 an Mega 2560 jgrothe 2 167 10.09.2016 13:39
Letzter Beitrag: jgrothe
  Arduino mega 2560 mit TFT LCD Touch Shield V1 Clemens55555 17 947 02.08.2016 20:51
Letzter Beitrag: Clemens55555
  SainSmart 3.2 TFT + 5" TFT/SD Shield + Due SAM3X8E ARM (Arduino Due) Techniker_UE 13 3.241 24.07.2016 14:34
Letzter Beitrag: Eichner
  Mega: Hardware i2c bus speed (Wire.) verändern? HaWe 10 2.939 14.07.2016 20:09
Letzter Beitrag: Mathias

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste