Temperaturschreiber... PC Excel Kurve!

[Fighter-2]

Hey!

Ich habe eine Frage!


Ich habe für meinen Roller eine Abgastemperaturmessung gebastelt bzw werde die die Tage aufbauen!

Die Abgastemperatur wird von einem Thermoelement erfasst und auf einen LCD Display mit einem Atmega32 ausgegeben! ;)

Nun wollte ich fragen, ob es möglich wäre.. diese Temperaturen zuspeichern, die dan später mitm PC ab auszulesen und dann zB in Excel einzufügen um eine Temperaturkurve zubekommen!

Würde das irgentwie gehen?

LG Chris

[wassermann]

Hallo,

entweder gleich direkt über RS232 schicken oder per 24Cxyz bzw. SD/MMC speichern und dann später auslesen.

gruss,
wassermann

[python_rocks]

diese Temperaturen zuspeichern
Hallo Chris!

Wie viele Werte pro Minute? Was für ein Datentyp (Word, Single,...)?

mfg
Gerold
:-)

[Lordcyber]

HAllo,
da schliese ich mich doch an geht es genauso.
Würde diese gerne so alle 5min auf einer großen SD speichern.

[Fighter-2]

Also mein Controller bekomt am AD wandler ne Spannung rein.. abhängig von der Temperatur! Rechnet das um und zeigt mir den Wert einfach aufn LCD an ! ;)

Wie genau was für Datentyp ect... davon habe ich keinen Plan ^^.. wollte nur fragen.. ob das möglich ist und mit was fürn Aufwand das verbunden wäre?

Da ich ja am Roller keinen PC habe... wollte ich das zwischen speichern und dann später am PC auslesen lassen! ;) Wenn das geht?

[Jon]

Als Datentyp kann man mal ein Word annehmen, da ein Byte für einen Wert bis 1023 zu klein ist. Etwas zw. einem Word und einem Byte gibt es nicht.

Die Frage ist nun, fighter-2, wie viele Messungen pro Minute oder Stunde willst du speichern?
Abhängig davon reicht nämlich vielleicht der Speicher des µCs oder du brauchst wirklich noch eine SD Karte oder so.

jon

[Fighter-2]

achso ^^

Da sich die Temperatur ja sehr schnell verändert wollte ich schon alle 30sek mal einen Wert speichern!

Ich hatte mir aber auch überlegt.. sowas wie Start -- Stop mit ein zubauen, das man ganze auch nur dann startet.. wen der Motor läuft und wenn ich es brauche! :)

Ehm... die Uhrzeit wollte ich dann auch irgentwie mit rein bringen ;)

[python_rocks]

Ich hatte mir aber auch überlegt.. sowas wie Start -- Stop mit ein zubauen, das man ganze auch nur dann startet.. wen der Motor läuft und wenn ich es brauche!
Ehm... die Uhrzeit wollte ich dann auch irgentwie mit rein bringen
Hallo Chris!

Also das mit der Uhrzeit erschwert die Aufgabe ziemlich.

Wenn du aber nur jede Sekunden einen Messwert (2 Byte) in einen 24LC256 (32k I²C EEPROM) schreibst, und einfach bei jedem Motorstart als Wert "0" angibst, dann hast du laufende Werte vom Motorstart aus. Du kannst 16.000 Werte in den EEPROM schreiben.

16.000 / 60 / 60 = 4,4 Stunden je einen Messwert pro Sekunden

Wenn 4,4 Stunden genügt, dann würde ich vor Beginn der Messungen den EEPROM löschen und dann vollschreiben lassen. Wenn das EEPROM voll ist, die Messungen beenden.

Es gibt noch eine andere Möglichkeit: Man beschreibt das EEPROM im Kreis. Wenn man am Ende angelangt ist, dann beginnt man wieder von vorne. Aber dafür muss man mehr Aufwand treiben.

Den EEPROM kann man dann entweder mit einem kleinen selbstgebastelten Gerät auslesen oder man schließt ein RS-232-Kabel am Renngerät an und liest die Daten darüber aus.

Also von der Datenmenge her würde also ein EEPROM locker reichen. Und das Beschreiben und Auslesen eines EEPROMs ist ziemlich einfach.

Für das Beschreiben einer mit FAT formatierten SD-Card ist mir noch kein gutes Bascom-Rezept untergekommen. Vielleicht ist es einfacher wenn man AVR-DOS kauft. Aber darüber können andere sicher mehr schreiben.

lg
Gerold
:-)

PS: Was ist aus der Rückleuchte geworden?

[Fighter-2]

Die Sachen für die Rückleuchte sind bestellt! ;)

Nur sind se noch net da!? Warte schon 2 wochen! -_-

