ATNEL tech-forum 2019-07-28T08:51:25+01:00 https://forum.atnel.pl/feed.php?f=4&t=22446&mode 2019-07-28T08:51:25+01:00 2019-07-28T08:51:25+01:00 https://forum.atnel.pl/viewtopic.php?t=22446&p=220761#p220761 <![CDATA[Re: ws2812 nie działa gradient]]> Coś w tym jest co piszesz, dzisiaj podstawiłem tak jak podpowiedziałeś i cześć kolorów faktycznie działa ale niektóre się kompletnie rozsypuje na pasku albo wychodzą inne kolory, a jeszcze dziwniejsza rzecz się stała kiedy ustawiłem jakiś kolor ( przy podmiance o której napiłeś) i ten kolor się rozsypał, wtedy pomyślałem zobaczę co się stanie jak zamienię Twoje uinty na inty dokładnie tak jak miałem wcześniej, jak jest w poradniku i okazuje się że działa, nie tylko ten ustawiony kolor ale wszystko działa :shock: Dla mnie zrozumieć co się stało jest niemożliwe, coś się odblokowało, nie wiem może kompilator może coś procku, nie mam bladego pojęcia..
Dzięki bynajmniej dzięki Tobie udało się problem rozwiązać :)

Statystyki: Napisane przez Dawid2379 — 28 lip 2019, o 08:51

]]> 2019-07-27T21:47:18+01:00 2019-07-27T21:47:18+01:00 https://forum.atnel.pl/viewtopic.php?t=22446&p=220758#p220758 <![CDATA[Re: ws2812 nie działa gradient]]> Dawid2379 napisał(a):

masz całkiem inne nazwy, nazwę struktury wiec bez reszty kodu nie będę umiał sobie tego podstawić czy pozamieniać.

W teście, który wykazał różnice wszystko jest napisane "po Twojemu", zatem wystarczy, że u siebie zamienisz int32_t na uint32_t i możesz potestować.
Moja teza zakłada, że zakres zmiennych int32_t jest za mały, dla niektórych kolorów może być OK, a dla innych nie, ale to tylko teza. Sprawdź, to nic skomplikowanego, zwykła podmianka. Chodzi o ten fragment:
[syntax=c]// interpolujemy wartosci na kanalach
AC.cl[cr] = ((((int32_t)AB.cl[cr] - AA.cl[cr])*(int32_t)pos)/(int32_t)max + AA.cl[cr]);
AC.cl[cg] = ((((int32_t)AB.cl[cg] - AA.cl[cg])*(int32_t)pos)/(int32_t)max + AA.cl[cg]);
AC.cl[cb] = ((((int32_t)AB.cl[cb] - AA.cl[cb])*(int32_t)pos)/(int32_t)max + AA.cl[cb]);[/syntax]

Zreszta popatrz na to trzeźwo, funkcja przyjmuje parametry typu uint32_t i taką też zwraca wartość.
Jaki zatem jest powód, że wewnątrz trzeba operować na zmiennych ze znakiem?

Jakimś specjalnym ekspertem w C nie jestem, ale trochę to kłuje w oczy :) i od powyższego bym zaczął.

Statystyki: Napisane przez Zealota — 27 lip 2019, o 21:47

]]> 2019-07-27T18:53:09+01:00 2019-07-27T18:53:09+01:00 https://forum.atnel.pl/viewtopic.php?t=22446&p=220753#p220753 <![CDATA[Re: ws2812 nie działa gradient]]> Statystyki: Napisane przez Dawid2379 — 27 lip 2019, o 18:53

]]> 2019-07-26T23:13:57+01:00 2019-07-26T23:13:57+01:00 https://forum.atnel.pl/viewtopic.php?t=22446&p=220720#p220720 <![CDATA[Re: ws2812 nie działa gradient]]> U siebie mam oczywiście ten sam wzór z poradnika ale rzutuję inaczej i mam poprawne kolory (tak mi się wydaje :) ):
[syntax=c]uint32_t color_interpolate( uint32_t minColor, uint32_t maxColor, uint8_t pos, uint8_t posMax ) {
T_RGB ColorMin, ColorMax;
ColorMin.color24bit = minColor;
ColorMax.color24bit = maxColor;

ColorMin.R = (uint8_t)ColorMin.R + ( (uint32_t)ColorMax.R - (uint32_t)ColorMin.R )*pos / posMax;
ColorMin.G = (uint8_t)ColorMin.G + ( (uint32_t)ColorMax.G - (uint32_t)ColorMin.G )*pos / posMax;
ColorMin.B = (uint8_t)ColorMin.B + ( (uint32_t)ColorMax.B - (uint32_t)ColorMin.B )*pos / posMax;

return ColorMin.color24bit;
}[/syntax]

