AT90USB1287 - ISR viel zu langsam!

Im Unterforum Microcontroller - Beschreibung: Hardware - Software - Ideen - Projekte

Elektronik Forum Nicht eingeloggt       Einloggen       Registrieren




[Registrieren]      --     [FAQ]      --     [ Einen Link auf Ihrer Homepage zum Forum]      --     [ Themen kostenlos per RSS in ihre Homepage einbauen]      --     [Einloggen]

Suchen


Serverzeit: 24 11 2024  20:24:42      TV   VCR Aufnahme   TFT   CRT-Monitor   Netzteile   LED-FAQ   Osziloskop-Schirmbilder            

Elektronik- und Elektroforum Forum Index   >>   Microcontroller        Microcontroller : Hardware - Software - Ideen - Projekte


Autor
AT90USB1287 - ISR viel zu langsam!

    







BID = 700221

Knutwurst

Neu hier


Avatar auf
fremdem Server !
Hochladen oder
per Mail an Admin

Beiträge: 41
Wohnort: Hamburg
 

  


Moin Moin,

Da ich weiß, dass niemand gerne sehr lange Texte liest, komme ich einfach mal auf den Punkt:

Ich arbeite gerade daran, einen RGB LED Cube mit einem Mikrocontroller der AT90USB Serie anzusteuern, und diesen dann als USB 3D-Display zu verwenden. Den genauen Aufbau teile ich gern auf Anfrage mit, aber momentan bereitet mir etwas anderes Kopfzerbrechen... und zwar die Geschwindigkeit. Klar, 16Mhz sind nicht viel, aber ich hatte gehofft, dass ich einen Timer wenigstens mit 1Mhz laufen lassen könnte... jedoch Pustekuchen.

Die Konfiguration meines Timers sieht so aus:


Code : 


OCR0A  = 60;       // <-- weniger geht nicht, da sonst USB schon ausfällt!

TCCR0A = (1 << WGM01);

TCCR0B = (1 << CS00);

TIMSK0 = (1 << OCIE0A);



Und die ISR selbst:



Code : 


ISR(TIMER0_COMPA_vect, ISR_BLOCK)