Ehm... ja die Uhrzeit muss ja dann nicht dabei sein! ;)

Ich wollte son Start und Stopp Taste verwenden! ;)

Ja 4,4 Stunden reichen ;)

[python_rocks]

Interessante Lektüre :-)

staff.ltam.lu/feljc/electronics/bascom/Speicherkarten_Low_Level.pdf

[izaseba]

Hallo,
Für Deine Aufgabe ist der AVR Butterfly perfekt.
Onboard Hast Du :
1. Eine RS232 Schnittstelle für die Komunikation mit dem PC
2. Einen Uhrenquarz, mit dem die Uhrzeit ganz leicht zu realisieren ist
3. Mehrere freie ADC Eingänge
4. Einen serielen Flashspeicher mit 4MBit

Das ganze wird mit einer 3V Knopfzelle betrieben und hat die Größe einer Checkkarte

Gruß Sebastian

[Fighter-2]

Mh... ich weiß net.. ich mein ich brauch das net!

Ich dachte mir das so.. das ich quasi von meinem Temperaturmesser die Daten an einen anderen Controller sende und dort speichere!

Am Temperaturmesser hängen ja noch andere Dinge wie Port Abfragen ect !;)

[python_rocks]

Wie genau was für Datentyp ect... davon habe ich keinen Plan ^^.. wollte nur fragen.. ob das möglich ist und mit was fürn Aufwand das verbunden wäre?
Hallo Chris!

Das sind keine guten Voraussetzungen. Um einen Wert per I²C in ein EEPROM zu schreiben, sollte man doch irgendwie einen Überblick über die Datentypen haben. ;-)

Die Frage des Aufwandes:

1.) Wenn das Programm gestartet wird, dann muss das EEPROM ausgelesen werden um herauszufinden, wo der freie Speicher beginnt. Sobald dieser gefunden wurde, legt man die Speicheradresse in einer Variabl ab. Dann schreibt man noch zwei mal hintereinander 0 in den EEPROM um den Start der neuen Messreihe zu kennzeichnen.

2.) Ein Timer sollte jede Sekunde einen Interrupt auslösen. In diesem Interrupt wird die im Hintergrund gemessene Spannung (vom Analog Digital Converter) in eine Variable geschrieben.

3.) In der Hauptschleife wird geprüft ob die vom Interrupt befüllte Variable einen Wert enthält. Wenn nicht, dann wird mit die Schleife fortgesetzt. Wenn der Wert da ist, dann wird die Speicheradresse um zwei Byte erhöht und dann wird der Wert (2 Byte) in einem Rutsch ins EEPROM geschrieben. Falls die Speicheradresse 32000 erreicht, dann wird die Speicheradresse auf 0 gesetzt um weiteres Schreiben in den EEPROM zu verhindern.

3.) Wenn eine besondere Taste oder Tastenkombination gedrückt wird, dann soll der EEPROM gelöscht werden. Dafür schreibt man einfach in alle 32.000 Speicherbereiche 0xFF rein.

4.) Den EEPROM auf einem Sockel unterbringen, dass man diesen ausbauen und am Computer auslesen kann. Ein kleines Gerät dafür bauen ist einfacher als diesen ganzen Mist im Hauptprogramm des Renngerätes unterzubringen. Außer man hat sowiso vor, das Renngerät per RS-232 mit dem Computer zu verbinden. Dann geht es natürlich in einem Rutsch. :-)

lg
Gerold
:-)

[python_rocks]

von meinem Temperaturmesser die Daten an einen anderen Controller sende und dort speichere!
Hallo Chris!

Das vereinfacht die Sache. Dann schickst du von deinem Temperaturmesser-µC aus die Daten an den Mikrocontroller, der sich um das Speichern kümmert.

Dann bist du im Haupt-µC die Sorgen über das Speichern los und kannst dich dort um wichtigere Aufgaben kümmern. Und im µC der sich um das Speichern kümmert, kannst du jeden Aufwand betreiben den du haben möchtest. Du kannst am Anfang ganz simpel alles der Reihen nach in den EEPROM schreiben. Später kannst du eine batteriegepufferte Echtzeituhr mit anschließen und die Werte mit Uhrzeit versehen in einen größeren EEPROM oder sonstwohin schreiben.

Du solltest nur die Daten so übertragen, dass für den Haupt-µC keine Wartezeit entstehen kann. Also z.B. per SPI oder SHIFTOUT. SPI ist sehr schnell und wäre meine Wahl für so etwas. Und da der Ziel-µC die Daten nur empfangen muss, genügen zwei Leitungen dafür.

