Kommunikation über 1 Kabel

TommyB

Team Bitschubse
17. Mai 2010
2.151
80
48
40
127.0.0.1 ;)
Sprachen
  1. C#
  2. VB.Net
  3. LunaAVR
  4. Assembler
  5. Python
Hiho :)

Ich frag einfach mal, vielleicht hat sowas ja schon mal einer von euch gemacht :)

Ich müsste ein paar Daten (nur 1 oder 2 Bytes alle 5 Sekunden) über ein Kabel senden.
Prinzipiell würde ja RS232 gehen, nur erstens würde das automatisch 2 Pins belegen (selbst wenn ich die nicht nutze), und mein ATtiny13 kann das eh nicht. Der Tiny muss nur empfangen.

Um das Senden mach ich mir keine Sorgen sondern wie man das Signal denn wieder vernünftig "entschlüsselt". Ich muss davon ausgehen dass die Timings nicht sonderlich präzise sind, muss mich also vermutlich auch um eine billige Fehlerkorrektur kümmern. Auch wenn Übertragungsfehler jetzt nicht soo dramatisch sind (wären aber trotzdem ärgerlich). Der Tiny soll im Endeffekt nur ein PWM erzeugen.

Hat da wer schon mal was gemacht oder kennt etwas existierendes?
 
Hi Tommy,

verwende doch einfach den USART und nutze nur TXT bei dem sendenden Controller und RXD bei dem empfangenden Controller (wie man das in Bascom konfiguriert weiss ich nicht, es sind die Bits RXEN und TXEN). Der nicht genutzte Pin des USART steht als Standard IO pin zur Verfügung. Oder musst du Daten hin und her schicken?

Wenn du noch etwas Sicherheit benötigst, verwende CRC, vielleicht reicht dies dir ja aus.

Dirk :ciao:
 
Hi Dirk :)

Wie gesagt, RS232 fällt ja flach. Hat der Tiny13 nicht und auf der anderen Seite wären trotzdem 2 Port Pins weg, egal ob ich den nun anschließe oder nicht. Da kann ich denn auch gleich was selber basteln (müsste denn ja ein Software-RS232 stricken), sofern es nichts fertiges gibt.
Zumal ich den RS232 Port auf der Sender-Seite gern noch für was Anderes offen halten würde.

So etwas wie 1wire z. B.. Nur dass das viel zu überdimensioniert wäre mit den ganzen IDs etcpp. find ich dafür auch ein bissl zu extrem. Wenn ich dran denk wie viele Tak tzyklen der Tiny dafür brauchen würde...


p.s.: Ich programmiere immer noch in Assembler ;)
Zumindest die AVR Teile.
 
Hallo,

Wie gesagt, RS232 fällt ja flach. Hat der Tiny13 nicht und auf der anderen Seite wären trotzdem 2 Port Pins weg, egal ob ich den nun anschließe oder nicht.
Das würde ich nicht sagen. Man kann auch nur die halbe RS232 verwenden. Das sollte kein Problem sein.

Mega8 TxD ----->------ RxD Tiny13 (oder statt RxD die USI)
GND --------------------GND

mit 150 Baud sollte das relativ stabil laufen.

Zumal ich den RS232 Port auf der Sender-Seite gern noch für was Anderes offen halten würde.
Dann wohl Soft-PWM so wie du es schon angedacht hast.

So etwas wie 1wire z. B.. Nur dass das viel zu überdimensioniert wäre mit den ganzen IDs etcpp. find ich dafür auch ein bissl zu extrem. Wenn ich dran denk wie viele Tak tzyklen der Tiny dafür brauchen würde...
1Wire hat nicht viel Luft im Timing. Das hab ich selber gemerkt wie ich das in Assembler umgesetzt habe. Da muß der Takt relativ gut passen.

Gruß
Dino
 
Sag mal genaueres.
Auf den Tiny13 bist Du bereits festgelegt? Der Tiny2313 hätte HW-UART.
Ich interpretiere mal, daß der Tiny13 der Empfänger sein soll, wer ist der Sender?
Kann man von sauberen 5V-TTL ausgehen?
Du programmierst Assembler, oder?
Welche Leitungslängen?