Ty rzutujesz na int32 to wartość działań spokojnie może przekroczyć wartość typu, w końcu kolor to 24 bit, a może dojść do mnożeń przez duży zakres np 0xFF, czy jeszcze więcej.
Spróbuj rzutowania, które podałem a zobaczymy czy to pomoże.

Zrobiłem również dodatkowy test:
[syntax=c]typedef struct{
uint8_t g;
uint8_t r;
uint8_t b;
} TWSRGB;
typedef union {
uint32_t color;
uint8_t cl[4];
}TCLU;

enum {cb,cg,cr};
volatile uint32_t color1 = 0x00FF0000;
volatile uint32_t color2 = 0x00FFFF00;
volatile uint32_t wynik = 0;

uint32_t Interpolate2Colors(uint32_t A, uint32_t B, uint16_t pos, uint16_t max){

TCLU AA, AB, AC;
AA.color = A;
AB.color = B;

// interpolujemy wartosci na kanalach
AC.cl[cr] = AA.cl[cr] + ( ( (int32_t)AB.cl[cr] - AA.cl[cr] )*(int32_t)pos)/(int32_t)max;
AC.cl[cg] = AA.cl[cg] + ( ( (int32_t)AB.cl[cg] - AA.cl[cg] )*(int32_t)pos)/(int32_t)max;
AC.cl[cb] = AA.cl[cb] + ( ( (int32_t)AB.cl[cb] - AA.cl[cb] )*(int32_t)pos)/(int32_t)max;

return AC.color;
}
uint32_t Interpolate3Colors(uint32_t A, uint32_t B, uint16_t pos, uint16_t max){

TCLU AA, AB, AC;
AA.color = A;
AB.color = B;

// interpolujemy wartosci na kanalach
AC.cl[cr] = AA.cl[cr] + ( ( (uint32_t)AB.cl[cr] - AA.cl[cr] )*(uint32_t)pos)/(uint32_t)max;
AC.cl[cg] = AA.cl[cg] + ( ( (uint32_t)AB.cl[cg] - AA.cl[cg] )*(uint32_t)pos)/(uint32_t)max;
AC.cl[cb] = AA.cl[cb] + ( ( (uint32_t)AB.cl[cb] - AA.cl[cb] )*(uint32_t)pos)/(uint32_t)max;

return AC.color;
}
wynik = Interpolate2Colors( color2, color1, 127, 255 );
wynik = Interpolate3Colors( color2, color1, 127, 255 );[/syntax]
Wyniki różnią się, najpierw jest 0xff8100, a z drugiej funkcji 0xff8000, zatem stawiam, że jest coś na rzeczy :)

Statystyki: Napisane przez Zealota — 26 lip 2019, o 23:13

]]> 2019-07-26T21:37:10+01:00 2019-07-26T21:37:10+01:00 https://forum.atnel.pl/viewtopic.php?t=22446&p=220719#p220719 <![CDATA[ws2812 nie działa gradient]]> Zmieniałem już procesor , fakt tez Atmega8 ale nic się nie zienia, wiec odpada ze coś nie tak z prockiem,
zmieniałem tez piny i dalej ten sam problem świecą jak chcą te diody, nie wiem co jeszcze mogłabym zrobić

Obrazek
main.c

