Libreria CCS para controlar LEDs WS2811/WS2812

[Marttyn]

En arduino (Atmel), los 16Mhz son 1 instruccion por cada ciclo de reloj, mientras que con Microchip, tienes una instruccion por cada 4 ciclos de reloj, con lo cual la velocidad "real" seria de 32Mhz / 4 = 8Mhz.

[KILLERJC]

EDIT:

Hola,  tengo una pergunta,  veo que en el pic usan una frecuencia de 32Mhz para controlar las tiras, pero en el arduino uno  usan 16Mhz, como es posible hacerlo con 16Mhzen  arduino uno?

Porque en el PIC se busca que todas las instrucciones ocupen solo 1 ciclo de maquina (excepto los saltos) el problema para esto es que 1 ciclo de maquina consta de 4 ciclos de reloj, por eso el Fcy es Fosc/4

Por su parte los micros de la ex-Atmel utiliza otra arquitectura, y los ciclos de instruccion varian con respecto a lo que se desee hacer. Siendo los mas consumidores aquellos que deben escribir un puerto o la RAM/ saltos , mientras que las operaciones dentro de los registros ( equivalente a como lo es W en el PIC ) se hacen con menos ciclos. Aun asi requieren menos ciclos.

Es una de las grandes peleas de lo que era Atmel-Microchip, otro es la forma del espacio de memorias, siendo el PIC16 en bancos y en Atmel continuo, y vectores de interrupcion. Hay cosas mas rapidas que se pueden realizar y otras mas lentas.
Ejemplo:
En un PIC para leer una posicion de la RAM y luego sumarle un numero precargado en W es solo una instruccion. 4 ciclos de reloj
En un ATtiny el proceso requiere 3 instrucciones, llevar el dato de la RAM a un registro interno, sumarle el numero precargado en otro registro y luego volverlo a la RAM.
Pero si solo debo operar mucho sobre los registros internos, el de la ex-Atmel lo supera ampliamente.

En arduino (Atmel), los 16Mhz son 1 instruccion por cada ciclo de reloj, mientras que con Microchip, tienes una instruccion por cada 4 ciclos de reloj, con lo cual la velocidad "real" seria de 32Mhz / 4 = 8Mhz.

Esta mal, hay instrucciones de 1,2,3, 4 y 5 ciclos de reloj.

[Marttyn]

La pregunta venia diciendo "por que en Arduino se puede hacer andar estos leds a solo 16Mhz, y en Microchip hacen falta 32Mhz?".
No quise entrar en detalle, por que a grandes rasgos mi respuesta responde a lo que se pregunta. Pero tienes razon en todo lo que dices.

[proteus7]

ok, gracias por sus respuestas  (Marttyn, KILLERJC)

[Byakuya]

Hola a todos, Esperando que todos se encuentren bien.. Una pregunta la librería aquí expuesta solo trabaja para ese microcontrolador o es universal para cualquier microcontrolador Microchip ? yo usaba solo código -> C <-, Sin herramientas de medición para pulsos y tiempos me decidí a utilizar un pic18f4550 a 48Mhz y con Bootloader y dije asi.... 48Mhz / 4 se requiere determinado tiempo para un uno y para un cero, el chip es tolerante a ciertos tiempo error, entonces mis funciones dicen... Se define el pin del micro a utilizar puede ser cualquiera. la velocidad del micro a 48Mhz según yo utilice pic18f4550....

Código: [Seleccionar]


//*****************************************
//  rutina que fija el color en el pixel
//*****************************************

void setpixelcolor(uint16_t pixel, uint32_t color) {
 uint8_t rede,greene,bluee;
 if(pixel <= neonum) {
   rede   = (uint32_t)(color >> 16);
   greene = (uint32_t)(color >> 8);
   bluee  = (uint32_t)color;
  }
  neored  [pixel] = rede;
  neogreen[pixel] = greene;
  neoblue [pixel] = bluee;
}


Después la rutina que se encargara determinar que bit colocar en la línea de transmisión.

Código: [Seleccionar]



//********************************
// rutina bit uno --- bit cero
//********************************

void neobit (int1 bit) {
 if(bit == 1) {
  output_high(neopin); delay_cycles(6); output_low(neopin); //delay_cycles(3); //bit '1'
 }else {
  output_high(neopin); delay_cycles(3); output_low(neopin);//delay_cycles(6); //bit 'o'
 }
}

 
Después solo dije... hay que enviar los datos según el data dice.. enviar primero el rojo y después el verde y al ultimo el azul entonces....

