Kommunikation über 1 Kabel

Die GPIOR sind General Purpose I/O Register, also I/O-Register zur freien Verwendung. Haben die etwas moderneren AVR. Kann man also wie zusätzliche SRAM-Zellen verwenden. GPIOR0 liegt sogar üblicherweise adresstechnisch im Bereich unter 0x20, folglich kann ich die (von Dir angesprochenen) direkten Bit-Instruktionen verwenden. Damit eignet sich eben dieses Register hervorragend zum ablegen/abfragen von eigenen Flags, zum Parken von Bits usw. SBI/CBI, SBIS/SBIC können nur auf I/O-Register bis 0x1F angewendet werden - viel mehr als die Register für die Beine (Pin/Port/DDR) sind das nicht, aber das GPIOR0 ist meist(?) mit drin.

P.S.: SBR/CBR/SBRS/SBRC sind nur auf die R wie Rechenregister anwendbar (die ersten 32 Rechenregister)
SBI/CBI/SBIS/SBIC auf die ersten 32 I wie I/O-Register
;)
 
So, habe mal en wenig über die Paritätsgeschichte nachgedacht:
Wenn ich das richtig verstehe, werden die einzelnen Datenbits verXORrt - bei even parity gilt also P=0 genau dann wenn Anzahl der Einsen gerade, P=1wenn ungerade. Odd parity dann umgekehrt. Das Startbit ist 0, man könnte es also mitverXORren.
VerXORren heißt, daß bei einer 1 der bisherige Zustand invertiert wird, oder? (*)
Dummerweise fällt mir da jetzt kein eleganter Weg ein, das gleich mitauszuwerten. Bisher würde ich das ja in etwa so machen:
-in der Timer_ISR werden die 3 relevanten Oversampling-Bits zusammenaddiert
-ist das Bit komplett, kann man 2x rechtsschieben, dann landet das richtige Bit (majority) im Carry
-wenn man das jetzt von links in den Byte-Puffer rotiert (UART ist LSB-first), ergibt sich das Byte - allerdings habe ich da so keine Chance, die Parität zu bilden
-quick'n dirty könnte man jetzt mit SBRC (auf das gerade eingeschobene Bit im Rechenregister) reagieren, und nur bei einer 1 den P-Speicher invertieren (siehe (*)). Allerdings mit nur einer Instruktion. Und hier kommt dirty ins Spiel: kann man dafür nicht das PORT-Register-Bit des Reset-Pins verwenden? Das Bein ist ja von der I/O-Logik abgekoppelt, trotzdem hat man Zugriff auf die Register. Zuerst steht also 0 in dem Bit. Nach dem SBRC schreibt man jetzt eine 1 in das PIN-Register-Bit (also wegen SBRC eben nur bei einer 1 - und zwar mit SBI), was effektiv den Zustand im PORT-Bit toggelt.
-Beim Checken des Paritätsbits kann man mit SBIC/SBIS direkt auf das PORT-Register-Bit prüfen/reagieren.
-Stimmt die Parität nicht, kann das empfangene Byte einfach verworfen werden, ok
-aber wie ist zu verfahren, wenn nach der Startflanke das Startbit=1 ist (irgend'ne Störung, kurzer Einbruch des Signals etc)

Fixe Idee, oder so machbar?
 
Jupp, XOR ist toggeln des Bits bei einer 1. Gerne immer noch verwendet als "Verschlüsselungsmethode" bei Firmware's für Handys :)

Ich muss gestehen die Parity ist mir erstmal egal :)
Die werde ich für die ersten Testläufe einfach ignorieren. Ich bin grade mit meiner Testanwendung fertig dass ich vom PC erstmal Signale senden kann. Ich schmeiß die hier mal in den Anhang mit rein. Benötigt wird aber das VisualBasic.Net Express 2008 (oder besser). Ist im Endeffekt nur ein DropDown mit den COM Ports und ein Slider darunter für das zu sendende Byte. Bzw in meinem Fall hab ich das jetzt so gemacht: 4800,8,E,1. Es werden 2 Bytes gesendet, erstmal die ID für den Slave (immer 0x00 bis jetzt) und dann der eingestellte Wert. Kann man im Quelltext aber alles ändern. (Sind Konstanten in der frmMain.vb. Da es nur eine Testanwendung ist hab ich auf die Usability nicht so viel Wert gelegt.)