Aber das ist alles eine Frage des Gesamtdesigns. Wir wissen ja nicht welche Ressourcen noch wie frei sind und wie ausgelastet der Haupt-µC ist.

lg
Gerold
:-)

PS: Da fällt mir noch ein: Wenn du das alles sowiso in einen eigenen z.B. ATmega8 auslagerst, dann ist es auch kein Problem, dort die Kommunikation mit dem Computer per RS-232 mit einzubauen. Dann hocht man einfach auf ein Kommando vom Computer und wenn dieses kommt, dann wird der gesamte EEPROM ausgelesen und an den Computer übertragen. Und wenn ein bestimmtes Kommando vom Computer kommt, dann löscht man den EEPROM.

.

[Fighter-2]

Ja ich würde nur ab und zu mal die Daten auslesen! ;)

Also zB nach nen Sprint mal die Daten übertragen und dann im Excel speichern und den Controller wieder "LEEREN" damit wieder genügend Platz ist!

Könnte man den so eine Auswertung machen in Excel? das ich qusi einfach die Temperaturenwerte gespeichert bekomme!? :)

Am Haupt Contoller hängt

das Grafikdisplay 128x64

zwei Temperaturmessungen einem Abgas und einem Kühlwassertemperatur

dann verschiedene Abfragen und Spielerreien!

Dann noch der Füllstandssensor... der mir ne Warnung ausgibt.. wenn der Sprit alle wird! ;)

[python_rocks]

Könnte man den so eine Auswertung machen in Excel? das ich qusi einfach die Temperaturenwerte gespeichert bekomme!?
Hallo Chris!

Du kannst dir für später sogar überlegen, nicht nur die Abgastemperaturen zu speichern.

Die Daten kannst du über RS-232 in den Computer überspielen. So ein Steuerprogramm, mit dem die Daten ausgelesen und in eine Excel-Datei geschrieben werden und mit dem man auch das Signal zum Löschen geben kann -- ist kein Problem. So etwas stampfe ich mit Python in einer Stunde aus dem Nichts. ;-) Wenn es so weit ist, helfe ich dir da gerne aus.

Wenn du die Daten vom Haupt-µC zum Speicher-µC überträgst, dann solltest du zur Temperatur auch ein zusätzliches Steuersignal übermitteln, damit der Messwert als "Temperatur" erkannt wird. So versperrst du dir nicht die Möglichkeit, auch andere Werte speichern zu lassen.

Wenn man als Code für eine Temperaturmessung den Buchstaben "a" (hex 0x61) ausmacht und die Temperatur eine WORD-Zahl (z.B. hex 0xAABB) ist, dann könnte ein Telegramm z.B. so aussehen:

SOH | 0x61 | STX | 0xAABB | EOT
Das wären nur 6 Byte die einmal die Sekunde vom Haupt-µC zum Speicher-µC übertragen werden.

Die Bedeutung von SOH, STX und EOT findest du hier: http://halvar.at/elektronik/rs232/

Falls du später vorhast, auch andere Messwerte zu übertragen, brauchst du nur ein neues Telegramm erfinden. Z.B. könnte der Buchstabe "b" (hex 0x62) die Kühlertemperatur kennzeichnen:

SOH | 0x62 | STX | 0xBBAA | EOT
Diese Codes lassen sich mit SPI sehr leicht und schnell vom Haupt-µC zum Speicher-µC übertragen. Wie und wo der Speicher-µC die Daten speichert ist dem Haupt-µC egal. So kann der Speicher-µC jederzeit durch eine leistungsfähigere/bessere Lösung ausgetauscht werden, ohne dass der Haupt-µC etwas davon merkt.

ASCII-Codes: https://www.roboternetz.de/phpBB2/posting.php

Da fällt mir noch ein, dass du damit auch Statuscodes speichern kannst. Einfach einen neuen Header erfinden und einen Code für die Statusmeldung übertragen...

Ich liebe solche Spielereien und das Ausmalen eines Gesamtkonzeptes. :-) Ich glaube, das ist der Grund dafür, dass ich Programmierer geworden bin. ;-)

mfg
Gerold
:-)

[Fighter-2]

Jop wäre schon genial! Wenn ich noch mehrere Werte hätte! :)

Dann könnt ich schauen, wie sich die Abgastemperatur zur Wassertemperatur verhält!

Nur man müsste schauen.. das beide Kurven zeitgleich und nicht versetzt aufgezeichnet werden.... damit man einen Vergleich aufstellen kann! :)

Die Uhrzeit wäre auch Interessant! :)

Später vieleicht auch mal eine Drehzahl? Das ist aber erstmal nicht nötig, den ich habe andere Anzeige Instrumente dafür! ;)

