LED-Matrix mit Atmega8 (16Mhz) Wieivele Schieberegiste in Reihe?

[Thomas J. (rrurr)]

Hallo an alle,

ich beabsichtige eine LED-Matrix mit 16 x 8 (128) LEDs aufzubauen. Als 
µC möchte ich einen Atmega8 verwenden, an den ich einen 16 Mhz 
Quarzoszillator anschließe. Für das Ansprechen der LEDs wollte ich 16 
Schieberegister verwenden (pro Zeile ein Register).

Nun wollte ich mal fragen, wieviele Schieberegister ich in Reihe 
schalten, kann, ohne dass ich am Ende Probleme bekomme, weil es zu lange 
dauert, bis die Bits durchgeschoben wurden. (Also eine Laufschrift o.ä. 
sollte flüssig ablaufen, das wäre super.)
Bei 16 Mhz denke ich mir, könnte ich theoretisch alle 16 Register 
hintereinander schalten, habe aber noch keine praktischen Erfahrungen 
sammeln können und bevor ich das zusammenlöte, wollte ich mal hier 
nachfragen:

Hat jemand schon Erfahrungen mit dem in-Reihe-schalten von 
Schieberegistern an einen 16 Mhz µC?

Freue mich auf Antworten.

Gruß

[Eumel (Gast)]

1. Der Controller packt das locker, keine Angst. Das SPI Modul läuft mit 
maximal halbem Controller Takt, also bei dir 8 MHz. Mit 8Mhz hast du die 
128 bit in 16 µs rausgeschoben.

2. Normalerweise macht man sowas mit multiplexen, das reduziert den 
Verkabelungsaufwand deutlich, es geht aber auch so wie du es vor hast.

[Thomas J. (rrurr)]

1. Super, das freut mich :)

2. Ja, das Thema habe ich mal angekratzt .Werde mich in Zukunft damit 
mal richtig auseinander setzen, vorerst bin ich glücklich, wenn die 
Matrix läuft ;-)

Gruß

[Thomas J. (rrurr)]

Eine Frage hätte ich doch noch:

Sollte ich die Ansteuerung per SPI-Modul realiseren oder kann ich das 
auch (ist aus meiner Sicht einfacher) via Software machen?

Gruß

[Eumel (Gast)]

Thomas J. schrieb:
> Eine Frage hätte ich doch noch:
>
> Sollte ich die Ansteuerung per SPI-Modul realiseren oder kann ich das
> auch (ist aus meiner Sicht einfacher) via Software machen?
>
> Gruß

Via Software wird das um einiges langsamer (für deine Zwecke aber noch 
schnell genug). Ich finde, dass das SPI Modul vom Atmega8 kinderleicht 
zu bedienen ist, was stört dich denn daran? Wenn du dabei Hilfe 
brauchst, kein Problem.
In welcher Sprache programmierst du?

[egs_ti (Gast)]

man muss nur mal den inneren Schweinehund überwinden
 und ins Datenblatt schauen.

[Thomas J. (rrurr)]

Eumel schrieb:
> Via Software wird das um einiges langsamer (für deine Zwecke aber noch
> schnell genug). Ich finde, dass das SPI Modul vom Atmega8 kinderleicht
> zu bedienen ist, was stört dich denn daran? Wenn du dabei Hilfe
> brauchst, kein Problem.
> In welcher Sprache programmierst du?

Habe nun mal eine Schaltung erstellt, nach dem Vorgaben aus den 
Schieberegister-Artikel 
(http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister) 
bzw. so wie ich diese verstanden habe. Der Schaltplan befindet sich im 
Anhng (spi.png).
(Auf die Beschaltung des µC habe ich gerade mal verzichtet...)

Wollte das ganze in C programmieren.

Gruß

[amateur (Gast)]

@Thomas
128 LEDs sind in der Größenordnung, in der man auch das Netzteil 
konsultieren sollte.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Sieht gut so aus.
Bedenke, das SS im SPI Master Mode auch nurn normaler Ausgang ist und 
nicht vorm Modul gesteuert wird.

128bit sind kein Problem, habe hier für mein 4x16 Zeichen Display aus 
16Seg Anzeigen genau 17 SRegs hintereinander geschalten und das ist 
schnell genug.