COM PWM test application.png
Anhang anzeigen ComPwm.zip

Gleich erstmal mein USB-RS232 aus nem alten Projekt raus basteln und denn gehts dran den Tiny zu programmieren. Wenn die ersten Schritte stehen mal weiter sehen :)
 
Habs jetzt schon mit eingebaut. Jedes 1-Datenbit toggelt das Reset-PORT-Bit (über das PIN-Bit). Ist das empfangene Paritätsbit 1, wird nochmals getoggelt. Wenns jetzt 0 ist, stimmte es. Even Party. Hoffe ich.
Vielleicht schreib ich das nachher in der Bahn noch in Reinschrift ab.

Du hättest keinen LA, es bringt also nichts, zwischendurch irgendwelche Pins zum Debuggen tanzen zu lassen, oder?

So'n ähnliches VB-Progamm hatte ich auch schon, bei mir wird allerdings nur ein Byte gesendet. Ich hatte einen vertikalen Slider oder so was, im mouseup-event wurde dann das Byte abgeschickt.
 
ValueChanged wäre das richtige Event gewesen (vielleicht dazu noch Scroll).
Aber ist bei solch kleinen Testanwendungen ja eh egal. Hauptsache es läuft.
Das ID Byte lässt sich bei mir abschalten. Hab mitgedacht ;)

Ne, einen LA hab ich nicht. Vielleicht bastel ich mir irgendwann aus meinem RasPi einen (als zusätzlichen Verwendungszweck). Würde für mich wohl auch reichen. Mein Skop würde mir da auch nicht viel weiter helfen da das nur 1 Kanal hat.
Aber dafür hab ich debugWire und kann direkt im Chip schaun was da so kreucht und fleucht :)
 
So... hab mal aus'm Hut heraus etwas zusammengetippt - vielleicht kannst Du es nachvollziehen, und ggf anpassen
Code:
 ;************************************
;			Lueftersteuerung
;************************************
;Software UART (RX)
;Hardware/Software PWM
;
;ATtiny13
;
;       +-----+
;!Reset-|B5   |-Vcc
; Rx-In-|B3 B2|-
;      -|B4 B1|-OC0B (HW-PWM)
;   Gnd-|   B0|-SW-PWM
;       +-----+
;
;************verwendete Hardware*******
;PCINT0 RX-Pin - Synchronisation aufs Startbit
;Timer0 WGM=7 - 8fach Oversampling, HW-PWM (OC0B), Zeitbasis fuer SoftPWM (SW-PWM-Pin)
;Telegramm:
;Startbit|D0|D1|D2|D3|D4|D5|D6|D7|Paritaetsbit(even)|Stopbit

.include "tn13def.inc"	;MCU-Definitionsdatei
;************Interruptvektoren*********
.org 0x0000
	rjmp reset		;Resetvektor
.org PCINT0addr
	rjmp RX_start
.org TIM0_COMPAaddr
	rjmp OS_tick
;*************Konstanten***************
.equ F_MCU=9600000
.equ Baud=4800
.equ T0Ov=(F_MCU/(Baud*8))-1	
.equ RxPin=PINB3			;hier RX-Pin festlegen
.equ BitCntReload=10 	;8Data+1Start+1Paritaet+1Stop-1(Carry)

;**********Reservierte Register********
.def OSR=R23			;Oversampling-Zaehler
.def BitCnt=R22	;Bitzaehler
.def RecByte=R15	;recieved Byte
.def sabuf=R14		;samplebuffer
;**********Resetvektor
reset:
	;Stackpointer ist default =RAMEND
	;Variablen (Register) initialisieren
	clr OSR
	ldi BitCnt, BitCntReload
	clr sabuf
	;PortB5 ist (als Paritaetszaehler bereits 0)
	
	;Timer0 initialisieren
	ldi R16, (1<<=CIE0A)
	out TIMSK0, R16	;IRQ bei Ueberlauf (WGM=7)
	ldi R16, T0Ov
	out OCR0A, R16		;Reichweite
	ldi R16, (1<<COM0B1)|(1<<WGM01)|(1<<WGM00)
	out TCCR0A, R16	;KanalB PWM, WGM=7
	ldi R16, (1<<WGM02)|(1<<CS00)
	out TCCR0B, R16	;Presc=1, WGM=7, Timer laeuft
	
	;externe Interrupts
	;ggf vorher auf Hi-Pegel am RxPin warten
	SBI PCMSK, RxPin		;RxPin->IRQ
	ldi R16, (1<<PCIE)
	out GIMSK, R16		;PinChangeInterrupt
	
	;hier init fuer SoftPWM
	;ggf Sleepmode vorbereiten
	sei