Gerold ich finde das du echt ein super User hier im Forum bist ! :) Du erklärst immer gut und hilfst einen ordentlich! :) Finde ich einmalig!! :)

Ich muss mich echt bei dir bedanken! :) Solche Leute gibt es leider nur selten, die sich richtig viel mühe geben und sich auch da rein denken! :) einfach klasse... danke! :)

Ich kann mit meinem "mysmartUSB" doch auch die Daten übertragen oder? Oder kann man das einfach über SUB D machen? :)

Deine Seite ist echt cool!

LG Chris

[python_rocks]

Ich kann mit meinem "mysmartUSB" doch auch die Daten übertragen oder?
Hallo Chris!

Der mySmartUSB ist ideal dafür, den kannst du direkt an die RX- und TX-Pins des µC anschließen und dir die Daten zum Computer saugen.

lg
Gerold
:-)

PS: Und das Firmware-Update für den mySmartUSB nicht vergessen: http://www.loetstelle.net/forum/viewtopic.php?p=6851#6851
;-)

[Fighter-2]

Update gemacht! :)

Da hast du dir echt viel Mühe gegeben auf der Seite!! TOP!!

Also ist das alles möglich was ich vor habe.. cool! :)


Also dann mache ich das echt so mit dem Haupt Controller und dem Speicher Controller!

Es gibt doch einen Atmega mit 164kb Speicherplatz oder? Würde das reichen? Oder wäre eine SD Karte von Vorteil?

Mh.. bin mir da nicht so sicher! ;)

Wie sollte ich nun vorgehen? :) Boar das wird echt genial... freue mich voll! :)

LG Chris

[python_rocks]

Es gibt doch einen Atmega mit 164kb Speicherplatz oder? Würde das reichen? Oder wäre eine SD Karte von Vorteil?
Hallo Chris!

Ich meinte einen ATmega8 zum Datenloggen -- aber nicht als Speicher, sondern als Verwalter des Speichers. Und als Speicher einen (bis zu vier) von diesen I²C-EEPROMs:
http://www.alldatasheet.com/datasheet-pdf/pdf/194692/MICROCHIP/24LC256.html

Weil das Beschreiben und Auslesen dieser EEPROMs sehr einfach ist -- im Gegensatz zum Beschreiben einer SD-Karte.

lg
Gerold
:-)

[Fighter-2]

Ja dann machen wir das so! :)

Gute Sache! :)

[Fighter-2]

Wie fängt man nun das ganze an? :)

Erstmal müsste man ja eine Verbindung zwischen Hauptcontroller und Speichercontroller herstellen, zusätzlich dann noch zwischen Speichercontroller und Speicher! ;)

Wie wird die Komunikation den hergestellt? :) Gibt es dazu.. was zum nachlesen? ;)

[Lordcyber]

Hallo,
wie ja schon bekannt ist habe ich das selbe Problem mit Tranportablen Daten.
Daher ja fand ich das mit SD CArd Klasse.
Da nun hier auf den 24LC256 umgeschwenkt wurde da das ja einfacher sein soll hab ich mir das auch überlegt.
Aber will ja nicht unnötig Kabel verlegen oder ganze Einheit abbauen.
Der Chip Kam mir irgendwie bekannt vor. Nach etwas Recherage kam ich drauf. Habe noch 2 FunCards hier aus alter Irdeto ZEit.
Daher könnte man die Daten nicht auf eine CARD AT90SC8515/24LC256 ( FUN 4 ) schreiben die dan rausziehen und am PC auslesen??
Danke.

[python_rocks]

Da nun hier auf den 24LC256 umgeschwenkt wurde da das ja einfacher sein soll hab ich mir das auch überlegt.
...
Aber will ja nicht unnötig Kabel verlegen oder ganze Einheit abbauen.
Hallo Lordcyber!