Irgendwo gabs hier schon mal 'ne ähnliche Frage - ich hatte dann mal was dazu zusammengekritzelt (in ASM), aber ob ich das jetzt noch finde...
Dein Tiny hat keine HW-Kommunikationsschnittstelle, Du mußt also entweder die Bits synchron rüberschieben (also eine weitere Leitung), oder einen Timer verwenden, und das in SW nachbauen. Dein Controller hat aber auch nur einen 8Bit-Timer (immerhin mit 2 OC-Units) - prinzipiell kannst Du also die Periodendauer auf die UART-Bits festlegen (und synchronisieren), und nebenbei mit dem anderen Kanal PWM laufen lassen (wegen der Begrenzung natürlich mit eingeschränkter Auflösung)
WGM=7
Und beim Empfang mußt Du den Timer auf den UART synchronisieren -> wirkt sich natürlich auf den PWM aus.
Abgesehen davon werden beim HW-UART mehrere samples genommen (pro Bit) - mein Weg nutzte nur eins. Bei sauberen 5V-Pegeln, langsamer Übertragungsgeschwindigkeit, und hinreichend geringen Störungen sollte das aber machbar sein.

Hmm... den ADC kann man eigentlich auch zur Generation einer Zeitbasis verwenden (also nur prinzipiell - welche konkreten diskreten Werte da erreichbar sind (ADC-Prescaler), hab ich noch nicht durchgerechnet. Und ob die HW das verkraftet, wenn der mit 10MHz rennt (oder ob dann nur unbrauchbare Ergebnisse rauskommen, die uns ja eh nicht interessieren...) weiß ich auch nicht.
Der Watchdog könnte übrigens auch als Zeitbasis-Generator entfremdet werden - auch hier nur mit bestimmten diskreten Werten...

Dann hätte ich als PWM-Spezialisten (eher für höhere Frequenzen) den Tiny26 bzw dessen Nachfolger Tiny261/461/861 im Kopf - immerhin mit 2 Timern. Allerdings wie der Tiny2313 auch 20 Beine, und ohne HW-UART.
Der Tiny24 hat 14 Beine, und auch 2 Timer.
Hast Du Dir mal den Tiny25 angesehen?

Nachtrag @Dino: Der Tiny13 hat kein USI, und wie man da UART (ohne S) implementieren kann, ist mir nicht ganz klar (habs aber auch schon mal in'nem DB gesehen)- die Bits müssen doch trotzdem "eingetaktet" werden, oder nicht? Also entweder richtig über den Takteingang (weitere Leitung), oder über das USI-Clock-Strobe-Bit (was aber wieder getimt werden muß)

Und noch'n Nachtrag für Thomas:
...auf der anderen Seite wären trotzdem 2 Port Pins weg, egal ob ich den nun anschließe oder nicht...
Nein, Du kannst Transmitter und Reciever getrennt aktivieren. Solange die inaktiv sind, bleiben die entsprechenden Pins normale I/Os (bzw ggf andere Funktionen) - nur nebenbei.
Mit etwas protokollarischem Overhead kannst Du auch mehrere Empfanger über einen UART-TX ansteuern (zB über das 9te Datenbit, oder über 2Bytes, wobei das erste dann als Adresse (in SW) verarbeitet wird)
 
Hi,

Und beim Empfang mußt Du den Timer auf den UART synchronisieren -> wirkt sich natürlich auf den PWM aus.
muß es nicht. Man kann es auch so machen wie es ein normaler UART macht. Mit Oversampling. Man arbeitet also mit 4, 8 oder 16fach höherem Takt und synchronisiert sich damit dann auf die Daten auf. Mit Flankenerkennung.

Gruß
Dino
 
Stimmt... erhöht aber auch den Aufwand etwas (da man nicht nur die Bits zählen muß, sondern die samples im Zeitfenster (valid bit), und außerhalb des Fensters unterscheiden muß. Samples m Fenster - da könnte man dann einfach den Pinzustand in ein Hilfsregister schieben, und dann am Ende übernehmen (0x00 bzw 0x?? - ja nach Sampleanzahl)<-Nein, das ist ja bereits das nächste Bit... man muß nur entsprechend anders zählen - also eben 4x 8x so weit, und ggf Übereinstimmung der samples in einem Byte prüfen/mitteln/wie auch immer...
Zusätzlich setzt man den Samplezähler bei einem Flankenwechsel zurück, wobei das nur nach jedem Bit erlaubt ist.
Vielleicht soll auch noch ein Timeout mit rein?

Dann macht die fixe Idee mit dem ADC vielleicht doch noch Sinn, falls (!!) man damit auf 'ne brauchbare Zeitbasis fürs Oversampling kommt...

Edit: Achso, Du meintest SoftPWM, der kann dann natürlich auch an die Zeitbasis des Oversampling-Timers gekoppelt werden...

Edit: Eigentlich ist an dem Durchgestrichenem da oben doch was dran, kommt später noch'n Beitrag von mir dazu...
 
Ok, ich glaub ich hab hier etwas Verwirrung gestiftet.

Prinzipiell ganz simpel.
Im Moment ist es noch so (weils Debuggen leichter ist) dass der "Master", also der Sender, mein Raspberry ist.
Was aber nun relativ irrelevant ist weils nachher auch am PC hängen wird (werde da vermutlich einen LPT Pin für missbrauchen).
Zum Testen dient mein Lüfter. Also RasPi misst Temperatur, berechnet Geschwindigkeit und schickt die raus. Der Tiny passt sein PWM dementsprechend an.

Problem:
Software PWM frisst CPU ohne Ende (bei höheren Frequenzen) und dank Windows / Linux / whatever mit dem Pseudo-Multitasking alles Andere als präzise. Blöd. Daher geht nicht einfach ein Transistor o. Ä.. Vor allem weil wenn ich damit mal LEDs steuern will, ich seh das geflacker sofort.

Lösung(-sansatz):
Einen Tiny13 (wegen der geringen Pinanzahl und somit Größe) dafür nutzen. Der kann das n bissl besser.
Fehlt nur noch die Übergabe der Werte.

Die Idee mit dem Watchdog hatte ich auch schon mal (aber nicht hierfür), aber den ADC zu nutzen, das ist echt mal ne Überlegung wert. Nette Idee :)
Damit könnte man zumindest schon mal so ein wenig Timing herstellen ohne den Timer zu verwenden.
 
Siehe Dinos Hinweis zum Oversampling. Du willst am Tiny einen (!) Kommunikationseingang nutzen, und einen(!) PWM-Ausgang?
Mich juckts ja jetzt förmlich in den Fingern, das mal mit meinem ATtiny10 auszuprobieren. Wäre Dir der klein genug?

Gib mal Deine Eckdaten an:
-mögliche Taktfrequenzen des Controllers (wegen klein wirst Du sicher auch noch den internen Oscillator verwenden wollen, oder?)
-mögliche (geforderte) Übertragungsgeschwindigkeit (da wird ja der Sender auch was festlegen) Baudrate usw...
-gewünschte PWM-Auflösung und Frequenz

Die Temperaturmessung und Leistungsvorgabe/-Berechnung willst/kannst Du nicht einfach auch an den Mikrocontroller abtreten? Muß ja nicht unbedingt ein PID-Regler implementiert werden (zumindest nicht mit automatischer Berechnung der Faktoren;) - da kämst Du mit dem Tn13 sicher an die Grenzen)
 
Also gefordert ist eigentlich nichts, außer so klein wie möglich. ^^

Ich wollte nur dass der Controller relativ gesehen "dumm" ist. Denn kann ich die selbe Firmware nämlich auch für andere Projekte nutzen.
Die Bus Geschwindigkeit ist egal. Auflösung wäre 7 bis 8 Bit gut genug. Neue Werte übertrage ich nur alle 5 Sekunden. Wenn ich jetzt mal 2 Byte einplane (Wert und Parity (statt Prüfsumme, sollte reichen schätz ich), vielleicht noch Platz für eine Slave ID für spätere Erweiterung) denn würden 8 Baud ja schon fast reichen :D
Schneller geht natürlich. 115k wären aber wegen dem schlechten Timings natürlich unrealistisch :)
Senderfrequenz geht eh per Software, von daher auf beiden Seiten frei definierbar.
PWM Frequenz würde ich bei 1KHz oder höher ansetzen.