;*************Hauptschleife****************
main:
	NOP
	rjmp main
;*************PCINT-ISR********************
RX_start:
	ldi OSR, 2			;Synchronisation
	cbi PCMSK, RxPin	;vom PCINT abgekoppelt
	reti
	
;***********OC0A-ISR**********************
OS_tick:
	push R16
	in R16, SREG
	push R16			;R16 und SREG -> Stack
	'***********hier ggf Zeitbasis für SoftPWM einbauen
	lsl OSR				;Oversampling zaehlen
	brcs BitRdy		;Bit komplett? -> Sprung
	cpi OSR, 16
	brcs TovIsrRdy
	cpi OSR, 65
	brcc TovIsrRdy	;ausserhalb des Fensters? ->Sprung
	sbic PINB, RxPin	;sonst Rx-Pin-Pegel auf
	inc sabuf				;SampleBuffer addieren
	rjmp TovIsrRdy		;Oversampling fertig
	
BitRdy:						;letztes Oversample eines Bits wurde empfangen (also 1 Bit komplett)
	subi BitCnt, 1		;Zaehler dekrementieren
	brcs stopBit			;wenn Stopbit empfangen wurde -> Sprung
	brzs parityBit		;wenn Paritaetsbit empf. wurde -> Sprung
	cpi BitCnt, 9
	brcc startBit		;wenn Startbit empfangen wurde -> Sprung
	lsr sabuf				;Datenbit empfangen, 2x rechtsschieben
	lsr sabuf				;majority landet im Carry
	ror RecByte			;majority von links in Bytespeicher rotieren (LSB first)
	SBRC RecByte, 7	;wenn es eine 1 war
	sbi PINB, PINB5	;PORTB5 toggeln (XOR)
	rjmp TovIsrRdy		;Datenbit fertig

parityBit:				;Paritaetsbit
	lsr sabuf				;Buffer 2x ->rechts,
	lsr sabuf				;majority->Carry, sabuf=0
	brcc TovIsrRdy		;wenn es eine 1 war,
	sbi PINB, PINB5	;PortB5 toggeln (XOR)
	rjmp TovIsrRdy		;Paritaetsbit fertig
	
stopBit:					;Stopbit
	[color=red][B]sbis[/B] [/color]PORTB, PORTB5	;wenn kein Paritaetsfehler
	'**************************hier RecByte freigeben(flag etc...)
	cbi PORTB, PORTB5		;Paritaetszaehler wieder 0
	clr OSR						;Oversampling -> idle
	ldi BitCnt, BitCntReload ;Bitzaehler reinitialisiert
	clr sabuf					;samplebuffer=0
	sbi PCMSK, RxPin		;Startbitdetektion wiederaufgeschaltet
	rjmp TovIsrRdy			;Stopbit fertig
	
startBit:						;Startbit
	'*************************ggf hier sabuf=0 prüfen, was soll bei Fehler geschehen?
	;Sartbit fertig (wenn leer,kann Sprung direkt nach TovIsrRdy erfolgen
	
TovIsrRdy:
	pop R16
	out R16, SREG
	pop R16					;SREG, R16 <- Stack
	reti
hmm... irgendwie scheinen die tabs in meinem Editor anders zu sein - das korrigier ich jetzt aber nicht mit dem Handy...
Ich bin dann in knapp 3h zuhause, aber ob ich da noch was testen will...
kannst das ja mal durchgehen, ob sich das mit dWire machen läßt (wegen senden), weiß ich nicht.
Achso, wie Du sicher sehen wirst, ist PWM noch nicht drin - für HardPWM kann man das problemlos schnell in der stopBit-Fallunterscheidung miteinbauen (out OCR0B, recByte) - aktiviert wird er bereits (aber das siehst Du sicher selbst)

gib mal Rückmeldung...

LotadaC
 
Wow, damit hätte ich nicht gerechnet, danke :)
Ist nicht ganz der Stil wie ich programmiere, aber höchst interessant, hab ich viel zu lesen & lernen :)
Bin ja noch nicht soo erfahren mit ASM. Ich komm damit zwar klar (mit offener Hilfe), aber man lernt ja nie aus.

