Hi @ all,
folgendes Problem: Ich steuere ein Magnetventil mittels ATmega32 an.
Meine Schleife sieht aktuell so aus (nur zur Orientierung, wie Ablauf
aussieht):
Do
'PC2: Signal einschalten (HIGH)
Portc.2 = 1
'xx Sekunden Warten
Waits 3
'PC2: Signal ausschalten (LOW)
Portc.2 = 0
'xx Sekunden Warten
Waits 60
Loop
Jetzt würde ich gerne die delay-Zeiten über eine GUI steuern können.
Sprich zwei Textfelder die mittels Buttonklick die Zeiten in meinem
Quellcode ändern. Desweiteren wäre es klasse, wenn man noch einen Button
programmieren kann, der den Quellcode kompiliert und in den
Mikrocontroller überträgt.
Würde mir gerne das übertragen von Steuersignalen an den USART ersparen,
da ich lesen musste, dass das erlenen und erstellen einer GUI einen sehr
langen Zeitraum (6 Monate für Anfänger?!) in Anspruch nimmt.
Ja ich weis, du fauler Hund, zu bequem um etwas Neues zu erlernen, nur
leider ist für dieses Projekt der zeitliche Rahmen begrenzt. Könnte
maximal zwei Monate investieren :-(!
Deshalb bin ich auf der Suche nach einem Programm, mit dem man die oben
aufgeführten Anforderungen umsetzen kann.
Gibt es so etwas auf dem Markt?
Gehe auch gerne näher auf Details ein, falls es Fragen zum Projekt gibt.
Danke schon mal für die Hilfe
>Jetzt würde ich gerne die delay-Zeiten über eine GUI steuern können.>Sprich zwei Textfelder die mittels Buttonklick die Zeiten in meinem>Quellcode ändern. Desweiteren wäre es klasse, wenn man noch einen Button>programmieren kann, der den Quellcode kompiliert und in den>Mikrocontroller überträgt.
Was soll den der Murks.... Das macht man so nicht.
>Würde mir gerne das übertragen von Steuersignalen an den USART ersparen
Da wirst du wohl nicht drum herum kommen.
Um was geht es denn genau?
Nimm die UART des Controllers und schließe da einen MAX232 an. Am PC
nimmst du einen USB Seriellwandler mit virtuellem Comporttreiber. Als
Frontend kannst ein Terminalprogramm wie z.B. Teraterm nehmen. Dann
musste im Controller zeichenketten definieren, aus denen er weiß, welche
Variable er auf welchen Wert setzten soll. Diese Zeichenketten kannst im
Terminalprogramm senden.
Sei dir bewusst dass manche Terminalprogramme per default ein Carriage
Return als letztes Zeichen senden und manche nicht. So währe es
vielleicht sinnvoll, auch einen Loopback vom Controller zum PC zumachen.
Dann siehst du im return, was dein Controller "sieht".
GST schrieb:> Nimm die UART des Controllers und schließe da einen MAX232 an. Am PC> nimmst du einen USB Seriellwandler mit virtuellem Comporttreiber.
Lieber direkt einen USB-TTL Wandler und ohne MAX232 auf den Controller.
Die Strecke zum Controller dann per USB zurücklegen. MAX232 ist heute
bissle veraltet und überflüssig wenn man sowieso nen USB-Adapter
braucht.
gruß cyblord
Also wie schon gesagt wurde, nimm die serielle Schnittstelle und
übertrage so die Parameter.
Mit einem UART-USB Converter (FTDI) ist das ein Kinderspiel, da du am uC
die einfache UART Schnittstelle verwenden kannst und am PC ebenso.
Wenn du dann eine Programmiersprache am PC verwendest mit der du leicht
eine GUI erstellen kansnt (.NET bspw. unter Windows), und vielleicht
auch noch von der Sprache dir bekannt ist (vielleicht Visual Basic
.NET), so ist das in unter einer Woche, ohne Vorkenntnisse
(programmieren kannst du ja hoffentlich), zu schaffen, da du einfach ein
fertiges Projekt umarbeiten musst:
http://www.lvr.com/serial_ports_dotnet.htmhttp://www.youtube.com/watch?v=1YQM30r8Nuohttp://www.microsoft.com/visualstudio/deu/products/visual-studio-express-for-windows-8#product-express-windows
Die angedachte Vorgehensweise ist äußerst suboptimal. Eine geringfügige
Verbesserung wäre dadurch zu erzielen, die veränderlichen Wartezeiten im
internen EEPROM des Microcontrollers zu speichern und nur die per ISP zu
programmierende Hex-Datei für den EEPROM-Inhalt programmgesteuert neu zu
erzeugen.
Der Programmieraufwand (GUI, Datei erzeugen/Schreiben, externe
Programmierroutine (z.B. avrdude, myAVR)) ist jedoch vermutlich
wesentlich höher als die Daten per UART zu übertragen.
Beim Neuerzeugen des gesamten Programms müssen zusätzlich noch Compiler
und Linker aufgerufen werden.
Die ganze Fehlerbehandlung im GUI dürfte mindestens 80% des Aufwandes
ausmachen.
Wow, erstmal thx @ all für die vielen Hinweise.
@Frank.M, hab mal kurz über die Links drüber geklickt, schauen recht
vielversprechend aus.
Btw, gewisse Grundprogrammierkenntnisse sind da, hatte mal vor sehr,
sehr, sehr langer Zeit ein Semester lang Ingenieurinformatik.
@leluno, schwirrte mir als optimale Endlösung durch den Kopf, wollte
aber erst mal die Steuerung über den Laptop ausarbeiten. Kann aktuell
auch noch nicht wirklich in diese Richtung argumentieren, da ich mich
mit Touchpads noch nicht befasst habe.
Werd jetzt nochmals alle Antworten in Ruhe durchgehen, sollten weitere
Fragen auftreten, werd ich euch natürlich nochmals kontaktieren ;-)
cyblord ---- schrieb:> Lieber direkt einen USB-TTL Wandler und ohne MAX232 auf den Controller.> Die Strecke zum Controller dann per USB zurücklegen. MAX232 ist heute> bissle veraltet und überflüssig wenn man sowieso nen USB-Adapter> braucht.
Oder gleich einen kleinen Arduino nehmen. Damit ist dann auch die
Steuerung via Terminal trivial, dank der beiliegenden Bibliotheken. Ein
winziger Sketch, fertig.
Fehlt nur noch das UI...
Also wenn es dir nicht wichtig ist es über einen PC zu steuern, dann
kannst du auch einfach zwei schöne Drehknöpfe nehmen mit denen du die
Zeit direkt am uC einstellst. Das sollte die einfachste Lösung sein, da
du nur zwei ADC-Eingänge dafür brauchst und programmiertechnisch
minimalsten zusatzaufwand.
Alternativ, etwas aufwendiger, ein alphanumerisches display um die
eingstellte Zeit anzuzeigen, und evtl. 4 Taster anstatt die zwei Potis
um die zwei Zeiten digital einstellen zu können.
Für dich vermutlich vorerst unmöglich ist die Touchscreen-Lösung mit
Grafikdisplay.
Und nicht zu vergessen:
Dein AVR-Programm ist schon Murks.
Die Wait müssen da raus.
Wait ist etwas für den Anfang, damit man mal überhaupt irgendwas
programmieren kann. Aber für ernsthafte Anwendungen ist das alles nicht
zugebrauchen. Zeitsteuerungen bedeuten meistens: Timer.
Ganz speziell dann, wenn das Programm mehrere Dinge quasi gleichzeitig
machen soll. Bei dir den Ausgang ansteuern UND die UART überwachen.
Besser du lernst jetzt gleich, wie sowas geht, denn auf lange Sicht
kommst du sowieso nicht drum rum.
änderung der timer-Zeiten geht auch mit Tasten oder ganz komfortabel mit
einer ir-Fernbedienung. Das ist alles viel einfacher als Steuerung über
PC-gui
Karl Heinz Buchegger schrieb:> Zeitsteuerungen bedeuten meistens: Timer.> Ganz speziell dann, wenn das Programm mehrere Dinge quasi gleichzeitig> machen soll. Bei dir den Ausgang ansteuern UND die UART überwachen.
Mit Arduino kein Problem. UART kommt per Callback rein, den Rest macht
man in loop() als Statemachine, die ueber die Systemzeit die Zustaende
wechselt. Kein Grund selbst mit Timern zu kaempfen.
Warum man sich für ein/pause/aus mit timern rumärgern soll ist mir
rätselhaft. Letztlich würde ich einfach ein Mäuseklavier verbauen, das
an ein paar IOs vom µC geht. Da kannste dann eben 2^n Sekunden
einstellen wobei n die Anzahl der Taster ist -> bei 4 Tastern also z.B.
zwischen 1 und 16 Sekunden (oder 0 und 15, aber 0 macht in meinen Augen
wenig Sinn).
Sonst wie die Vorredner schon gesagt haben: nimm die serielle
Schnittstelle. Das ist wirklich kein Drama die anzusteuern. Ein bisschen
musst du dir eben Gedanken über das Protokoll machen. Theoretisch
könntest du auch einfach direkt nur ein Byte schicken, das in der
Pausen-Variable landet. Damit wären dann 255 Sekunden möglich.
Moritz schrieb:> Warum man sich für ein/pause/aus mit timern rumärgern
? rumärgern
Was bitte ist an einem simplen Timer 'rumärgern'.
Das ist so einfach wie einem Baby den Schnuller klauen.
> soll ist mir> rätselhaft.
Dann rätsle weiter.
> Theoretisch könntest du auch einfach direkt nur ein Byte schicken,> das in der Pausen-Variable landet.
Er hat aber 2 Delay Zeiten, die er einstellen will. Und nu?
Aha! Wenn man dann mal auch ein wenig das Kleingedruckte beachtet, sind
die Dinge dann gleich gar nicht mehr so einfach.