Ich hab die interne Clock an (ich glaub das war 9,6MHz) ohne Prescaler.
Sonst hast du recht. +5V, GND, PWM Out, DATA IN. (Für mich kommt noch debugWire dazu was aber später natürlich weg fällt)
Signalpegel für die Daten ist aber auf 3,3V Basis. Der Tiny13 kommt damit aber gut klar ohne Level-Shifter. Wie das beim 10er aussieht kA.

Ich sag ja, vom Prinzip easy :)

Zu der Regelung:
Die sieht im Moment so aus dass ich alle 5 Sekunden die Temperatur messe und direkt die Geschwindigkeit setze (Software PWM direkt am Raspberry. Läuft sogar erstaunlich konstant, wenn man mal von den kurzen Abweichungen in der Frequenz absieht. Für Lüfter noch ok, für LEDs absolut unbrauchbar. Mag vielleicht auch noch daran liegen weil ich wegen dem Display SPI nutze. kA wie das intern verschaltet ist).
 
So, ich habe mir jetzt mal das Datenblatt des Mega88 (weil der 'n HW-UART hat, und ich grad das DB zur Hand - geht sicher auch jedes andere mit HW-UART) vorgenommen. Da geht das in etwa so:
  • Die AVR verwenden 16fach-Oversampling (bzw 8fach (U2X-Flag=1), was die doppelte Geschwindigkeit erlaubt)
  • von den 16 (bzw 8) möglichen Samples werden die drei in der Mitte verwertet
  • sind nicht alle 3 samples gleich, gilt die Mehrheit. "majority wins"
  • das Sampling beginnt nach der fallenden Flanke (Startbit) - Synchronisation
Das sollte sich auch ganz gut mit Software (und etwas Hardware) nachbauen lassen.
Ich hab's mal mit 4800Baud durchgespielt, weil das ganz gut zum Timer und Taktfrequenz paßt - kannst Du natürlich anpassen:

4800 Baud
wir verwenden 8fach-Oversampling (schliesslich haben wir einen 8bit-Controller)
folglich soll unser Timer mit 4800Hz*8=33400Hz überlaufen.
Der Timer ist direkt an die 9,6MHz gekoppelt (Prescaler=1), und läuft im CTC bzw "frequenzkorrektem" PWM (Mode7) - OCR0A begrenzt die Reichweite auf 250 Schritte pro Überlauf.
Also ist OCR0A=249 zu setzen.
Somit haben wir also unseren Oversampling-Generator, der nebenbei über KanalB HW-PWM mit fast 8Bit (eben nur von 0 bis 249) und 33,4kHz PWM-Frequenz bereitstellt.
Andererseits müssen wir an die CompareMatches von OCR0A (also die Überläufe) eh 'n Interrupt koppeln, da wir ja hier die Samples auswerten wollen. Da kann also auch noch 'ne Zeitbasis für SW-PWM generiert werden - allerdings jetzt nur noch mit der Schrittfrequenz von 33,4kHz. Bei 7 Bit Auflösung wären also nur noch 33400Hz/2^7=261Hz PWM-Frequenz drin.

Als Bein wird eins genommen, das mit einem Interrupt auf eine fallende Planke reagiert (Startbitdetektion).

Zum Zählen der Oversamples in der OCRA-ISR benötigen wir einen Zähler/ein Register. Ich nenne es OSR (OverSamplingRegister). Dieses Register enthält im Idle eine 0. In der Startbitdetektion wird es 1 gesetzt.
In der OCR0A-ISR zählen wir jetzt aber nicht mit dem OSR, sondern schieben es... und zwar nach links

...
Ups Akku fast leer - dann werd ich auf die Aufnahme der samples und den "Majority Wins" Prozess und den ganzen Rest später eingehen müssen...
Bis hier kommst Du mit?
 
Ich musste es zwar 3x lesen, aber ich glaube ich hab alles verstanden :)