Ja das mit den Tabs ist so eine Sache. Normal ist 4 Leerzeichen, bei xml sogar nur 2, aber im Browser werden 8 Leerzeichen angezeigt. Dass es da zum Chaos kommt ist klar. Außer das Forum würde Tabs ersetzen was es augenscheinlich nicht tut.

Ich werde das am Wochenende auf jeden Fall ausprobieren. Breadboard, ein Tiny, ne LED (zum testen) und der USB-TTL Wandler liegt schon bereit :)

(p.S.: bei Parity Fehler würd ich den Wert einfach ignorieren. Kommt ja eh alle 5sec ein neuer :))
 
Hat halt jeder seinen eigenen Stil - kann man nicht drüber streiten...
Ich hab versucht, daß verständlich zu dokumentieren.
Bei kleinen Controllern und Projekten verwende ich gern reservierte Rechenregister, und erspare mir das hin- und herkopieren ins/vom SRAM - insbesondere was zeitkritischere Sachen betrifft. Du hast ja 32 davon. Allerdings muß man aufpassen, daß man die später nicht woanders (aus versehen) doch verwendet. Und nur die oberen lassen sich für Operationen mit Immediates verwenden (LDI usw).
In einigen Punkten ist das ganze allerdings etwas inkonsequent:
-den Oversampling-Zähler kann man mit demselben Aufwand auch als Abwärts-Zähler realisieren (dann ist man nicht mehr an 8fach gebunden) - da hatte ich mich in die Idee mit dem schieben verbissen.
-in der Überlauf-ISR des Timers (also bei OCRA) brauch ich eigentlich nach dem sichern des SREG R16 nicht mehr sichern, da es in der ISR selbst nicht verwendet wird.
-Da ich Register reserviere, sollte ich grundsätzlich alle(!) Register nicht mit Rnn ansprechen, sondern auch dort nur neue Namen vergeben - eben um versehentliche Verwendung eines reservierten Registers zu vermeiden (also zB alle nicht reservierten Register mit RRnn (Rechenregister nn) benamsen, und im Programm konsequent diese Namen verwenden)