[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <stdlib.h>

#include "ws281x.h"


TWSRGB ws_rgb_leds [WS_LED_CNT]; //tworzenie tablicy
uint8_t * pasek = (uint8_t*)ws_rgb_leds;

int main(void){


ws_cls ( ws_rgb_leds,0 ) ;
_delay_ms(2000);
gradient2c(pasek, 10, 25, 0xaf0000, 0x0000af);
ws281x_asm_send(pasek, WS_LED_CNT, WS_PIN);


while(1){


}

}[/syntax]

ws281x.c
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <string.h>

#include "ws281x.h"

const uint8_t gamma_correctionR[] PROGMEM = {
0, 1, 1, 1, 2, 3, 5, 7, 10, 13, 17, 21, 26, 32, 38, 45, 52, 60,
69, 78, 88, 99,111,124,137,151,166,182,199,217,235,255
};

const uint8_t gamma_correctionG[] PROGMEM = {
0, 1, 1, 1, 2, 3, 5, 7, 10, 13, 17, 21, 26, 32, 38, 45, 52, 60,
69, 78, 88, 99,111,124,137,151,166,182,199,217,235,255
};

const uint8_t gamma_correctionB[] PROGMEM = {
0, 1, 1, 1, 2, 3, 5, 7, 10, 13, 17, 21, 26, 32, 38, 45, 52, 60,
69, 78, 88, 99,111,124,137,151,166,182,199,217,235,255
};

#define GAMMAR(a) (pgm_read_byte(&gamma_correctionR[a])) // macro for RED
#define GAMMAG(a) (pgm_read_byte(&gamma_correctionG[a])) // macro for GREEN
#define GAMMAB(a) (pgm_read_byte(&gamma_correctionB[a])) // macro for BLUE



void ws_cls( void * line, uint32_t color ){

if( !color ) memset(line, 0, WS_LED_CNT*3);
else {
uint16_t x,i;
for( i=0; i<WS_LED_CNT;i++){

x=i*3;
*((uint8_t*)line + x) = color >> 8; //zielony
*((uint8_t*)line + x+1) = color >> 16; //czerwony
*((uint8_t*)line + x+2) = color; //niebieski

}
}
ws281x_asm_send( (uint8_t*)line, WS_LED_CNT, WS_PIN );

}

void ws_set_pixel ( void * line, int x, uint32_t color){

if( x<0 ) return;
if( x >= WS_LED_CNT) return;

*((uint8_t*)line + x*3) = color >> 8; //zielony
*((uint8_t*)line + x*3+1) = color >> 16; //czerwony
*((uint8_t*)line + x*3+2) = color; //niebieski
}


void ws_line ( void * line, int x, uint16_t len, uint32_t color){

int i;
for(i=x; i<(int)(x+len); i++){
ws_set_pixel( line,i, color );
}
}

static uint32_t Interpolate2Colors(uint32_t A, uint32_t B, uint16_t pos, uint16_t max){

TCLU AA, AB, AC;
AA.color = A;
AB.color = B;

// interpolujemy wartosci na kanalach
AC.cl[cr] = ((((int32_t)AB.cl[cr] - AA.cl[cr])*(int32_t)pos)/(int32_t)max + AA.cl[cr]);
AC.cl[cg] = ((((int32_t)AB.cl[cg] - AA.cl[cg])*(int32_t)pos)/(int32_t)max + AA.cl[cg]);
AC.cl[cb] = ((((int32_t)AB.cl[cb] - AA.cl[cb])*(int32_t)pos)/(int32_t)max + AA.cl[cb]);

return AC.color;
}

void gradient2c (void * line, int x, int len, uint32_t A, uint32_t B) {
int i;
int alen = (int)(x+len);

TCLU col;
TWSRGB * aline = line;

for ( i = x; i < alen; i++ ) {
if ( i<0 ) continue;
if ( i>=WS_LED_CNT+1 ) continue;

col.color = Interpolate2Colors(A, B, i-x, len);

aline[i].r = GAMMAR( col.cl[cr] );
aline[i].g = GAMMAG( col.cl[cg] );
aline[i].b = GAMMAB( col.cl[cb] );


}
}




void ws281x_asm_send( void *data, uint16_t datlen, uint8_t pin ) {

uint8_t databyte=0, cnt, pinLO=~pin;
WS_DIR |= pin;
datlen *= 3;

#if F_CPU == 16000000

asm volatile(
"lds%[cnt],%[ws_port]\n\t"
"or%[pinHI],%[cnt]\n\t"
"and%[pinLO],%[cnt]\n\t"
"mPTL%=:subi%A6,1\n\t"
"sbci%B6,0\n\t"
"brcsexit%=\n\t"
"ld%[databyte],X+\n\t"
"ldi%[cnt],8\n\t"

"oPTL%=:sts%[ws_port],%[pinHI]\n\t"
"rjmp .+0\n\t"

"lsl%[databyte]\n\t"
"brcs.+2\n\t"
"sts%[ws_port],%[pinLO]\n\t"
"rjmp .+0\n\t"
"rjmp .+0\n\t"

"dec%[cnt]\n\t"
"sts%[ws_port],%[pinLO]\n\t"
"breqmPTL%=\n\t"
"rjmp .+0\n\t"

"rjmpoPTL%=\n\t"
"exit%=:\n\t"
:[cnt]"=&d" (cnt)
:[databyte]"r" (databyte), [ws_port]"M" (_SFR_MEM_ADDR(WS_PORT)),
[pinHI]"r" (pin), [pinLO]"r" (pinLO), [data]"x" (data), [datlen]"r" (datlen)
);

#endif

}[/syntax]

ws281x.h

[syntax=c]#ifndef WS281X_H_
#define WS281X_H_

#define WS_PIN_NR PB5
#define WS_PIN ( 1<<WS_PIN_NR)
#define WS_PORT PORTB
#define WS_DIR DDRB

#define WS_LED_CNT 60

typedef struct{
uint8_t g;
uint8_t r;
uint8_t b;
} TWSRGB;

typedef union {
uint32_t color;
uint8_t cl[4];
}TCLU;


enum {cb,cg,cr};


void ws_cls( void *line, uint32_t color );
void ws_set_pixel ( void * line, int x, uint32_t color);
void ws_line ( void *line, int x, uint16_t len, uint32_t color);
void gradient2c (void * line, int x, int len, uint32_t A, uint32_t B);

void ws281x_asm_send( void *data, uint16_t datlen, uint8_t pin);

#endif /* WS281X_H_ */[/syntax]

Statystyki: Napisane przez Dawid2379 — 26 lip 2019, o 21:37

]]>