Hmm, wegen Interrupt, wäre auch ein PinChange Interrupt möglich? Eigentlich ja schon, oder? Das wäre für das Routen angenehmer (beim Tiny13).
Edit: Ach, du meinst den Timer Interupt. Oder doch nicht?


Und schon jetzt mal vielen Dank für deine Mühe :)
 
Hi,
ich hätte da noch einen Vorschlag --> Software UART, sollte eigentlich auch mit einem Tiny funktionieren, probiert habe ich es allerdings noch nicht.
Auf einen ATMega32 funktioniert es jedenfalls, die Baud-Rate sollte nicht zu hoch sein (und zum Systemtakt passen !) und die Interrupts sollten möglichst nicht dazwischen funken, sonst gibt's Datensalat.
Das folgende Beispiel hab ich mal irgendwo gefunden, in der BASCOM-Hilfe steht das aber glaub ich auch so ähnlich drin.
Wenn du die Transmit-Seite nicht brauchst, einfach weglassen ist beim Soft-UART kein Problem.

Viel Spass beim Experimentieren ....

' SOFTWARE UART
'
' The previous examples used the hardware UART. That means the compiler uses the internal UART registers and internal hardware (RxD(0) and TxD(0)) of the AVR. If you don’t have a hardware UART you can also use a software UART.
' The Bascom compiler makes it easy to “create” additional UART’s. Bascom creates software UART’s on virtually every port pin.
' Remember that a software UART is not as robust as a hardware UART, thus you can get timing problems if you have lots of interrupts in your program.
'
' For this example we use micro controller pins portc.1 and portc.2.
'
' Connect portc.1 to TxD and portc.2 to RxD see the schematic above.
'
' $regfile = "m88def.dat"
'
' $crystal = 8000000
' $baud = 19200
'
' Dim B As Byte
'
' Waitms 100
' 'Open a TRANSMIT channel for output
' Open "comc.1:19200,8,n,1" For Output As #1
' Print #1 , "serial output"
'
' 'Now open a RECEIVE channel for input
' Open "comc.2:19200,8,n,1" For Input As #2
' 'Since there is no relation between the input and output pin
' 'there is NO ECHO while keys are typed
'
' Print #1 , "Press any alpha numerical key"
'
' 'With INKEY() we can check if there is data available
' 'To use it with the software UART you must provide the channel
'
' Do
' 'Store in byte
' B = Inkey(#2)
' 'When the value > 0 we got something
' If B > 0 Then
' Print #1 , Chr(b) 'Print the character
' End If
' Loop
' Close #2 'Close the channels
' Close #1
'
' End
'
 
