WS2811 Lib (optimierungen)

[Tobias N. (silberkristall)]

Hallo,

ich habe mir mal eine WS2811 Library geschrieben. Nunja, diese verstehe 
ich wenigstens. Klappen tut auch alles soweit aber ich würde diese noch 
ein wenig optimieren.

Mir geht es hautpsächlich darum das man das ganze noch mit der Frequenz 
machen kann. Also anhand der F_CPU.

Mit der berrechnung habe ich leider noch nicht soviele erfahrungen.

Derzeit habe ich das Fix auf 8Mhz erstellt. Ein Takt dauert demnach 
125ns aber wenn ich nun berechne z.b.

takttime = (((1 / F_CPU) * 1000) * 1000) * 1000

dann habe ich in takttime die taktzeit, bei 8Mhz also 125ns, aber wie 
geht es dann weiter?

Wenn ich das wiederrum mit einer berrechne und das wiederrum durch eine 
Schleife laufen lasse habe ich ja wieder ein timing problem was 
angepasst werden muss.

Ich hoffe ihr könnt mir da weiter helfen.

[Tobias N. (silberkristall)]

Habe mal was angepasst.

ws2811.h

int takttime = (((1 / F_CPU) * 1000) * 1000) * 1000;

int onehightakte = (1250 / takttime) - 1;
int onelowtakte =  (1250 / takttime) - 1;
int zerohightakte = (500 / takttime) - 1;
int zerolowtakte = (2000 / takttime) - 1;

ws2811.c

void wswrite_zero(void)
{
  // 500ns +- 150ns high
  WSPORT |= (1<<WSPIN); // 125ns
  for (int i=0; i<zerohightakte; i++)
  {
    nop();
  }
  // 2000ns +- 150ns low
  WSPORT &= ~(1<<WSPIN); // 125ns
  for (int i=0; i<zerolowtakte; i++)
  {
    nop();
  }

}

void wswrite_one(void)
{
  // 1200ns +- 150ns high
  WSPORT |= (1<<WSPIN); // 125ns
  for (int i=0; i<onehightakte; i++)
  {
    nop();
  }
  // 1300ns +- 150ns low
  WSPORT &= ~(1<<WSPIN); // 125ns
  for (int i=0; i<onelowtakte; i++)
  {
    nop();
  }
}

[Frank M. (ukw) (Moderator)]

Tobias N. schrieb:
> Habe mal was angepasst.
>
> ws2811.h
>

> int takttime = (((1 / F_CPU) * 1000) * 1000) * 1000;
> 
> int onehightakte = (1250 / takttime) - 1;
> int onelowtakte =  (1250 / takttime) - 1;
> int zerohightakte = (500 / takttime) - 1;
> int zerolowtakte = (2000 / takttime) - 1;
>

Da dieses Werte alle konstant sind, rate ich Dir, sie mit 
Preprocessor-Konstanten zu erschlagen. Dann kann die Berechnung durch 
den Compiler erfolgen und muß nicht mühselig vom µC erledigt werden.

Also:

#define TAKTTIME (((1 / F_CPU) * 1000) * 1000) * 1000

bzw. kürzer:

#define TAKTTIME (1000000000UL / F_CPU)

Rest:

#define ONEHIGHTAKTE  ((1250 / TAKTTIME) - 1)
#define ONELOWTAKTE   ((1250 / TAKTTIME) - 1)
#define ZEROHIGHTAKTE (( 500 / TAKTTIME) - 1)
#define ZEROLOWTAKTE  ((2000 / TAKTTIME) - 1)

Dieser Mischmasch aus deutsch und Englisch sieht aber schon irgendwie 
beknackt aus, oder? ;-)

Was meinst Du, was der Compiler daraus macht:

> for (int i=0; i<onelowtakte; i++)
> {
>     nop();
> }

Neben Initialisierung und ständigem Vergleich mit einer Variablen bzw. 
einem festen Wert auch noch "nebenbei" mal ein NOP. Deine Schleifen 
verbrauchen ein Vielfaches!