Der 24LC256 (http://www.alldatasheet.com/datasheet-pdf/pdf/194692/MICROCHIP/24LC256.html) oder der M24512-WMW6 (http://www.alldatasheet.com/view.jsp?Searchword=M24512-WMW6) (mit 512 kBit Speicherplatz), sind beide I²C-Clients und könnten über ein sehr einfaches I²C-Protokoll beschrieben und ausgelesen werden. I²C sind zwei Leitungen an die alle I²C-Geräte gemeinsam angeschlossen werden. Ich persönlich hätte den ATmega8 und den 24LC256 direkt nebeneinander auf eine kleine Lochrasterplatine gesteckt. Also nichts mit langen Leitungen. Und an diese Platine einen kleinen dreipoligen Stecker (oder damit es stabiler wird ein sechspoliger Wannenstecker) zum Anschließen des mySmartUSB als USB-UART-Adapter verwendet. Der ATmega8 kostet keine 2 Euro und der 24LC256-I/P (http://www.conrad.de/goto.php?artikel=150234) kostet bei Conrad 2,86 Euro. Wahrscheinlich lässt er sich wo anders um weniger Geld bekommen. Das waren meine Überlegungen zu diesem Thema.


AT90SC8515/24LC256 ( FUN 4 )
OK, dann lass mich mal darüber nachdenken.

Scheint nicht uninteressant zu sein. Allerdings (glaube ich irgendwo gelesen zu haben) werden diese Karten per I²C angesteuert. Oder war es doch 1-Wire?

Egal. Damit müsste man mehr Programmlogik in den Haupt-µC verlagern. Die Daten könnten also per I²C an die Karte übergeben werden. Die Karte müsste dann noch auf eine I²C-Echtzeituhr zugreifen und dann die Daten in den EEPROM schreiben. Wie sieht dann die Lösung aus, wenn ich später doch noch auf miniSD oder MMC als Speichermedien umsteigen möchte, da dort doch viel, viel mehr Speicherplatz zur Verfügung steht? Wenn ich alles über einen ATmega8 mache, dann tausche ich den EEPROM gegen einen Kartenslot. Mir scheint so eine Karte auch ein wenig groß. Aber alles hat seine Vorteile und Nachteile. Die ersten Nachteile an der Karte sind, dass man sich in die Programmierung von I²C als Slave einlesen muss und ich halte diese Karten für extrem überteuert.

Außerdem, wenn man von der Karte aus per I²C auf eine Echtzeituhr zugreifen möchte, dann wäre die Karte der I²C-Master. Das bedeutet, dass man die gesamte I²C-Lösung als "Multimaster" konzeptionieren muss. -- Das macht die Sache unter Bascom viel schwieriger. -- Das ist das KO-Argument. Die Karte zwingt mich in den I²C-Multimaster-Modus, sobald ich Daten von einer Echtzeituhr haben möchte. Außer ich hole die Daten von der Echtzeituhr bereits in den Haupt-µC. Also doch mehr Logik in den Haupt-µC verlagern. Gleichstand?

Chris braucht nicht mehr Speicher als ein M24512-WMW6 zur Verfügung stellen kann. Und das Auslesen der Daten über einen kleinen Stecker ist auch nicht das Problem. Außerdem kann man die Schaltung (ATmega8 und M24512-WMW6) auf einer kleinen Lochrasterplatine unterbringen, die man mit einem Wannenstecker auf die Hauptplatine aufstecken kann. Somit könnte man dieses Teil sogar abstecken und zum Auslesen zum Computer bringen.

Aber jetzt habe ich den KO-Schlag für die Karte. ;-) -- Ich habe einen ATmega8 und ich habe einen 24LC256 mit dem ich eine Testschaltung aufbauen kann. Aber ich habe keine "CARD AT90SC8515/24LC256 ( FUN 4 )" mit der ich experimentieren kann. Ich habe auch keinen Slot für so eine Karte und glaube nicht, dass ich das Geld dafür ausgeben werde, nur um damit Tests machen zu können.

So nebenbei: Ich habe soeben die I²C-Echtzeituhr PCF8563 bei Segor gefunden: http://cgi.segor.de/user-cgi-bin/sidestep2.pl?foto=1&Q=8563&M=1
Vielleicht kann man damit sogar etwas anfangen. Ich merke es mir zumindest schon mal vor.

Ich muss jetzt Schluss machen.

lg
Gerold
:-)

[python_rocks]

Hallo Lordcyber!

Meinen obigen Beitrag bitte nicht falsch verstehen. Ich schließe die Funcard als ideal Lösung für Chris aus. Aber du hast diese ja bereits. Ich weiß ja nicht wieviel Daten du sammeln möchtest. Aber für dich könnte das natürlich eine Lösung sein. Du müsstest dich aber in I²C als Slave einlesen. Außerdem weiß ich nicht mit was du programmierst. Von Chris weiß ich, dass er mit Bascom arbeitet. Dort ist I²C als Master sehr einfach. I²C als Slave muss man selber programmieren.

Welche Datenmenge kommt denn bei dir so zusammen? Was sind die Anforderungen?

lg
Gerold
:-)

[python_rocks]

Wie fängt man nun das ganze an? :)

Erstmal müsste man ja eine Verbindung zwischen Hauptcontroller und Speichercontroller herstellen, zusätzlich dann noch zwischen Speichercontroller und Speicher! ;)

Wie wird die Komunikation den hergestellt? :) Gibt es dazu.. was zum nachlesen? ;)
Hallo Chris!