Noch ein paar Anmerkungen:
-das ganze ist nur mit'nem Editor getippt - sind also sicher noch diverse Fehler zu finden
-wo der verwendete Rx-Pin festzulegen ist, hab ich kommentiert - ist 'ne Konstante (ich hab erstmal B3 verwendet)
-ebenso Baudrate und MCU-Frequenz, können in gewissen Grenzen angepaßt werden - allerdings läuft der Timer derzeit fest mit Prescaler=1 bis 249 oder so (hatte es irgendwo mal ausgerechnet), mehr als 255 darf für den 8bitter nicht rauskommen, klar; weniger als ... 50 - 100oder so (aus dem Bauch heraus) sollten es auch nicht sein, da die Timer-ISR ja jedesmal abgearbeite werden muß (hier sollte man nochmal die unterschiedlichen Fälle durchgehen, und die etwa benötigten Takte ermitteln. Hier würde es dann Sinn machen, beim Compilieren den Wert von T0Ov (Timer0-Overflow) mit #if zu prüfen, und ggf 'ne Warnung bzw 'nen #error zu schmeissen;)
-wo ich den Rampenzähler für softPWM einbauen würde, hab ich dokumentiert. Der Zähler wird dann mit 8facher Baudrate inkrementiert. Die Ansteuerung des Beinchens selbst würde ich dann ins Hauptprogramm (main) legen.
-HW-PWM (Kanal B) wird bei der Initialisierung des Timers bereits mitaktiviert - allerdings beschreibe ich das Vergleichsregister (OCR0B) nicht. Auch das würde ich in die main legen, da:
-in der Timer ISR wird, falls ein komplettes Bit empfangen wurde, und dieses das Stopbit war geprüft, ob das vorherige Paritätsbit stimmte. Wenn nicht, wird mit SBIS (muß SBIS sein, stand falsch im Code) eine Instruktion übersprungen, Diese eine Instruktion muß also das empfangene Byte freigeben. Dazu würde ich ein weiteres Rechenregister (der Tiny13 hat ja kein GPIOR0) reservieren, und dort ein Bit als neues-Byte-empfangen-Flag (NewByteRecievedFlag - NBRF...:confused:9) setzen (SBR/ORI - ist derselbe Opcode. cave!: nur obere 16 Rechenregister)
-Dieses Flag dann in der main pollen, ist es gesetzt, löscht Du es, wartest ggf bis OSR 0 ist, und liest das RecByte aus. OSR=0->RecByte lesen sollte atomar erfolgen, also Interrupts kurz abschalten. In etwa so:
NBRF pollen, wenn gesetzt
NBRF löschen
Einsprungpunkt: Interrupts unterdrücken
OSR=0? (TST - manipuliert Z)
RecByte in ein Arbeitsregister kopieren(MOV)
Interrupts freigeben
bei Z=1 zurück zum Einsprungpunkt BRZS
im Arbeitsregister steht jetzt das zuletzt empfangene Byte bereit, in den Interrupts kann nebenbei ein weiteres neues Byte empfangen werden
-bei einem Paritätsfehler wird einfach das Flag nicht gesetzt - Achtung: wenn ein korrektes Byte empfangen wurde, Aber in der main zuviel Zeit verplempert wird, kann es theoretisch passieren, daß Du erst auf das Flag reagierst, wenn OSR bereits wieder ungleich 0 ist (wenn ein weiteres Byte ankommt). Dann wartest Du ja das weitere Byte ab, was ggf falsch sein kann. Ich denk nochmal drüber nach. Vielleicht bei der Flankendetektion das NBRF selbst löschen, und dafür in der main das OSR nicht prüfen.
-Die Kontrolle auf ein Fehlerhaftes Startbit ist auch noch nicht drin - der Zweig ist leer.
-Die Anzahl der Stopbits (Hi-Pegel) ist egal - nach dem ersten idlet der Empfang bis zur ersten fallenden Flanke rum - wielange das auch immer dauert.

btw Branches auf Zero-Flag heißen BRNE/BREQ - nicht BRZC/BRZS... schade eigentlich... beim Carry gibts ja auch mehrere Mnemonics (mit demselben Opcode).

Wenn Du das ganze irgendwann via dWire testen willst, mußt Du aber auch das ankommende Bit-Telegramm antsprechend Deiner Haltepunkte anhalten, oder? Ich würde das erstmal durch den Simulator laufen lassen, und zu den jeweiligen Zeiten das Pin-Register-Bit des Rx-Pins manipulieren.
 
So ich hab jetzt mal ein Test aufgebaut. Ist zwar mit einem Mega168 (obwohl der Hardware UART hat nutz ich selbstverständlich n Port Pin, wär ja sonst sinnlos) aber dafür hab ich viele Pins frei für LEDs zum debuggen :)
Via debugWire kann ich natürlich nicht mein USB-TTL Wandler anhalten, nur den Chip. Aber sollte doch schon einiges helfen.

Ich fang jetzt mal an deinen Code und Infos nach und nach umzusetzen (und zu verstehen). Bei Fortschritten werd ich berichten :)
 
Hmm... zum testen, oder wie?
Der ist natürlich etwas anders aufgebaut, insbesondere was die I/O-Register betrifft. Generell sollte es natürlich auch gehen, allerdings mußt Du einige Sachen prüfen:
  • die veränderte Taktfrequenz sollte eigentlich kein wesentliches Problem sein - der OCR-Wert für den begrenzenden Kanal A wird ja aus Frequenz und Baudrate berechnet. Allerdings wirst Du mit einem etwas größerem Baudratenfehler rechnen müssen (0,2% oder so)
  • bei der Initialisierung des Timers mußt Du natürlich alle relevanten Bits in den Registern überprüfen, um denselben Effekt zu erreichen. Vielleicht heißen Bits anders, oder liegen in anderen Registern.
  • dito beim PCINT
  • das wichtigste jedoch: bei einigen Bits nutzte ich de direkten Bitzugriff. (zB beim PCMSK). Das geht aber nur bei Registeradressen bis 0x1F. Die Register können aber hier anders angeordnet sein.
 
Genau, ist nur zum ersten testen, also noch nicht wirklich ernstzunehmen :)