...wäre auch ein PinChange Interrupt möglich? Eigentlich ja schon, oder?...
klar, zumindest kann man ja in der ISR den Pegel prüfen. Oder man verläßt sich darauf.
Im Idle (also auch zu Beginn) sollte die Leitung Hi sein (kann man ja vorher abwarten oder so)
Folglich ist (wenn der PinChangeInt scharf ist) die erste Flanke fallend. Das ist das (potentielle) Startbit.
In der ISR wird nur das "OSR" ;) auf 1 gesetzt (das entspricht der Synchronisation unseres Oversamplingzählers auf den Sender), und der PinchangeInt selbst abgeschaltet.

Der Timer läuft mit der ermittelten Geschwindigkeit durch, kann nebenbei auch Hard- oder SoftPWM bereitstellen, aber solange das OSR=0 ist, passiert beim schieben noch nichts - 0 ist der Idle-Status.

Nach dem schieben wird sofort auf das eventuelle Carry reagiert, welches ja beim ... Tada ... 8ten Schieben passiert. Oversample 8 halt. Hier ist also die "majority" der Oversamples 4, 5, 6 als empfangenes Bit an das Haupprogramm rauszugeben, sowie ein Signalflag. Und für das nächste Bit muß OSR natürlich wieder 1 werden.
Leider besitzt der Tiny13 mein geliebtes GPIOR0 nicht. Da könnte man dann direkt auf einzelne Bits prüfen, oder diese zuweisen.
wenn OSR kleiner als 8 (Oversample 4) oder größer als 32 (oversample 6) ist, geschieht auch nichts weiter.
Im Fenster jedoch addieren wir den Pegel am Eingangspin auf einen SampleBuffer (Hmm... sabuf... ein Byte... ein Register).
Sabuf ist initial =0 (Dieser Zustand muß auch im Fall mit dem Carry da oben wiederhergestellt werden!) ... Wir wollen sabuf nur incrementieren, wenn das Eingangsbein Hi ist, als überspringen wir den INC einfach genau dann, wenns low ist. Mit SBIC.

Und wie bekommen wir im Zweig mit dem 8ten schieben da oben (Carry) das empfangene Bit einfachst heraus? Wenn sabuf=3 oder 2 ists ne 1, wenn sabuf 1 oder 0 ists ne 0. Hmm... binär gesehen 0b00000011 bzw 0b00000010 -> 1 und 0b00000001 bzw 0b00000000 ->0.
Klar einmal rechtsschieben - zack ist danach das Zero gesetzt, wars 'ne 0, ist Z=0 wars 'ne 1. Anhand des Z kannst Du entsprechend verzweigen, und die Flags fürs Hauptprogramm generieren.