Ich kann dir nur erzählen, wie ich die Sache angehen würde. Wie du an die Sache herangehen sollst, weiß ich nicht.

Ich würde mir zwei ATmega8 nehmen. Einen davon in mein Experimentierboard von Roland Walter und einen in mein (hoffendlich bald geliefertes) Pollin Experimentierboard. Auf dem Pollin Experimentierboard ist auch ein Sockel für einen EEPROM mit drauf. -- Lass mich mal im Schaltplan nachsehen ob der per I²C angesteuert werden kann. -- Ja, passt genau. Allerdings ist Adresse des EEPROM fest auf "000" gestellt. Aber damit kann man leben. :-)

Beide Experimentierboards haben einen MAX232 an Board und können somit über RS-232 an den Computer angeschlossen werden. So übertrage ich später Meldungen zum Debuggen der Programme zum Computer. Mehr brauche ich zum Debuggen nicht.

Als Erstes würde ich mich um das Ansprechen des EEPROMs per I²C kümmern.

Also würde ich ein paar Funktionen dafür schreiben, die das Ganze kapseln.


sub ee_erase(byval slave_address as byte)
... und hier stehen die Befehle zum Löschen des EEPROMs
end sub

function ee_first_free_address(byval slave_address as byte) as word
...hier wird herausgefunden bis zu welcher Adresse das EEPROM bereits beschrieben wurde.
Die erste freie Adresse wird zurück gegeben.
end function

sub ee_write_temperature(byval slave_address as byte, byval temperature as word)
...
end sub
OK, ich halte mich kürzer. Ich würde mich also zuerst mal um die Kommunikation zwischen dem µC und dem EEPROM kümmern. Alle Prozeduren und Funktionen schreiben, die dafür notwendig sind dass das EEPROM gelöscht, ausgelesen und beschrieben werden kann.

Dann würde ich mich um die Kommunikation zwischen dem µC und dem Computer kümmern. Es muss ja per RS-232 eine Verbindung hergestellt werden können. Der Computer muss eine Anweisung erteilen und der µC muss darauf reagieren.

Es macht keinen Unterschied, ob du per RS-232 und einem MAX232 an den µC fährst oder ob du später mit dem mySmartUSB direkt an RX und TX ran fährst.

Ein Befehl sollte mit RETURN ``chr(13)`` abgeschlossen werden. Denn dann kannst du im µC mit INPUT arbeiten um die Befehle zu empfangen. Siehe: http://halvar.at/elektronik/rs232/

Du könntest also z.B. über die UART den Befehl "READ ALL" schicken. Dieser wird von INPUT ausgelesen. Dann analysiert man den Befehl. Mit SELECT CASE kannst du auf verschiedene Befehle reagieren.

Bei "READ ALL" würdest du also per I²C den EEPROM von vorne bis hinten auslesen und jedes Byte über die UART an den Computer zurück schicken.

Bei "DELETE ALL" würdest du per I²C den EEPROM von vorne bis hinten mit 0xFF vollschreiben.

Wenn das Lesen, das Schreiben und die Kommunikation mit dem Computer hinhaut, dann kannst du dich um die Kommunikation mit dem Haupt-µC kümmern. Aber bevor du den Haupt-µC umprogrammierst, würde ich den zweiten ATmega8 als Ersatz dafür verwenden und zuerst das Programm auf diesem entwickeln. Erst wenn alles läuft und die Tests erfolgreich waren, dann würde ich die Funktionen für die Übertragung der Temperaturdaten in den Haupt-µC einbauen.

Die Kommunikation zwischen dem Haupt-µC und dem Speicher-µC könnte per SPI passieren. So lange kein weiteres Gerät am SPI-Bus hängt, genügen zwei Leitungen zwischen Haupt-µC und dem Speicher-µC dafür.

Links zu SPI mit Bascom:
- http://avrhelp.mcselec.com/index.html?config_spi.htm
- http://avrhelp.mcselec.com/index.html?spiin.htm
- http://avrhelp.mcselec.com/index.html?spiout.htm
- "spi-slave.bas" im Bascom-SAMPLES-Ordner.
- http://avrhelp.mcselec.com/index.html?using_the_spi_protocol.htm

Man schickt also die Temperatur, in ein Ticket verpackt, über den SPI-Bus vom Haup-µC zum Speicher-µC. Dieser analysiert das Ticket und ruft die zugehörige Prozedur auf, die sich darum kümmert, dass der neue Messwert an die richtige Stelle im EEPROM geschrieben wird (per I²C).

Über die UART können Befehle vom Computer kommen. Wird der Befehl zum Löschen des EEPROM gegeben, dann wird dieser gelöscht. Wird der Befehl zum Auslesen des EEPROM gegeben, dann liest der Speicher-µC die Daten vom EEPROM und gibt diese über die UART an den Computer zurück.