{

/*

	 * PORTB 0 = LE   (P10 -> 7)

	 * PORTB 1 = CLK  (P10 -> 5)

	 * PORTB 2 = SDI  (P10 -> 3)

	 *

	 * PORTB 4 = OE   (P10 -> 1)

	 * PORTB 5 = B    (P10 -> 8)

	 * PORTB 6 = G    (P10 -> 6)

	 * PORTB 7 = R    (P10 -> 4)

	 *

	 * PORTD 0 = LE 1

	 * PORTD 1 = LE 2

	 * PORTD 2 = LE 3

	 * PORTD 3 = LE 4

	 * PORTD 4 = LE 5

	 * PORTD 5 = LE 6

	 * PORTD 6 = LE 7

	 * PORTD 7 = LE 8

	 */





	/*

	 * Bitmuster an den Ports zwischenspeichern

	 */

	tempPORTB = PORTB;

	tempPORTD = PORTD;



	/*

	 * Clock berechnen und zürücksetzen

	 */

	if(++CLK == 2)

	{

		CLK = 0;

		tempPORTB CLEAR_BIT1; //CLK=0

	}else{

		tempPORTB SET_BIT1; //CLK=1



		if(++LEDSubCount == 64)

		{

			/*

			 * Werte für die Farbe der aktuellen LED/Reihe

			 * an den PWM Generator für die MOSFETS übergeben

			 */



			SoftPWM_Channel_R_Duty = (framebuffer2[RowCount][LEDCount] & 0b0000111100000000) >> 8;

			SoftPWM_Channel_G_Duty = (framebuffer2[RowCount][LEDCount] & 0b0000000011110000) >> 4;

			SoftPWM_Channel_B_Duty = (framebuffer2[RowCount][LEDCount] & 0b0000000000001111);

			

			/*

			 * PORTB Bit 0 = Latch Enable für alle

		 	 * LED Treiber auf einem Modul.

		 	 */

			tempPORTB SET_BIT0; //LE=1

			LEDCount++;

			LEDSubCount = 0;

		}else{

			tempPORTB CLEAR_BIT0; //LE=0;

		}



		/*

		 * Clock für ein Led-modul berechnen und

		 * ggf. zurücksetzen

		 *

		 * PORTB Bit 4 = Output Enable für das aktuelle

		 * LED Modul. Output wird abgeschaltet, wenn Modul

		 * nicht mit Daten versorgt wird.

		 */

		if(LEDCount == 64)

		{

			RowCount++;

			LEDCount = 0;

			tempPORTB SET_BIT4; //OE=0 (invertiert)

		}else{

			tempPORTB CLEAR_BIT4; //OE=1 (invertiert)

		}



		/*

		 * Ausgänge für die aktuelle Reihe aktivieren

		 */

		if(RowCount == 8)

		{

			RowCount = 0;

		}



		tempPORTD = RowCount+1;



		/*

		 * Bei steigender Flanke die gewählte LED (von 64)

		 * innerhalb einers Modules (RowCount) setzen.

		 * LEDSubCount ist hierbei die 'innere' Schleife

		 *

		 *

		 * PORTB Bit 1 = CLK

		 * PORTB Bit 2 = SDI

		 */

		if(LEDSubCount == LEDCount)

		{

			tempPORTB SET_BIT2; //SDI=1

		}else{

			tempPORTB CLEAR_BIT2; //SDI=0

		}		

	}





	/*

	 * PWM Generator für die Farbansteuerung

	 *

	 * PORTB Bit5 = blau

	 * PORTB Bit6 = grün

	 * PORTB Bit7 = rot

	 *

	 */

	if (++SoftPWM_Count == 0b00010000)

		  SoftPWM_Count = 0;



	/*

	 * ROT

	 */

	if (SoftPWM_Count >= SoftPWM_Channel_R_Duty)

	{

		tempPORTB SET_BIT7;

	}else{

		tempPORTB CLEAR_BIT7;

	}



	/*

	 * GRÜN

	 */

	if (SoftPWM_Count >= SoftPWM_Channel_G_Duty)

	{

		tempPORTB SET_BIT6;

	}else{

		tempPORTB CLEAR_BIT6;

	}



	/*

	 * BLAU

	 */

	if (SoftPWM_Count >= SoftPWM_Channel_B_Duty)

	{

		tempPORTB SET_BIT5;

	}else{

		tempPORTB CLEAR_BIT5;

	}





	/*

	 * Alle Veränderungen an den Ports wieder zurückschreiben

	 */

	//PORTB |= (1<<tempPORTB) & 0b00010111;

	//PORTD |= (1<<tempPORTD) & 0b11111111;

	PORTB = tempPORTB;

	PORTD = tempPORTD;

}



Hat jemand eine Idee, wie ich das Ganze schneller bekomme? CLK/60 kann doch nicht das Maximum sein.. oder?

Gruß
Knutwurst

BID = 700235

DonComi

Inventar



Beiträge: 8605
Wohnort: Amerika

 

  
Hallo Knutwurst;

Das kann so doch nichts werden. Wenn du CLK/60 hast, dann kannst du ja nichtmal 60 elementare Instruktionen in der ISR ausführen, weil dann der nächste IRQ kommt.


In einer ISR sollte man allgemein keine großartigen Berechnungen durchführen. Wenn es doch sein muss und zusätzlich zeitkritisch ist, sollte das in Assembler kodiert werden.
Dann entfällt auch der enorme Overhead, den der GCC als Prolog und Epilog in die ISR mit einbaut. Hardwaremäßig wird der PC auf den Stack geschmissen und die Adresse der ISR geladen -> vier Instruktionen. Dann kommen, vom GCC erzeugt, die Sicherung des Statusregisters und die Initialisierung einiger Register und sichern alter Inhalte auf dem Stack... Allein dieser Overhad benötigt bestimmt schon 80% der 60 Taktzyklen.

Schau dir diebezüglich mal das Disassembling an: avr-objdump -d objdatei
Wetten, dass dort zig pops kommen, bevor überhaupt dein Kode drankommt?



Fazit: schlechtes Programmdesign oder schlicht zu langsamer Controller.
Schreibe es in Assembler und linke es hinzu - du darfst dann natürlich keine C-Funktionen aus ASM ausführen! Kein Frame vorhanden.