Im Hauptprogramm Zählst Du die über das Flag (muß dann natürlich zurückgesetzt werden) signalisierten Bits mit (Startbit zB prüfen, obs 0 ist), die 8 Datenbits in Dein Datenbyte pumpen, ggf Parität prüfen. Wenn das Stoppbit ankommt (muß 1 sein), muß OSR=0 gesetzt werden (dann idlet unser UART rum), und der PCINT wieder angespitzt werden, für das nächste Startbit...

Sachen, die ich vergessen habe, kannst Du gern ergänzen.

Edit: Wenn ich nochmal so drüber nachdenke, könnte das letzte Oversampling beim Stoppbit möglicherweise auftauchen, wenn bereits die nächste Flanke fällt (nächstes Startbit)... wodurch wir die übersehen...
In der Flankendetektions-ISR muß OSR auf 2 gesetzt werden - dann sollte es passen (und entsprechend sind jetzt die relevanten 3 Stellen Bit 5(16), 6(32), 7(64) im OSR)
 
Mal 'n 2ten Post für gp177, um das zu trennen...

Das mit dem SW-UART unter BASCOM ist bekannt, hier ging es aber um Assembler. Strenggenommen machen wir ja fast dasselbe. Als Alternative hätte man in Bascom noch serialin oder shiftin oder sowas (eins davon war SW-UART, eins SW-SPI). Ich glaube mich zu erinnern, daß der SW-UART beim Empfang wartet, und die entsprechenden Zeiten durch den Takt generiert - da dabei der (einzige) Timer unbenutzt bleibt, würde das mit dem PWM sogar gehen.
Inwiefern Bascom da Oversampling benutzt, weiß ich nicht - habe jetzt keine Lust, das zu reassemblieren.

BTW: die $BAUD-Direktive überschreibt die Voreinstellung zur Baudrate in den Optionen (Optionen->Compiler->Kommunikation), und betrifft den (ersten) Hardware-UART, den der Tiny13 bekanntlich nicht hat. Steht diese Direktive im Code, beschwert sich der Compiler über die nicht vorhandenen UART-Baudraten- und UART-Controlregister.

Nachtrag: Meinen Tiny10 scheint Bascom (2.0.7.3.001 Vollversion) gar nicht zu unterstützen, zum nötigen Tiny Programming Interface (TPI) finde ich auch nichts...

Trotzdem Danke für Deinen gutgemeinten Tip;)
 
Ich wollte gestern eigentlich schon antworten, aber O2 hat mich grad gedrosselt (zum Glück nur noch bis morgen) und mit max. 7KB/s ist das Netz nicht grade angenehm.

Ja das stimmt, hier geht es um Assembler, nicht um Bascom :)
Läuft das mittlerweile überhaupt auf den Tinys? Als ich das damals, zu der Zeit als ich noch Bascom verwendet habe *schäm*, mal probiert hatte hat der mir den Flash mit Gott weiß was so voll gestopft dass garkein Quelltext mehr rein ging. -> Nutzlos. Da bin ich denn auch auf Assembler gewechselt.

@LotadaC:
Hast du die echte RS232 beschrieben? Denn könnt ich ja rein theoretisch mir 'nen USB zu RS232 Adapter holen (ich hab glaub ich sogar noch einen hier den ich mal auf TTL umgebastelt habe, n paar Dioden sollten reichen um von 5V auf 3,3 zu kommen) um das pro Gerät zu testen. Das wäre natürlich zum Debuggen angenehmer.
 
Naja, selbst Dino nutzt zuweilen Bascom. Und ich hab hier auch 'ne Vollversion. Ich nutz die bloß praktisch nicht für mich. Aber die ASMler erkennt man daran, daß sie dann trotzdem ganz gern direkt auf den I/O-Registern rummachen, und weniger auf die "tollen" vorgefertigten CONFIGs und OPENs usw zurückgreifen.
Der Vorteil von ASM ist, daß man sich um jeden Mist selber kümmern kann. Der Nachteil, daß man sich um jeden Mist selber kümmern muß;). Da geht's mit Bascom halt schneller.

Wegen "...mit Gott weiß was so vollgestopft, daß..." - kannst ja spassenshalber mal folgendes compilieren lassen:
Code:
$Regfile="ATtiny13.dat"
Wenn, wie im Codeschnipsel da oben noch der Software-Comport geöffnet wird (also nur der Empfang), die Schleife mit Inkey, und die Fallunterscheidung (ohne was drin, bisher) dazukommt, bist Du bei 16%. Dabei verbraucht Inkey aber 'ne Menge Zeit (bei 4800 Baud), und außerdem darf die Schleife nicht viel anderes machen (sonst übersiehst Du vielleicht ein Byte). Da Du aber den Timer für HW-PWM freihättest, ginge das meiner Meinung nach.