Wenn das alles mal im Renngerät läuft und getestet wurde, dann kann man sich Gedanken darüber mache, was noch super wäre und wie man dieses Logging aufpeppen könnte.

Jetzt mache ich mir ein Mittagessen. :-)

lg
Gerold
:-)

[python_rocks]

Hallo!

Ich traue mich meine Versuche gar nicht hier rein zu stellen. Da wird jetzt sicher einer sagen, was verzapft dieser Anfänger denn da für einen Blödsinn. :-| Es geht um das Auslesen und Beschreiben eines 24LC256 EEPROM.

Man wird unweigerlich merken, dass ich aus der GUI-Anwendungs-Programmierung komme und noch nicht lange mit den AVRs arbeite. Aber besser bringe ich es im Moment nicht zusammen. Irgendwie scheinen die Prozeduren und Funktionen im Bascom erschreckende Einschränkungen bez. Variablen zu haben. Keine Arrays, keine Overlays. Mit ``byval`` deklarierte Parameter lassen sich innerhalb der Funktion nicht bitweise verändern. Man muss sie vorher in eine andere Variable kopieren. Habe ich noch etwas übersehen? ;-)


$regfile = "M8def.dat"
$crystal = 8000000
$hwstack = 32
$swstack = 10
$framesize = 40
$baud = 38400


Declare Sub Eeprom_write_byte(_
Byval Slave_address As Byte , Byval Data_address As Word , _
Byval Value As Byte _
)
Declare Function Eeprom_read_byte(_
Byval Slave_address As Byte , Byval Data_address As Word _
) As Byte


'TWI (I²C)
$lib "i2c_twi.lbx" 'Hardware TWI einschalten
Config Scl = Portc.5
Config Sda = Portc.4
Const Slave_address = &B10100000
Config Twi = 400000
I2cinit


'TEST --------------------

Dim W As Word
Dim Bt As Byte


For W = 0 To 200
Bt = W
Call Eeprom_Write_byte(slave_address , W , Bt)
Print "written:" ; Bt
Next W

For W = 200 To 0 Step -1
Bt = Eeprom_Read_byte(slave_address , W)
Print "read:" ; Bt
Next W

'TEST --------------------


End



Sub Eeprom_write_byte(_
Byval Slave_address As Byte , Byval Data_address As Word , _
Byval Value As Byte _
)

Local Slave_w As Byte
Local Slave_r As Byte
Local Addr_high As Byte
Local Addr_low As Byte

Slave_w = Slave_address And &B11111110
Slave_r = Slave_address Or &B00000001

Addr_high = High(data_address)
Addr_low = Low(data_address)

I2cstart
I2cwbyte Slave_w
I2cwbyte Addr_high
I2cwbyte Addr_low
I2cwbyte Value
I2cstop

Waitms 5

End Sub


Function Eeprom_Read_byte(_
Byval Slave_address As Byte , Byval Data_address As Word _
) As Byte

Local Slave_w As Byte
Local Slave_r As Byte
Local Addr_high As Byte
Local Addr_low As Byte
Local Retval As Byte

Slave_w = Slave_address And &B11111110
Slave_r = Slave_address Or &B00000001

Addr_high = High(data_address)
Addr_low = Low(data_address)

I2cstart
I2cwbyte Slave_w
I2cwbyte Addr_high
I2cwbyte Addr_low
I2cstart
I2cwbyte Slave_r
I2crbyte Retval , Nack
I2cstop

Eeprom_Read_byte = Retval

End Function

@Chris:
Das Beschreiben und Auslesen des EEPROM funktioniert schon mal.

lg
Gerold
:-)

[Lordcyber]

Hallo Lordcyber!

Meinen obigen Beitrag bitte nicht falsch verstehen. Ich schließe die Funcard als ideal Lösung für Chris aus. Aber du hast diese ja bereits. Ich weiß ja nicht wieviel Daten du sammeln möchtest. Aber für dich könnte das natürlich eine Lösung sein. Du müsstest dich aber in I²C als Slave einlesen. Außerdem weiß ich nicht mit was du programmierst. Von Chris weiß ich, dass er mit Bascom arbeitet. Dort ist I²C als Master sehr einfach. I²C als Slave muss man selber programmieren.

Welche Datenmenge kommt denn bei dir so zusammen? Was sind die Anforderungen?