_________________


[ Diese Nachricht wurde geändert von: DonComi am  5 Jul 2010 14:24 ]

BID = 700238

Knutwurst

Neu hier


Avatar auf
fremdem Server !
Hochladen oder
per Mail an Admin

Beiträge: 41
Wohnort: Hamburg

Danke DonComi für die schnelle Antwort,
ja... dass die ISR zu groß ist, hab ich mir doch schon gedacht. Wenn ich sie sehr abspecke (nur ein.. zwei PORT Befehle) dann läuft es auch wunderbar. Viel Zeit scheint das Verwenden von globalen Variablen wie z.B. SoftPWM_Count zu verbrauchen.

Ist es denn überhaupt möglich, so schnell so viele Daten über die Ports zu senden? Wenn ja, wie? Oder brauche ich wirklich einen schnelleren Controller?

Das Programmdesign würde ich auch komplett umstricken, wenn ich einen Ansatz und Hoffnung hätte, dass es klappt.

BID = 700244

DonComi

Inventar



Beiträge: 8605
Wohnort: Amerika

Also, du hast weniger als 60 Taktzyklen und willst ja auch nochmal was im Hauptprogramm erledigen.

Es ist sehr knapp.
Eine IO-Operation dauert allein bereits zwei Taktzyklen.

Ich habe mir das nicht näher angeschaut, aber mit ein wenig Assemblerkenntnissen kann man das deutlich beschleunigen.

Dabei muss man auch schonmal zu einigen Kniffen greifen

Was sagt denn objdump?

Edit: welchen µC nutzt du denn?
Der Mega48 kann bis zu 20MHz, hat aber auch nur 4k ROM und kein USB.



_________________


[ Diese Nachricht wurde geändert von: DonComi am  5 Jul 2010 14:46 ]

BID = 700248

Knutwurst

Neu hier


Avatar auf
fremdem Server !
Hochladen oder
per Mail an Admin

Beiträge: 41
Wohnort: Hamburg

Wie die Überschrift schon sagt, benutze ich einen AT90USB1287 mit 16Mhz Quartz.

Also eigentlich hab ich noch viel weniger als 60 Zyklen... am liebsten würde ich alles in 8 erledigen

In der ISR siehst du ja, was ich ungefähr vorhabe - und das muss eben sehr sehr schnell gehen. Im Grunde sind es ja nur ein Haufen vergleiche und schließlich eine Ausgabe an die Ports. Mein Controller ist hierbei eigentlich nur ein Signalgenerator, welcher einen internen Puffer besitzt, den man über USB füllen kann. Letzteres funktioniert auch schon sehr gut.

Die Disassemblierung von der ISR sieht übrigens so aus:


Code : 


Disassembly of section .text.__vector_21:



