Assembler: Benötige Hilfe

[Flo (Gast)]

Hallo,

ich habe folgende Funktion (geklaut von 
https://github.com/strawberryhacker/led-strip-driver - unnötige 
"#if"-Teile entfernt, damit das hier nicht zu lang wird.

void __attribute__((noinline)) update_led_strip(color* colors, uint16_t number_of_leds)
{  
  LED_PORT.DIRSET = (1 << LED_PIN);
  uint8_t* led_strip_port_pointer;
  led_strip_port_pointer = (uint8_t*)(&LED_PORT);
  
  uint8_t pin = (1 << LED_PIN);

  cli();
  while(number_of_leds--)
  {
    asm volatile(
    
    //send red component
    "ld    __tmp_reg__,  %a0+    \n\t"
    "ld    __tmp_reg__,  %a0      \n\t"
    "rcall  send_byte%=          \n\t"
    
    //send green component
    "ld    __tmp_reg__,  -%a0    \n\t"
    "rcall  send_byte%=          \n\t"
    
    //send blue component
    "ld    __tmp_reg__,  %a0+    \n\t"
    "ld    __tmp_reg__,  %a0+    \n\t"
    "ld    __tmp_reg__,  %a0+    \n\t"
    "rcall  send_byte%=          \n\t"
    "rjmp  asm_end%=          \n\t"

    //send byte subroutine
    "send_byte%=:            \n\t"
    "rcall  send_bit%=          \n\t"
    "rcall  send_bit%=          \n\t"
    "rcall  send_bit%=          \n\t"
    "rcall  send_bit%=          \n\t"
    "rcall  send_bit%=          \n\t"
    "rcall  send_bit%=          \n\t"
    "rcall  send_bit%=          \n\t"
    "rcall  send_bit%=          \n\t"
    "ret                \n\t"

    //send bit subroutine
    "send_bit%=:            \n\t"
    
    "rol  __tmp_reg__          \n\t"
    //set outout high
    "std  Y+5,  %[led_strip_pin]  \n\t"
    "brcs  .+2              \n\t"
    //set outout low
    "std  Y+6,  %[led_strip_pin]  \n\t"
    "nop                \n\t"
    "nop                \n\t"
    "brcc  .+2              \n\t"
    //set outout low
    "std  Y+6,  %[led_strip_pin]  \n\t"
    
    "ret                \n"
    "asm_end%=:"
    
    //constraints
    : "=b" (colors)                                //output operands
    : "0" (colors), [led_strip_pin] "r" (pin), "y" (led_strip_port_pointer));  //input operands
  }
  
  //enable interrupt
  sei();
  
  //send reset pulse
  _delay_us(80);
}

Da ich nur eine einzige LED ansteuern möchte, hätte ich die Funktion 
gerne geändert. Ungefähr so: "update_led(uint8_t red, uint8_t green, 
uint8_t blue)"

Ich habs jetzt schon ne Weile versucht, aber ich bekomme es einfach 
nicht hin. Kenne mich mit Assembler leider überhaupt nicht aus.
Klar könnte ich die Funktion auch mit number_of_leds=1 aufrufen. Aber 
ich würd ja gern wissen WIE das funktioniert :)

Ich hoffe mir kann jemand helfen. 😊

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Also entweder übergibst du als 'number of leds' einfach immer eine 1 und 
änderst sonst gar nix oder du entfernst die while schleife und rennst 
nur einmal durch die Funktion.

Flo schrieb:
> Aber
> ich würd ja gern wissen WIE das funktioniert :)

Ist einfach nur die while Schleife. Der Rest ist bit schieben in ASM. 
Aber das ist für dich eigentlich uninteressant.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Flo schrieb:
> Ich habs jetzt schon ne Weile versucht, aber ich bekomme es einfach
> nicht hin.
Wo klemmt es denn? Für welchen Rechner soll das sein? Was soll der Code 
tun und was tut er stattdessen? Wie stellst du das fest?

[Flo (Gast)]

Matthias S. schrieb:
> Also entweder übergibst du als 'number of leds' einfach immer eine 1 und
> änderst sonst gar nix oder du entfernst die while schleife und rennst
> nur einmal durch die Funktion.

Ich würde aber auch gerne das "struct color"-Zeug loswerden.
Und außerdem - wie gesagt: Verstehen wie so was funktioniert ;)

Lothar M. schrieb:
> Wo klemmt es denn? Für welchen Rechner soll das sein? Was soll der Code
> tun und was tut er stattdessen? Wie stellst du das fest?

Der Code ist für einen ATXmega und soll WS2812B-LEDs ansteuern. Das tut 
er auch ;)
Aber ich würde halt gerne die RGB-Werte direkt als uint8 (oder was auch 
immer) direkt an den Assembler-Teil übergeben. Ohne den Umweg über die 
color-struct 😅

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Flo schrieb:
> Ohne den Umweg über die
> color-struct 😅

Wie du im ASM Teil siehst, ist das gar kein Umweg. Es reicht ein 
einfaches hoch- und runterzählen von a0, um aufs struct zuzugreifen.

[Zeno (Gast)]

Matthias S. schrieb:
> Flo schrieb:
>> Ohne den Umweg über die
>> color-struct 😅
>
> Wie du im ASM Teil siehst, ist das gar kein Umweg. Es reicht ein
> einfaches hoch- und runterzählen von a0, um aufs struct zuzugreifen.
Er hat sich halt Code aus dem Netz geholt und versteht ihn nicht. Da 
gibt es jetzt eigentlich nur 3 Wege die zum Ziel führen:
1. Er denkt sich selbst was aus
2. Er setzt sich auf Hosenboden, nimmt sich ein schlaues Buch und 
arbeitet den Quellcode Schritt für Schritt durch. Ja das ist sehr 
mühsam, aber es bildet durchaus.
3. Er bemüht die Suchmaschine seines Vertrauens, um anderen Code für 
sein Problem bzw. der sein Problem besser abbildet zu finden. Ich denke 
da wird man durchaus fündig.

Den Code den ein anderer gemacht hat zu verstehen, ist nicht immer ganz 
einfach, da muß man ab und an schon viele bittere Pillen schlucken. 
Gerade für einen Anfänger, wie der TO einer zu sein scheint, ist das oft 
schwierig, weil der Profi die Probleme anders löst als ein Anfänger tun 
würde.

[Flo (Gast)]

OK.... Ich habe jetzt nochmal ein bisschen rumgespielt - jetzt 
kompiliert er wenigstens mal ohne Fehler 😅
Kann aber leider gerade nicht ausprobieren, ob's auch läuft.

Sieht jetzt so aus:

  asm volatile(
    "mov  __tmp_reg__,  %[RED]    \n\t"
    "rcall  send_byte%=          \n\t"
    "mov  __tmp_reg__,  %[GREEN]  \n\t"
    "rcall  send_byte%=          \n\t"
    "mov  __tmp_reg__,  %[BLUE]    \n\t"
    "rcall  send_byte%=          \n\t"
    "rjmp  asm_end%=          \n\t"
  
.....(bla bla bla).....

    :: [RED] "r" (r), [GREEN] "r" (g), [BLUE] "r" (b), [led_strip_pin] "r" (pin), "y" (led_strip_port_pointer)
    
  );

Passt das so? 🤔