Mein Tipp: Benutze besser _delay_us(), das kann das wesentlich besser. 
Damit kannst Du dann Deine ganze Taktberechnungen bzw. Schleifen wieder 
rausschmeissen.

[Tobias N. (silberkristall)]

Hallo,

cool, danke :)

Ja sieht schon ein wenig komisch aus :) Kann man ja noch ändern g

Jetzt muss ich noch noch das Timing der Schleifen anpassen, richtig?

Und ggf. wenn eine "krumme" zahl raus kommt anpassen, richtig?

[Tobias N. (silberkristall)]

_delay_us() bringt mir nichts da ich das ganze ja im NS bereich brauche.

[Frank M. (ukw) (Moderator)]

Tobias N. schrieb:
> Ja sieht schon ein wenig komisch aus :) Kann man ja noch ändern *g*

Solltest Du auch, wenn Du es nochmal brauchst. Aber Du brauchst die 
Dinger gar nicht, s.u.

> Jetzt muss ich noch noch das Timing der Schleifen anpassen, richtig?

Schmeiss die Schleifen raus und ersetze sie durch delay_us (), also:

...
#include <util/delay.h>        // einfügen! Hier muss F_CPU bekannt sein!
...
void wswrite_zero(void)
{
  // 500ns +- 150ns high
  WSPORT |= (1<<WSPIN); // 125ns
  _delay_us (500);

  // 2000ns +- 150ns low
  WSPORT &= ~(1<<WSPIN); // 125ns
  _delay_us (2000);
}

void wswrite_one(void)
{
  // 1200ns +- 150ns high
  WSPORT |= (1<<WSPIN); // 125ns
  _delay_us (1200);

  // 1300ns +- 150ns low
  WSPORT &= ~(1<<WSPIN); // 125ns
  _delay_us (1300);
}

Dann kannst Du Dir den ganzen Takte-Heckmeck mit den Schleifen sparen.

[wurg (Gast)]

och nö. so funktioniert c nicht. eine hochsprache ist einfach nicht 
dafür gedacht, taktzyklengenaues timing zu erzeugen.

versuche doch einen der hundert anderen ansätze hier auf dem board zu 
verstehen. da ist deine zeit besser investiert. --> wS2812

[Frank M. (ukw) (Moderator)]

Tobias N. schrieb:
> _delay_us() bringt mir nichts da ich das ganze ja im NS bereich brauche.

Du hast recht, mein Fehler. Sorry. Ich bin erstaunt, dass das mit den 
Schleifen überhaupt klappt.

[wurg (Gast)]

meine güte, ich sehe gerade dass das bereits dein dritter thread mit 
diesem fehlgeleiteten ansatz ist...

[Tobias N. (silberkristall)]

die nop(); sind ja asm. ein nop = 1 takt, 1 takt = 125ns :)

[Frank M. (ukw) (Moderator)]

Tobias N. schrieb:
> die nop(); sind ja asm. ein nop = 1 takt, 1 takt = 125ns :)

und Dein for(...) verbraucht nichts an CPU-Takten? Wenn Dein µC 10 NOPs 
machen soll, dann macht er auch noch mindestens 10 Vergleiche (Variable 
i mit einem Wert). Und das kostet bei jedem(!) Vergleich ein Vielfaches 
eines NOPs.

Deshalb schrieb ich: Wundert mich, dass es überhaupt mit Deinen 
Schleifen funktioniert.

[Tobias N. (silberkristall)]

ich hatte ja schonmal was fertiges o.O

Beitrag "Re: WS2812 Timing"

[Icke ®. (49636b65)]

wurg schrieb:
> versuche doch einen der hundert anderen ansätze hier auf dem board zu
> verstehen. da ist deine zeit besser investiert. --> wS2812

Richtig. Man kann einfach die geniale, kaum noch zu verbessernde 
WS2812-LightweightLib von Tim benutzen oder das Rad eckig machen.

Beitrag "Lightweight WS2811/WS2812 Library"