Dank den InX / OutX Macros (hab ich hier im Forum schon mehrfach gepostet) macht mir das auch nichts aus wenn die Register wo anders liegen. ISR adressiere ich eh ausschließlich absolut, also mit dem jeweiligem Label.

Ich wollte nur vermeiden 100% auf dem Tiny zu debuggen. Ist ja jedes Mal wieder neu flashen (auch bei fast jedem Breakpoint, wie es im Einzelschritt Modus aussieht kA). Daher lieber ein paar LEDs.

Zugegeben, an die andere Taktfrequenz hab ich garnicht gedacht. Aber naja, in .Net übergeb ich ja die Baudrate als Integer, und da das USB Teil Chinaware ist mit angeblich 1MBaud wird man da wohl jede Frequenz einstellen können die einem beliebt ^^
Aber mal testen. Auf die TX Leitung kann ich mitm Skop ja drauf schaun und die Timings checken.
 
SZum Teil heißen die Register auch anders.
Deine Makros erschlagen nur das Problem mit der 0x3F-Grenze bezüglich IN/OUT und STS/LDS - betrifft also nur den Extended I/O-Space.
Den hat der Tiny13 gar nicht. Alle I/O-Register liegen hier im "normalen" I/O-pace bis 3F.
Ich meinte die Register, die im Bereich bis 0x1F liegen, und direct-Bit-accessible sind.
 
Hallo Tommy,

So ich hab jetzt mal ein Test aufgebaut. Ist zwar mit einem Mega168 (obwohl der Hardware UART hat nutz ich selbstverständlich n Port Pin, wär ja sonst sinnlos) aber dafür hab ich viele Pins frei für LEDs zum debuggen :)

Hmm... zum testen, oder wie?
Der ist natürlich etwas anders aufgebaut, insbesondere was die I/O-Register betrifft. Generell sollte es natürlich auch gehen, allerdings mußt Du einige Sachen prüfen:
...
  • das wichtigste jedoch: bei einigen Bits nutzte ich de direkten Bitzugriff. (zB beim PCMSK). Das geht aber nur bei Registeradressen bis 0x1F. Die Register können aber hier anders angeordnet sein.

beim Mega48,88,168,328 hab ich mich beim ersten Mal mächtig verjagt. Gegenüber dem Mega8 hat er doch so einiges an Standard-Registern (zB UART) in Memory-Bereichen die man nicht mehr direkt über Bitmanipulation ansprechen kann. Wenn man was von nem Tiny testen will, dann steht man sich mit nem Mega8 besser. Das ist einfacher umzusetzen. (Außer natürlich bei PCINT)

Gruß
Dino
 
Ok, jetzt bin ich etwas verwirrt.

Also ich bin jetzt noch nicht soo weit, ich hab erst mal die Initialisierung drin.
Hab ich mir gedacht ich teste die mal (ohne den UART) und geb erstmal n PWM Signal zum testen raus.
Du sagtest das würden 33400Hz ergeben, ich messe aber 39200Hz :confused:
Frequenz hab ich auf 8MHz angepasst.
Oder ist der interne RC so extrem ungenau? 0.o

Code:
	.EQU F_MCU = 8000000			; Chip clock (hz)
	.EQU Baud = 4800			; Soft UART baud rate
	.EQU T0Ov = (F_MCU/(Baud*8))-1	; Calculated overflow value for Timer 0
	.EQU PwmDdr = DDRD			; Hardware PWM DDR
	.EQU PwmDdp = DDD5			; Hardware PWM DDR Pin
...
	; Timer 0 + Hardware PWM
	LDI		Temp	, (1<<OCIE0A)
	STS		TIMSK0	, Temp	;IRQ bei Ueberlauf (WGM=7)
	LDI		Temp	, T0Ov
	OUT		OCR0A	, Temp		;Reichweite
	LDI		Temp	, (1<<COM0B1) | (1<<WGM01) | (1<<WGM00)
	OUT		TCCR0A	, Temp	;KanalB PWM, WGM=7
	LDI		Temp	, (1<<WGM02) | (1<<CS00)
	OUT		TCCR0B	, Temp	;Presc=1, WGM=7, Timer laeuft
	LDI		Temp	, (1<<PwmDdp)
	OUT		PwmDdr	, Temp

ldi Temp, 127
out OCR0B, Temp
...