[Thomas J. (rrurr)]

amateur schrieb:
> @Thomas
> 128 LEDs sind in der Größenordnung, in der man auch das Netzteil
> konsultieren sollte.

Verwende Low-Current LEDs, denke nicht, dass ich bei einem 5 Volt und 
700mAh Probleme bekomme.


Martin Wende schrieb:
> Sieht gut so aus.
> Bedenke, das SS im SPI Master Mode auch nurn normaler Ausgang ist und
> nicht vorm Modul gesteuert wird.

Was genau möchtest du mir hiermit sagen? Dass ich das bei der 
Programmierung berücksichtigen mus?

Gruß

[Knut B. (Firma: TravelRec.) (travelrec)]

/SS muss vor dem Einschalten des Master-SPI-Mode auf AUSGANG geschaltet 
werden. Andernfalls tritt sich das SPI selbst auf den Fuß, wenn sich der 
Pegel an /SS auf Low ändert. Wenn Du den /SS-Pin für die Register mit 
verwenden möchtest, so muss dieser in Software getoggelt werden, wenn es 
erforderlich ist.

[Eumel (Gast)]

Thomas J. schrieb:
> Verwende Low-Current LEDs, denke nicht, dass ich bei einem 5 Volt und
> 700mAh Probleme bekomme.

Nicht denken sondern RECHNEN!

[Peter D. (peda)]

Thomas J. schrieb:
> Der Schaltplan befindet sich im
> Anhng (spi.png).

Den Anschluß G würde ich auf eine PWM legen, dann kann man die LEDs 
dimmen.
Und einen Pullup dran, damit die LEDs nicht flackern, wenn der MC noch 
im Reset ist.

[Thomas J. (rrurr)]

Eumel schrieb:
> Thomas J. schrieb:
>> Verwende Low-Current LEDs, denke nicht, dass ich bei einem 5 Volt und
>> 700mAh Probleme bekomme.
>
> Nicht denken sondern RECHNEN!

Eine LED verbraucht maximal 2 mA bei 128 LEDs ergibt sich ein maximaler
Strom von 256 mA, nur für die LEDs. Bleiben also noch 444 mA für
Microcontroller und Quarz bzw. die Operationen ansich in den Registern.



Peter Dannegger schrieb:
> Thomas J. schrieb:
>> Der Schaltplan befindet sich im
>> Anhng (spi.png).
>
> Den Anschluß G würde ich auf eine PWM legen, dann kann man die LEDs
> dimmen.
> Und einen Pullup dran, damit die LEDs nicht flackern, wenn der MC noch
> im Reset ist.

Den Pullup ist mittlerweile dran, aber danke für den Hinweis. Das mit 
PWM ist 'ne gute Idee, danke!

[Electronics'nStuff (Gast)]

Hi

Bin auch ein bisschen vorsichtig an die SPI Sache rangegangen, aber das 
ist wirklich kinderleicht!

Beschaltung hast du ja schon (oben).. du brauchst nur das hier:

/**************** INCLUDES ***************************************/
#include <avr/io.h>          //I/O library
/****************************************************************/

/**************** DEFINES ***************************************/
#define F_CPU 20000000  //Frequenz -> 20MHZ
/****************************************************************/
#define MOSI  PB5 //Pinbelegung von einem ATMEGA644
#define SCK   PB7
#define SPI   DDRB
#define SS    PB4


void main()
{

 SPI_MasterInit();

 while (1)
 {

   SPI_MasterTransmit(12);

 }

}
 

void SPI_MasterInit(void)
{
   SPI = (1<<MOSI)|(1<<SCK) | (1<<SS);  //MOSI, SCK, SS Output
   SPCR = (1<<SPE)|(1<<MSTR); //Master Enable
   SPSR = (1<<SPI2X);         //Geschwindigkeit = FOSC/2
}
void SPI_MasterTransmit(char cData)
{
   SPDR = cData;
   while(!(SPSR & (1<<SPIF))); // Auf Abschluss der Ausgabe warten
   SSToggle(); //SS-Pin Toggeln
}

[Electronics'nStuff (Gast)]

Und wenn du eh gerade an der Planung bist.. nimm einen ATMEGA644 der 
schafft auch 20MHZ und braucht so nur 800ns für 8 Bit!