lg
Gerold
:-)
Hallo,
Arbeite ebenfalls mit Bascom.
DS1307 ist bei mir mit dabei. Kernstück Atmega 2561
Wird ein Steuerkomputer für meien Meerwasserbecken.
Daten sind:
2X Temparatur DS1631 alle 5 min mit Zeit
Leitwert alle 5 min
Zeit der Nachfüllung
Menge der NAchfüllungen
Ph Wert alle 5 min.
Da ich keine Lust habe den jeden Tag auszulesen währe das mit einem Großen Speicher Ideal. Denke mal so jeden bis alle 2 Monate
Soll alles in Excel ausgewertet werden.
Wie gesagt Kabel verbindung wegen entfernung zu groß.
Überlege gerade wie es mit AVR-DOS dafür aussieht.
Danke

[python_rocks]

Überlege gerade wie es mit AVR-DOS dafür aussieht.
Hallo Lordcyber!

Bei deinem µC dürfte AVR-DOS funktionieren. Und für nicht-kommerzielle Anwendungen ist AVR-DOS gratis.

- http://www.mcselec.com/index.php?option=com_content&task=view&id=20&Itemid=41
- http://members.aon.at/voegel/


Soll alles in Excel ausgewertet werden.
Ideal wäre es, die Daten im CSV-Format (http://de.wikipedia.org/wiki/CSV_%28Dateiformat%29) abzuspeichern. Dieses Format kann Excel direkt öffnen.

mfg
Gerold
:-)

[Lordcyber]

Habe dan mal neuen Thread gemacht. Damit nicht alles hier landet.
Weil ja noch mehr unklarheiten sind.

[python_rocks]

Habe dan mal neuen Thread gemacht. Damit nicht alles hier landet.
Weil ja noch mehr unklarheiten sind.
Hallo Lordcyber!

Hast du einen Link zum Thread?

In einem der beiden Links ist ein lauffähiges Beispiel mit dabei. Du erstellst für jeden Tag eine neue Datei. Diese öffnest du zum Eintragen eines Messwertes mit dem Parameter APPEND und schließt sie danach wieder. Die Daten werden angefügt.

Und dein Controller sollte das auf jeden Fall schaffen. Dieses Ding kostet ja über 15 Euro. :-)

Damit du die Karte jederzeit rausnehmen kannst, würde ich noch über eine Taste den Logger ein- und auschaltbar machen. Eine kleine LED kann ja anzeigen, ob der Logger eingeschaltet ist.

mfg
Gerold
:-)

[Lordcyber]

Hallo,
genau das war auch meien Frage kann ich die einfach entfernen??
Also Link ist:
https://www.roboternetz.de/phpBB2/viewtopic.php?p=360253#360253

[Fighter-2]

Hey! Ich habe leider übersehen das hie rweiter geschrieben worden ist! :(

Es kam auch keine Email oder so...


NUn im Moment habe ich keinen Durchblick hier.. den habe gerade Stress ... muss das erstmal klären! :(

Aber noch was anderes... ich muss erstmal den Haupt Controller ans laufen bekommen und dann können wir den Speicher Con. machen! :) Oder? Da steckt auch noch bissel Arbeit drinne.. aber den sollte ich schaffeN! :)

Ich bestelle nun erstmal paar Dinge dafür das ich alles zusammen stellen kann! ;)

Aber für den Speicher Controller könnte ich die Parts ja direkt mit bestellen! :) Dann spare ich Porto ^^

Wäre schön wenn ihr mir sagen könntet das ich bestellen solL! :)

LG Chris

[python_rocks]

Wäre schön wenn ihr mir sagen könntet das ich bestellen solL!
Hallo Chris!

Vorschläge:
- http://www.pollin.de/shop/shop.php?cf=suche_ergebnis.php&S_TEXT=100+922&btn_submit=Suchen&ts=0
- http://shop.embedit.de/product__114.php
- http://shop.embedit.de/product__182.php
- http://shop.embedit.de/product__189.php
- http://shop.embedit.de/product__336.php
- http://shop.embedit.de/product__126.php
Und falls du noch kein Evaluationsboard hast:
- http://www.pollin.de/shop/shop.php?cf=detail.php&pg=NQ==&a=MTY5OTgxOTk=

mfg
Gerold
:-)

[Fighter-2]

Ah gut! Danke! :)

Die Sockel und die Wannenstecker ect

Brauch ich net ^^ Weil ich habe noch viele Sachen hier rum fliegen in meiner Kramkiste! :) Den ich arbeite Samstags in der Computerfirma, wo ich schonmal defekte oder alte Mainboards schlachte! :) Deswegen habe ich viele kleinigkieten schon da! :)

Aber den Atmega und den EEPROM werde ich bestellen danke! ;)

Da ich eh bei Pollin bestellen wollte kommt das perfekt! :)

DANKE!! :)

dat evo Board werde ich mir auch noch bestellen! ;)