Auch die Berechnung irritiert mich etwas.
Also das "(F_MCU/(Baud*8))-1".
Müsste das nicht Baud * 10 sein? oder sogar 11 oder 12? Wegen Start-, Parity- und Stopbit(s)?


Edit:
Ich hab leider keinen Mega8 hier. Aber Bitmanipulation mach ich eigentlich eh immer nur in den oberen Registern und nur sehr selten direkt im IO Bereich, daher hatte mich das (zumindest bisher) noch nie gestört.
 
Die 8 kommt vom 8fach Oversampling. Die Formel sollte stimmen - allerdings ist 8*4800=38400
(Keine Ahnung, was ich da Falsch gelesen hatte)

Du kannst ja mit Deinem Oszi (ist das denn wirklich genau?) mal den Cpu-Takt messen - der Mega hat mMn 'n Pin, wo man per Fuse den Takt ausgeben lassen kann.

Effektiv wärst Du derzeit ca 'ne halbe us zu schnell - pro Bit.
 
Ah ok, denn machts Sinn :)

Naja wie genau das wirklich ist kann ich natürlich nicht sagen, ich hab nichts woran ich das vergleichen könnte. Aber ich schätze mal grade bei Frequenzmessung sollte der recht genau sein. Ich glaub ich hab hier irgendwo noch n 32khz Crystal, vielleicht prüf ich das später mal. Weil bei nur 1MS/s kann man 8MHz schlecht messen :)

Aber denn driftet der ja nicht soo weit ab.

Edit: Hab den jetzt mit OSCCAL auf ziemlich genau 38,4KHz gebracht :)
IMAG0389.jpg
 
Hmm, schon wieder verwirrt. :(

Also ich hab jetzt mal 1 Byte über RS232 gesendet (vom PC) und das mit dem Skop aufgenommen. Aber das sieht anders aus als erwartet: (der rote Balken ist nachträglich eingefügt)
IMAGE044.png

Soweit wie ich gelesen hab (u. A. hier) sollte RS232 im Idle low sein, ist jedoch high. Erst kurz vor dem Byte geht es für 2,08ms auf low bevor das Ganze denn los geht.
Oder hab ich da was falsch verstanden? Diese 2ms kann ich mir nicht erklären.


p.s.: mein Skop sagt 1 Bit ist 208µS lang. Kommt das hin bei 4800 Baud?
 
Ist das jetzt RS232, oder TTL gewesen? Ich hatte bisher nur TTL angesehen, da das ja das ist, was der Mikrocontroller sieht.

Welches Byte hattest Du gesendet?
 
:banghead:
Ich bin so dumm ^^
Wenn der Puffer 2 Byte groß ist werden, tadaa, natürlich auch 2 Byte gesendet. Das erste war 0x00, daher die Pause :eek:
Was noch dazu verwirrt hat ist dass RS232 invertiert ist.

So schauts denn richtig aus:
ComTest_AA3C.png ComTest_AA55.png
Werte: 0xAA3C und 0xAA55


p.s.: Jupp, ist TTL.
 
Du hast quasi beim Skope nur zuviel gezoomt gehabt, oder wie (und deswegen das erste Byte nicht gesehen)?
Ich hatte bei der Sache mit dem NEC-Protokoll auch sowas ähnliches: da ich die Stackinitialisierung des vergessen hatte, ist der nach dem ersten gesendeten Byte permanent durchgelaufen (PC-Überlauf, kein Reset - deswegen war ein "kannst jetzt senden Flag" weiterhin gesetzt), hat also immer wieder was gesendet. Mein LA hat mir dann irgendwie nicht passende Telegramme gezeigt. In Wirklichkeit war aber jedes vermeintliche Bit ein ganzes Telegramm - was man erst nach dem Reinzoomen gesehen hat. Dann hats gestimmt. Ich hatte quasi zuviel Zeit auf'm Schirm dargestellt, und es zufällig so aus, wie irgendein Telegramm. Typisches Beispiel von "Wer viel mißt mißt Mist."...

Interessant an der Protokollencodierung des Logic8: er versucht das, was grad dargestellt wird zu interpretieren - also so, als wenn er ne Trägerfrequenz als alternierende Bits (0x55 zB) erkennt, zoomt man in ein Bit, und sieht dort'n anderen Verlauf, und eben auch 'ne andere Interpretation.
 

Ü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)