00000000 <__vector_21>:

   0:	1f 92       	push	r1

   2:	0f 92       	push	r0

   4:	0f b6       	in	r0, 0x3f	; 63

   6:	0f 92       	push	r0

   8:	0b b6       	in	r0, 0x3b	; 59

   a:	0f 92       	push	r0

   c:	11 24       	eor	r1, r1

   e:	8f 93       	push	r24

  10:	9f 93       	push	r25

  12:	ef 93       	push	r30

  14:	ff 93       	push	r31

  16:	85 b1       	in	r24, 0x05	; 5

  18:	80 93 00 00 	sts	0x0000, r24

  1c:	8b b1       	in	r24, 0x0b	; 11

  1e:	80 93 00 00 	sts	0x0000, r24

  22:	29 98       	cbi	0x05, 1	; 5

  24:	80 91 00 00 	lds	r24, 0x0000

  28:	8f 5f       	subi	r24, 0xFF	; 255

  2a:	80 93 00 00 	sts	0x0000, r24

  2e:	80 91 00 00 	lds	r24, 0x0000

  32:	80 34       	cpi	r24, 0x40	; 64

  34:	01 f0       	breq	.+0      	; 0x36 <__vector_21+0x36>

  36:	00 c0       	rjmp	.+0      	; 0x38 <__vector_21+0x38>

  38:	e0 91 00 00 	lds	r30, 0x0000

  3c:	f0 e0       	ldi	r31, 0x00	; 0

  3e:	80 91 00 00 	lds	r24, 0x0000

  42:	96 e0       	ldi	r25, 0x06	; 6

  44:	ee 0f       	add	r30, r30

  46:	ff 1f       	adc	r31, r31

  48:	9a 95       	dec	r25

  4a:	01 f4       	brne	.+0      	; 0x4c <__vector_21+0x4c>

  4c:	e8 0f       	add	r30, r24

  4e:	f1 1d       	adc	r31, r1

  50:	ee 0f       	add	r30, r30

  52:	ff 1f       	adc	r31, r31

  54:	e0 50       	subi	r30, 0x00	; 0

  56:	f0 40       	sbci	r31, 0x00	; 0

  58:	80 81       	ld	r24, Z

  5a:	91 81       	ldd	r25, Z+1	; 0x01

  5c:	80 70       	andi	r24, 0x00	; 0

  5e:	9f 70       	andi	r25, 0x0F	; 15

  60:	90 93 00 00 	sts	0x0000, r25

  64:	e0 91 00 00 	lds	r30, 0x0000

  68:	f0 e0       	ldi	r31, 0x00	; 0

  6a:	80 91 00 00 	lds	r24, 0x0000

  6e:	96 e0       	ldi	r25, 0x06	; 6

  70:	ee 0f       	add	r30, r30

  72:	ff 1f       	adc	r31, r31

  74:	9a 95       	dec	r25

  76:	01 f4       	brne	.+0      	; 0x78 <__vector_21+0x78>

  78:	e8 0f       	add	r30, r24

  7a:	f1 1d       	adc	r31, r1

  7c:	ee 0f       	add	r30, r30

  7e:	ff 1f       	adc	r31, r31

  80:	e0 50       	subi	r30, 0x00	; 0

  82:	f0 40       	sbci	r31, 0x00	; 0

  84:	80 81       	ld	r24, Z

  86:	91 81       	ldd	r25, Z+1	; 0x01

  88:	80 7f       	andi	r24, 0xF0	; 240

  8a:	90 70       	andi	r25, 0x00	; 0

  8c:	e4 e0       	ldi	r30, 0x04	; 4

  8e:	96 95       	lsr	r25

  90:	87 95       	ror	r24

  92:	ea 95       	dec	r30

  94:	01 f4       	brne	.+0      	; 0x96 <__vector_21+0x96>

  96:	80 93 00 00 	sts	0x0000, r24

  9a:	e0 91 00 00 	lds	r30, 0x0000

  9e:	f0 e0       	ldi	r31, 0x00	; 0

  a0:	80 91 00 00 	lds	r24, 0x0000

  a4:	96 e0       	ldi	r25, 0x06	; 6

  a6:	ee 0f       	add	r30, r30

  a8:	ff 1f       	adc	r31, r31

  aa:	9a 95       	dec	r25

  ac:	01 f4       	brne	.+0      	; 0xae <__vector_21+0xae>

  ae:	e8 0f       	add	r30, r24

  b0:	f1 1d       	adc	r31, r1

  b2:	ee 0f       	add	r30, r30

  b4:	ff 1f       	adc	r31, r31

  b6:	e0 50       	subi	r30, 0x00	; 0

  b8:	f0 40       	sbci	r31, 0x00	; 0

  ba:	80 81       	ld	r24, Z

  bc:	91 81       	ldd	r25, Z+1	; 0x01

  be:	8f 70       	andi	r24, 0x0F	; 15

  c0:	80 93 00 00 	sts	0x0000, r24

  c4:	80 91 00 00 	lds	r24, 0x0000

  c8:	81 60       	ori	r24, 0x01	; 1

  ca:	80 93 00 00 	sts	0x0000, r24

  ce:	80 91 00 00 	lds	r24, 0x0000

  d2:	8f 5f       	subi	r24, 0xFF	; 255

  d4:	80 93 00 00 	sts	0x0000, r24

  d8:	10 92 00 00 	sts	0x0000, r1

  dc:	00 c0       	rjmp	.+0      	; 0xde <__vector_21+0xde>

  de:	80 91 00 00 	lds	r24, 0x0000

  e2:	8e 7f       	andi	r24, 0xFE	; 254

  e4:	80 93 00 00 	sts	0x0000, r24

  e8:	80 91 00 00 	lds	r24, 0x0000

  ec:	80 34       	cpi	r24, 0x40	; 64

  ee:	01 f4       	brne	.+0      	; 0xf0 <__vector_21+0xf0>

  f0:	80 91 00 00 	lds	r24, 0x0000

  f4:	8f 5f       	subi	r24, 0xFF	; 255

  f6:	80 93 00 00 	sts	0x0000, r24

  fa:	10 92 00 00 	sts	0x0000, r1

  fe:	80 91 00 00 	lds	r24, 0x0000

 102:	80 61       	ori	r24, 0x10	; 16

 104:	00 c0       	rjmp	.+0      	; 0x106 <__vector_21+0x106>

 106:	80 91 00 00 	lds	r24, 0x0000

 10a:	8f 7e       	andi	r24, 0xEF	; 239

 10c:	80 93 00 00 	sts	0x0000, r24

 110:	80 91 00 00 	lds	r24, 0x0000

 114:	88 30       	cpi	r24, 0x08	; 8

 116:	01 f4       	brne	.+0      	; 0x118 <__vector_21+0x118>

 118:	10 92 00 00 	sts	0x0000, r1

 11c:	80 91 00 00 	lds	r24, 0x0000

 120:	8f 5f       	subi	r24, 0xFF	; 255

 122:	80 93 00 00 	sts	0x0000, r24

 126:	90 91 00 00 	lds	r25, 0x0000

 12a:	80 91 00 00 	lds	r24, 0x0000

 12e:	98 17       	cp	r25, r24

 130:	01 f4       	brne	.+0      	; 0x132 <__vector_21+0x132>

 132:	80 91 00 00 	lds	r24, 0x0000

 136:	84 60       	ori	r24, 0x04	; 4

 138:	00 c0       	rjmp	.+0      	; 0x13a <__vector_21+0x13a>

 13a:	80 91 00 00 	lds	r24, 0x0000

 13e:	8b 7f       	andi	r24, 0xFB	; 251

 140:	80 93 00 00 	sts	0x0000, r24

 144:	80 91 00 00 	lds	r24, 0x0000

 148:	8f 5f       	subi	r24, 0xFF	; 255

 14a:	80 93 00 00 	sts	0x0000, r24

 14e:	80 91 00 00 	lds	r24, 0x0000

 152:	80 31       	cpi	r24, 0x10	; 16

 154:	01 f4       	brne	.+0      	; 0x156 <__vector_21+0x156>

 156:	10 92 00 00 	sts	0x0000, r1

 15a:	90 91 00 00 	lds	r25, 0x0000

 15e:	80 91 00 00 	lds	r24, 0x0000

 162:	98 17       	cp	r25, r24

 164:	00 f0       	brcs	.+0      	; 0x166 <__vector_21+0x166>

 166:	80 91 00 00 	lds	r24, 0x0000

 16a:	80 68       	ori	r24, 0x80	; 128

 16c:	00 c0       	rjmp	.+0      	; 0x16e <__vector_21+0x16e>

 16e:	80 91 00 00 	lds	r24, 0x0000

 172:	8f 77       	andi	r24, 0x7F	; 127

 174:	80 93 00 00 	sts	0x0000, r24

 178:	90 91 00 00 	lds	r25, 0x0000

 17c:	80 91 00 00 	lds	r24, 0x0000

 180:	98 17       	cp	r25, r24

 182:	00 f0       	brcs	.+0      	; 0x184 <__vector_21+0x184>

 184:	80 91 00 00 	lds	r24, 0x0000

 188:	80 64       	ori	r24, 0x40	; 64

 18a:	00 c0       	rjmp	.+0      	; 0x18c <__vector_21+0x18c>

 18c:	80 91 00 00 	lds	r24, 0x0000

 190:	8f 7b       	andi	r24, 0xBF	; 191

 192:	80 93 00 00 	sts	0x0000, r24

 196:	90 91 00 00 	lds	r25, 0x0000

 19a:	80 91 00 00 	lds	r24, 0x0000

 19e:	98 17       	cp	r25, r24

 1a0:	00 f0       	brcs	.+0      	; 0x1a2 <__vector_21+0x1a2>

 1a2:	80 91 00 00 	lds	r24, 0x0000

 1a6:	80 62       	ori	r24, 0x20	; 32

 1a8:	00 c0       	rjmp	.+0      	; 0x1aa <__vector_21+0x1aa>

 1aa:	80 91 00 00 	lds	r24, 0x0000

 1ae:	8f 7d       	andi	r24, 0xDF	; 223

 1b0:	80 93 00 00 	sts	0x0000, r24

 1b4:	29 9a       	sbi	0x05, 1	; 5

 1b6:	80 91 00 00 	lds	r24, 0x0000

 1ba:	85 b9       	out	0x05, r24	; 5

 1bc:	80 91 00 00 	lds	r24, 0x0000

 1c0:	8b b9       	out	0x0b, r24	; 11

 1c2:	ff 91       	pop	r31

 1c4:	ef 91       	pop	r30

 1c6:	9f 91       	pop	r25

 1c8:	8f 91       	pop	r24

 1ca:	0f 90       	pop	r0

 1cc:	0b be       	out	0x3b, r0	; 59

 1ce:	0f 90       	pop	r0

 1d0:	0f be       	out	0x3f, r0	; 63

 1d2:	0f 90       	pop	r0

 1d4:	1f 90       	pop	r1

 1d6:	18 95       	reti