Zu RS232: Du brauchst einen Wandler auf TTL, genau. Ich hab hierirgendwi so'n Teil vom "blauen C", ich hatte mir auch mal 2 bei elektor bestellt - dummerweise hatten die da'n Lieferengpaß, als sie es dann verschieckt hatten, ist das irgendwie in meinem Umzug untergegangen. Rechnung und Lieferschein hab ich ordentlich abgeheftet, aber die kleinen Dinger selbst hab ich noch nicht gefunden...

Letztlich hatte ich mir bei Dirk das hier bestellt. Den scheint's auch als 3.3V-Variante zu geben. Auf der Unterseite hat er 'ne Lötbrücke, wo man das umschalten kann. Allerdings ist der mit 'ner Leiterbahn auf 5V eingestellt - diese Bahn müßte also erstmal durchtrennt werden.

Zu der anderen Frage: Ist ja alles nur (noch nicht mal) Pseudocode. Bis jetzt hab ich was geschrieben zu:
-Synchronisation auf die erste Flanke (Startbit) durch einen externen Interrupt
-Generation der Timing-Events fürs Oversampling, die man auch für SoftPWM nutzen kann.
-Trick 17 mit dem schieben von Nullen (Idle) oder einer 1 durch ein Byte (Oversampling) in der Timer-Überlauf-ISR (bzw im CompareMatch)
-Trick 18 zum realisieren von "Majority Wins", und die Übergabe des ermittelten Bits an das Hauptprogramm