Código: [Seleccionar]


//*********************************
//    rutina envia datos
//*********************************

void ledshow (void) {
 signed int8 bitcount;
 uint16_t pixel;
 for(pixel = 0; pixel < neonum; pixel++) {
  for(bitcount = 7; bitcount >= 0; bitcount--) {      //envia rojo datha
      neobit(bit_test(neored[pixel], bitcount));  }
  for(bitcount = 7; bitcount >= 0; bitcount--) {     //envia verde datha
      neobit(bit_test(neogreen[pixel], bitcount));}
  for(bitcount = 7; bitcount >= 0; bitcount--) {    //envia azul  datha
      neobit(bit_test(neoblue[pixel], bitcount)); }
  }
 output_low(neopin);
}


Después de estas funciones y trabajando en conjunto.

Código: [Seleccionar]


//**********************
//    inicializa leds
//**********************

void pixelbegin(void) {
 for(i = 0; i < neonum; i++) {
 neored[i] = 0;
 neogreen[i] = 0;
 neoblue[i] = 0; 
 } //ceros
 ledshow();
}

void main (void)
for(;;) {
 setpixelcolor(0,rojo);
 ledshow();
 output_toggle(pin_d0);   // solo muestra funcionamiento de la tarjeta....
}

Todo se inicializo a ceros y fijo el color rojo en primer led funciono .... Pero su librería es mucho mas sofisticada, ahora la pregunta es
Funciona para cualquier microcontrolador? Saludos desde México Tlaxcala...

[Marttyn]

Hola Byakuya!
En efecto, tu codigo hace su funcion correctamente. Es una manera facil y directa de implementarlo.
El codigo que muestro yo (derivado de una libreria de Adafruit) es algo mas complejo ya que lleva los tiempos de manera muy exacta.
En tu caso supongo que los calculos que haces de tiempo estan correctos, pero entiendo que no estas teniendo en cuenta los ciclos que se pierden dentro de los bucles FOR de la funcion ledshow(), en los IF de la funcion neobit() y en el salto entre funciones que seguro descuadran los tiempos.

Como bien dices, el IC es tolerante a cierto error, y por eso tu programa funciona bien.
Es necesario ir con los tiempos tan medidos? Pues... depende de lo perfeccionista que seas y del grado de error que puedas permitir en la ejecucion de tu programa.
Quizas te topas con un IC que no es tan tolerante al error y en este el color no va bien... quien sabe.

Ahora, respondiendo a la pregunta "funciona para cualquier microcontrolador?". La respuesta es SI, con un "pero".... Funciona en cualquier microcotrolador que este corriendo a 32Mhz

Yo estaria encantado de incluir mas velocidades a la libreria, pero no tengo tiempo de hacer la programacion en ASM. Si alguien quiere aportar no es complicado. Yo me comprometo a añadirlo a la libreria para que pueda funcionar a las velocidades aportadas.

[jhordy]

amigos saludos, una consulta la funcion que se encarga de modificar el brillo en esta tira de led lo unico que hace es reducir o aumentar los valor del las variables RGB  y nada mas por ejemplo RGB: 100,40,50   si quisiéramos mas intensidad tedriamos que subir estos valores 150,90,100  , esto es ai ???????.  o los modifica en el PWM DEL CHIP WS2812B

[Marttyn]

Esta libreria solo escala el valor RGB. Si por ejemplo tienes (255,255,255) y lo pones al 50%, lo que hace es cambiar el valor RGB a (127,127,127). Esto conlleva una perdida en algunos casos. Al disminuir el brillo pierdes resolucion, y al volver a aumentarlo puedes encontrarte con un color diferente al inicial.

[championz]

hola! como estan? perdon por revivir este post, pero esoty probando la libreria, que va excelente, pero quiero ampliar la cantidad de leds de 85 a 192, para uzar 3 matrices de 8x8, es posible? esoty utilizando un pic16f1847

gracias!

[Marttyn]

Hola!
Haciendo las modificaciones necesarias podrias controlar los LEDs que quieras, siempre que dispongas de memoria suficiente.
En este caso no deberia ser complicado. Hay que cambiar la compilacion condicional para que permita mas (ahora esta limitado a 85), y deberias cambiar la variable in por un int16.
Es posible que necesites hacer algun cambio mas, pero las modificaciones son basicamente para que las variables no se desborden, el resto deberia funcionar exactamente igual.
Aqui esta la ultima version: https://github.com/ideaalab/led_pixels_library