Ja.... viel .... sehr viel...
Assemblerkenntinisse hab ich - jedoch sehr schlechte würde ich behaupten, da das schon ein paar Semester zurückliegt

[ Diese Nachricht wurde geändert von: Knutwurst am  5 Jul 2010 15:08 ]

BID = 700256

DonComi

Inventar



Beiträge: 8605
Wohnort: Amerika

Stimmt, habe den Titel überlesen

Also, ich möchte mal behaupten, dass man das für sechszig Zyklen schaffen kann - acht: keine Chance.

Wenn du schonmal direkt in ASM programmiert hast, ist dir das ja nicht ganz fremd.

Schau mal ins Datenblatt, dort stehen alle Mnemonics drin. Wie du das mit deinem C-Programm verlinken kannst, schreib ich dir dann später.


Ich muss ins Bett - bin auch seit drei Tagen dabei, noch die Programme für Informatik fertig zu bekommen .
Hab sie vor fünf Minuten abgeschickt, und brauche jetzt Pause.

_________________

BID = 700751

Knutwurst

Neu hier


Avatar auf
fremdem Server !
Hochladen oder
per Mail an Admin

Beiträge: 41
Wohnort: Hamburg


Zitat :
DonComi hat am  5 Jul 2010 16:22 geschrieben :