Zum Hauptprogramm selbst hab ich fast noch nichts geschrieben. Beim TTL-Uart ist das ja so:
-im Idle ist die Leitung Hi
-Das Startbit ist 'ne 0 (Lo), auf die fallende Flanke syncen wir (da das bereits der erste Oversampling-Zeitpunkt wäre, mus OSR im PinChangeInterrupt mit 2 reinitialisiert werden. es folgen 7 weitere Oversamplings (4, 8, 16, 32, 64, 128, 256=0=Überlauf, durch uns auf 1 gesetzt) das war das Startbit). Das Bit (jedes) wird in der Mitte gelesen. Mit Oversampling mehrfach ("Majority...").
-es folgen die Datenbits (AVR-HW-UART kann 5-9, Du kannst natürlich hier auch was beliebiges anderes Implementieren)
-es folgt ggf 1 Paritätsbit
-es folgt (mindestens) 1 Stopbit (ist immer 1 - die Leitung ist also bis zum nächsten Startbit wieder Hi (idle).

Du mußt also in der Hauptprogrammschleife schnell genug (mindestens einmal pro Bit) das Flag (aus der Timer ISR) pollen, und das ggf erhaltene Bit aus dem Zwischenspeicher abholen. Dabei mußt Du mitzählen, welches der Bits aus dem UART-Telegramm das ist, und behandelst es entsprechend (Startbit muß 0 sein - ansonsten hatten wir nur'ne Störung oder sowas, die Datenbits werden zu einem Byte zusamengerollt, Vergleich mit dem eventuellen Paritäsbit (vielleicht hatten wir Watte in den Ohren), beim Stopbit den Bereitschaftszustand wiederherstellen und den Flankeninterrupt für das nächste Byte (Startbit) scharfmachen.
 
Ich hab diesen hier noch irgendwo zu liegen:
Digitus DA-70156
Etwas verbastelt; ich hatte den darin enthaltenen Pegelwandler entfernt und überbrückt. Aber ob der jetzt 5V oder 3,3V raus gibt hab ich nie gemessen. War mir bisher auch egal da ich nur mit 5V gearbeitet habe.

Aber denn werd ich den mal suchen und damit einige Versuche starten. Genug Infos sollte ich ja mittlerweile haben dafür :)
Kommen zwar bestimmt noch Fragen auf beim Umsetzen, aber das zeigt sich dann.

Vielleicht sollte ich auch mal ein Auge auf dieses Projekt legen. Wäre da bestimmt hilfreich beim Debuggen, zumindest für die Empfängerseite.
 
Ich vermute, der Digitus enthält einen Pegelwandler von TTL auf RS232. Definitiv sollte er aber auch einen FT232R enthalten (USB-TTL-Wandler).
Dieser besitzt unter anderem Einen Eingang (VCCIO - Pin4) für die Versorgung der TTL-Seite (1,8-5V oder so), und natürlich einen Regler, der 3,3V erzeugt (für die USB-Datenleitungen). Der Regler benötigt einen externen Abblockkerko an Pin17 (3V3OUT), und ist mit 50mA belastbar.
Man kann also Pin17 mit Pin4 Verbinden, um den FT232 auf 3V3-TTL zu setzen. Außerdem kann man so auch (sehr genügsame) externe Hardware versorgen. Siehe dazu das Datenblatt des FT232R, insbesondere Seite 26.

Zum LA: Ich hab auch lange mit mir gerungen. Und mir dann letztens den Logic8 gegönnt.

Dann mach mal - bin ja selber gespannt drauf. Is schön, wenn man (ich) bloß ein paar fixe Ideen fallen lassen braucht, und jemanden anderen (Dir) dann die ganze Coderei überlassen kann...
(Ich hab ja keinen Tiny13 - vielleicht versuch ich's ja doch noch mit dem Tiny10. Der hat nur 16 Rechenregister, nur halb soviel SRAM (wie der 13), aber immerhin auch 1K Flash. Und mein GPIOR0 :p und 3 I/O-Pins)
 
Dann mach mal - bin ja selber gespannt drauf. Is schön, wenn man (ich) bloß ein paar fixe Ideen fallen lassen braucht, und jemanden anderen (Dir) dann die ganze Coderei überlassen kann...
(Ich hab ja keinen Tiny13 - vielleicht versuch ich's ja doch noch mit dem Tiny10. Der hat nur 16 Rechenregister, nur halb soviel SRAM (wie der 13), aber immerhin auch 1K Flash. Und mein GPIOR0 :p und 3 I/O-Pins)

Naja, ich sag mal so: Ist schon wenn man (ich) eine blöde Frage in die Runde stellt und man so gute Antworten von anderen Personen (dir) bekommt die einem weiter helfen ;)

Das ganze müsste auch auf einem Tiny10 laufen, pins genug hat der ja (obwohl es nur 6 sind).
Was du mit GPIOR0 meinst weiß ich grad nicht. Aber auch der Tiny hat Befehle um Bits im Register und IO-Register direkt zu setzen/clearen. CBI/CBR und SBI/SBR warens mein ich (zugegeben ich bin ohne offene Hilfe immer noch etwas aufgeschmissen ^^)

So ein "echter" LA wär schon was feines, aber es würde sich für mich nicht lohnen, dafür würde ich den zu selten brauchen. Und für das was ich dann eventuell mal brauche, ich glaub da reicht der RasPi aus. Wenn man mal bedenkt, bei höchster Samplerate sinds mal eben 80MB/s. Puh.

Zum USB zu RS232: Ich weiß nicht mehr was für Chips da drin waren / sind. Den Pegelwandler hab ich definitiv nicht mehr. Den hab ich auch etwas rabiat "ausgelötet" weil der zu viele Pins hatte für meinen Lötkolben. Hatte ihn mit nem Cuttermesser "entbeint". Ging schneller :)
 

Über uns

  • Makerconnect ist ein Forum, welches wir ausschließlich für einen Gedankenaustausch und als Diskussionsplattform für Interessierte bereitstellen, welche sich privat, durch das Studium oder beruflich mit Mikrocontroller- und Kleinstrechnersystemen beschäftigen wollen oder müssen ;-)
  • Dirk
  • Du bist noch kein Mitglied in unserer freundlichen Community? Werde Teil von uns und registriere dich in unserem Forum.
  •  Registriere dich

User Menu

 Kaffeezeit

  • Wir arbeiten hart daran sicherzustellen, dass unser Forum permanent online und schnell erreichbar ist, unsere Forensoftware auf dem aktuellsten Stand ist und der Server regelmäßig gewartet wird. Auch die Themen Datensicherheit und Datenschutz sind uns wichtig und hier sind wir auch ständig aktiv. Alles in allem, sorgen wir uns darum, dass alles Drumherum stimmt :-)

    Dir gefällt das Forum und unsere Arbeit und du möchtest uns unterstützen? Unterstütze uns durch deine Premium-Mitgliedschaft!
    Wir freuen uns auch über eine Spende für unsere Kaffeekasse :-)
    Vielen Dank! :ciao:


     Spende uns! (Paypal)