Stimmt, habe den Titel überlesen

Kann jedem mal passieren


Zitat :

Also, ich möchte mal behaupten, dass man das für sechszig Zyklen schaffen kann - acht: keine Chance.

Woah... ganz vergessen wie hässlich Assembler doch ist... aber ich habs soweit. Leider brauch ich selbst ohne wegsichern der Register noch zu lange. Ich schätze ein einzelner 16Mhz µC ist für 512 RGB LEDs einfach zu schwach.

Jetzt verwerfe ich diesen Ansatz (Hauptplatine ist sowieso noch nicht fertig, und das Design habe ich schon geändert) und hab jetzt ein neues Design für insgesamt 9 Mikrocontroller, die sich die Arbeit teilen. Der AT90USB übernimmt dann nur noch die Kommunikation über USB und das Routing zwischen den einzelnen µCs ...

Jetzt meine neue Frage:
Ich möchte 8 weitere ATMEGA164P-20AU-ND verwenden, die sich jeweils dann nur um 64 LEDs samt PWM kümmern müssen. Der von Atmel angegebene nominaltakt liegt bei 20Mhz.... kann ich diese Controller auch schneller betreiben? 24...25Mhz? Oder ist der interne RAM zu langsam?


Zitat :

Ich muss ins Bett - bin auch seit drei Tagen dabei, noch die Programme für Informatik fertig zu bekommen .

Lass mich raten... du studierst auch Informatik/Technische Informatik o.ä. und steckst gerade in den Klausurwochen?


Viele Grüße
Knutwurst

BID = 700771

Nukeman

Schriftsteller



Beiträge: 754
Wohnort: bei Kleve

Ich hab hier einen Attiny2313 auf 24MHz laufen, macht überhaupt keine
Probleme.
Wenn es ein Einzelprojekt ist, kann man vielleicht die Bausteine etwas
selektieren.
Besser wär aber schon, wenn der Ansatz es hergeben würde, dass Du sie
nicht übertakten brauchst. Oft steigt die Peripherie dann irgendwann
aus ( Flash, E2, ADC etc ).

Wie wolltest Du die Ausgänge denn designen? 8x8Bit Latches?
Wieviele PWM-Abstufungen sollen realisiert werden? Das hat ja auch
nochmal ordentlichen Einfluss auf die resultierende PWM-Frequenz.

Gruß
Stefan

BID = 700792

Knutwurst

Neu hier


Avatar auf
fremdem Server !
Hochladen oder
per Mail an Admin

Beiträge: 41
Wohnort: Hamburg

Na das klingt doch vielversprechend! Jetzt müsste ich eigentlich nur testen, ob meine atmega164 das auch mitmachen... Theoretisch kann ich ja auch einfach mehere Sätze Quarze mitbestellen - das lohnt nur nicht, wenn es schon vorher völlig aussichtslos wäre.


Zitat :
Wie wolltest Du die Ausgänge denn designen? 8x8Bit Latches?
Wieviele PWM-Abstufungen sollen realisiert werden?

Ich verwende 4x16Bit (x8 Ebenen) Konstantstrom LED-Treiber, welche immer die Kathode gegen Masse ziehen. Anode wird zusammen über 3 Mosfets per 3x4Bit PWM angesteuert.

Vielen Dank für dir bisher zahlreichen und kompetenten Antworten. Ich werd jetzt ins Bett gehen... wünsche euch noch einen schönen Abend!


Gruß
Knutwurst

[ Diese Nachricht wurde geändert von: Knutwurst am  8 Jul 2010 21:57 ]

BID = 701285

Knutwurst

Neu hier


Avatar auf
fremdem Server !
Hochladen oder
per Mail an Admin

Beiträge: 41
Wohnort: Hamburg

hmmm... ich beantworte mich mal selbst: Ich machs! Hab einfach mal n satz 20 und 24Mhz Quarze bestellt.

Jetzt hab ich aber noch ne Frage, die eigentlich wieder nicht zum Thema gehört:

Ich hab in AVR042 auf Seite 7 gelesen, dass es möglich ist, eine JTAG Daisychain aufzubauen. Natürlich steht da nichts darüber, ob das mit meinen Controllern auch geht, und ob ich dann auch noch jeden einzelnen debuggen kann... oder sogar gleichzeitig? Brauche ich Jumper zum auswählen der einzelnen Chips oder geht das in einem Rutsch?

Mein Programmer ist ein JTAGICE MKII in Verbindung mit AVR Studio. Software kann man ändern - einen anderen Programmer bekomme ich aber nicht so einfach.


Zurück zur Seite 0 im Unterforum          Vorheriges Thema Nächstes Thema 


Zum Ersatzteileshop


Bezeichnungen von Produkten, Abbildungen und Logos , die in diesem Forum oder im Shop verwendet werden, sind Eigentum des entsprechenden Herstellers oder Besitzers. Diese dienen lediglich zur Identifikation!
Impressum       Datenschutz       Copyright © Baldur Brock Fernsehtechnik und Versand Ersatzteile in Heilbronn Deutschland       

gerechnet auf die letzten 30 Tage haben wir 20 Beiträge im Durchschnitt pro Tag       heute wurden bisher 23 Beiträge verfasst
© x sparkkelsputz        Besucher : 182391810   Heute : 6548    Gestern : 6874    Online : 567        24.11.2024    20:24
2 Besucher in den letzten 60 Sekunden        alle 30.00 Sekunden ein neuer Besucher ---- logout ----viewtopic ---- logout ----
xcvb ycvb
0.0411751270294