problema con una secuencia de leds

[johenrod]

cordial saludo, tan amables podrían ayudarme.
estoy realizando una secuencia de leds, la idea es que vaya recorriendo uno a uno del bit0 hasta el 7, cuando llegue al 7 este se quede encendido y comience de nuevo desde el bit 0 ahora hasta el bit 6 ahora deben que dar encendidos 6 y 7 y comenzar de nuevo desde el 0 hasta llenar por completo.
lo he logrado hacer con un arreglo y un for pero quisiera que a medida que avanzan los bits estos prendan y apaguen 2 veces a medida que van llenando pero los que ya llenaron permanezcan fijos.
alguna idea ? de antemano gracias.

Código: C

1. byte const s14d7[]={0b00000001,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b10000000,
2.                       0b10000001,0b10000010,0b10000100,0b10001000,0b10010000,0b10100000,0b11000000,
3.                       0b11000001,0b11000010,0b11000100,0b11001000,0b11010000,0b11100000,
4.                       0b11100001,0b11100010,0b11100100,0b11101000,0b11110000,                                                                          
5.                       0b11110001,0b11110010,0b11110100,0b11111000,      
6.                       0b11111001,0b11111010,0b11111100  
7.                       0b11111101,0b11111110,0b11111111 };

[Eduardo2]

Probá con un triple for:

Código: [Seleccionar]

    #define Tblink 100
                 
    portb = 0 ;             
    for(signed int8 i=7;i>=0;i--){
        for(int8 j=0;j<=i;j++){
            for(int8 k=0 ; k<2 ; k++){
                bit_set(portb,j)   ; delay_ms(Tblink) ;
                bit_clear(portb,j) ; delay_ms(Tblink) ;
            }
        }
        bit_set(portb,i) ;
    }


[johenrod]

Probá con un triple for:

Código: [Seleccionar]

    #define Tblink 100
                 
    portb = 0 ;             
    for(signed int8 i=7;i>=0;i--){
        for(int8 j=0;j<=i;j++){
            for(int8 k=0 ; k<2 ; k++){
                bit_set(portb,j)   ; delay_ms(Tblink) ;
                bit_clear(portb,j) ; delay_ms(Tblink) ;
            }
        }
        bit_set(portb,i) ;
    }


Eduardo2 recibe un cordial saludo, espectacular la forma en que lo haces, yo lo había logrado pero con unas decenas de lineas de código 
es increíble, personas como tu la forma en la que enfrentan estas incógnitas a la hora de programar y ademas, lo comparten con los novatos como yo.
este tipo de info no se encuentra sino en los foros, en ningún lugar se puede aprender lógica de programación, que es lo que se necesita para hacer este tipo de cosas. ademas de la función que necesitaba me encontré con que, si no apago el puerto a la hora de entrar de nuevo a los for, hace un recorrido adicional apagando los leds ya encendidos y se ve super.
mil gracias por tu tiempo y enseñanza seguire investigando para lograr mas secuencias tratando de hacerlo con tu método.
Eduardo2     .

[Eduardo2]

Después de subir ese código me di cuenta de algunas variaciones interesantes (al menos para mi ) , como ya lo tenía escrito, lo comparto.

Las intrucciónes bit_set(x,bit) y bit_clear(x,bit) son eficientes cuando bit es una constante, cuando es una variable genera un bucle donde va desplazando un '1' bit veces.
Desde un enfoque friki, si esquivamos esto --> mejor.

Esto es casi lo mismo que el código anterior,  pero es mas rápido y ocupa casi la mitad de memoria.

Código: [Seleccionar]

   #define Tblink 100
       
    portb = 0 ;             
    for(int8 i=0x80 ; i!=0 ; i>>=1){
        for(int8 j=1 ; j!=i&&j!=0 ; j<<=1){
            for(int8 k=0 ; k<2 ; k++){
                portb |=  j ; delay_ms(Tblink) ;
                portb &= ~j ; delay_ms(Tblink) ;
            }
        }
        portb|=i ;
    }


Otro caso es si la secuencia de los leds fuese mas arbitraria.  En ese caso sería necesario sí o sí  tablas, como lo pensaste al principio, solo que mas de una para diferenciar los leds encendidos siempre de los que parpadean.
Algo asi:

Código: [Seleccionar]

const int8 led_on[]={
    0b00000001,0b00000010,0b00000100,0b00001000,0b00010000,0b00100000,0b01000000,0b10000000,
    0b10000001,0b10000010,0b10000100,0b10001000,0b10010000,0b10100000,0b11000000,0b11000001,
    0b11000010,0b11000100,0b11001000,0b11010000,0b11100000,0b11100001,0b11100010,0b11100100,
    0b11101000,0b11110000,0b11110001,0b11110010,0b11110100,0b11111000,0b11111001,0b11111010,
    0b11111100,0b11111101,0b11111110,0b11111111 };

const int8 led_off[]={
    0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,0b00000000,
    0b10000000,0b10000000,0b10000000,0b10000000,0b10000000,0b10000000,0b10000000,0b11000000,
    0b11000000,0b11000000,0b11000000,0b11000000,0b11000000,0b11100000,0b11100000,0b11100000,
    0b11100000,0b11100000,0b11110000,0b11110000,0b11110000,0b11110000,0b11111000,0b11111000,
    0b11111000,0b11111100,0b11111100,0b11111110 };


Código: [Seleccionar]

    #define Tblink 100
    for(int8 n=0 ; n<36 ; n++){
        for(int8 i=0 ; i<2 ; i++){         
            portb = led_on[n]  ; delay_ms(Tblink) ;
            portb = led_off[n] ; delay_ms(Tblink) ;
        }
    }
    portb=led_on[35] ;

Saludos.

[johenrod]

Después de subir ese código me di cuenta de algunas variaciones interesantes (al menos para mi ) , como ya lo tenía escrito, lo comparto.

Las intrucciónes bit_set(x,bit) y bit_clear(x,bit) son eficientes cuando bit es una constante, cuando es una variable genera un bucle donde va desplazando un '1' bit veces.


Saludos.

muchas gracias, con tus metodos logre reemplazar todos los arreglos que habia hecho y optimize el codigo un 80%.
no se si podrias ayudarme por favor, con la ultima funcion que me falta.

se debe prender uno por uno (bit0 al bit 7) cuando llegue al bit 3 se prenda tambien el bit0, cuando este llegue tambien al bit3 se prenda de nuevo el bit 0.
es como si empezara 3 veces pero cada uno debe ir hasta el bit7.(como un recorrido que se inicia 3 veces y deja 2 espacios entre ellos..) cuando el que empezo de tercero llegue a 7 inicia de nuevo.
Lo realice con arreglo pero quisiera saber como se haria con for o algo asi como lo que me esnseñaste.

Código: C

1. byte const s1d7[]={0b00000001,0b00000010,0b00000100,0b00001001,0b00010010,0b00100100,0b01001001,0b10010010
2.                           0b00100100,0b01001000,0b10010000,0b00100000,0b01000000,0b10000000,0b00000000};//0-14
3.  
4.  
5.   //******** sec8 *********************
6.     void secuencia8()
7.     {
8.              for (i=0;i<=14;i++)
9.         {
10.         porta=s1d7[i];
11.         ret1();
12.         }
13.     }
14.  
15.  
16. secuencia8();

[Eduardo2]

Esto se podría hacer asi:

Código: [Seleccionar]

void secuencia8()
{
    int8 cuenta ;
       
    for(portb=1 , cuenta=0 ; portb ; portb <<= 1){
        if(portb & 0b1000){
            if(cuenta < 2){
                cuenta++ ;
                portb |= 1 ;
            }
        }
        delay_ms(500);
    }       
}

[johenrod]

Esto se podría hacer asi:

Código: [Seleccionar]

void secuencia8()
{
    int8 cuenta ;
       
    for(portb=1 , cuenta=0 ; portb ; portb <<= 1){
        if(portb & 0b1000){
            if(cuenta < 2){
                cuenta++ ;
                portb |= 1 ;
            }
        }
        delay_ms(500);
    }       
}

huyyyyy hermano que "nota" trabajo de una. Que facilidad tienes, muchas gracias.
solo una duda como se lee cuando entra al for ?
busque por todas partes de estructuras del bucle for y solo encotre la de siempre for (i=0;i>7;i++) como busco para aprender mas de esto.

Código: C

1. void secuencia8()
2. {
3.     int8 cuenta ;
4.        
5.     for(porta=1 , cuenta=0 ; porta ; porta <<= 1) // ?????
6.     {
7.         if(porta & 0b1000) // "AND" cuando el bit3 sea 1
8.         {
9.             if(cuenta < 2) // 0 y 1 // osea que pasa 2 veces
10.             {
11.                 cuenta++ ; // incremento
12.                 porta |= 1 ; // "OR" en el bit 0 // osea que coloca un 1 en el bit0
13.             }
14.         }
15.         delay_ms(500);
16.     }      
17. }

[johenrod]

aqui lo modifique para que lo hiciera a la inversa.

Código: C

1. for(porta=128 , cuenta=0 ; porta ; porta >>= 1)
2.     {
3.         if(porta & 0b00010000)
4.         {
5.             if(cuenta < 2)
6.             {
7.                 cuenta++ ;
8.                 porta |= 128 ;
9.             }
10.         }
11.         delay_ms(500);
12.     }

[Eduardo2]

El for( : : ) trabaja asi:

for( se_ejecuta_al comienzo ; condición ; se_ejecuta_en_cada_iteración )

se_ejecuta_al comienzo : Pues eso, por lo general se inicializa una o varias variables, pero también se puede llamar rutinas.

condición : Mientras sea verdadera se repite el bucle.  Yo escribí "portb" , mientras "portb" sea distinto de 0 se repite.

se_ejecuta_en_cada_iteración :  Generalmente es un incremento, pero podés poner cualquier operación (puse un desplazamiento). Hasta llamar rutinas.

Por ejemplo, se puede poner una  rutina que haga parpadear un pin al comienzo , y el delay_ms(500) dentro del for

Código: [Seleccionar]

    for(portb=1 , cuenta=0 , blink() ; portb ; delay_ms(500) , portb <<= 1 ){
        if(portb & 0b1000){
            if(cuenta < 2){
                cuenta++ ;
                portb |= 1 ;
            }
        }         
    }       

El problema es que si abusamos se pierde claridad 

[johenrod]

El for( : : ) trabaja asi:

for( se_ejecuta_al comienzo ; condición ; se_ejecuta_en_cada_iteración )

cordial saludo,y gracias de nuevo por tu aclaracion, solo me queda una duda..
for(portb=1 , cuenta=0 ; portb ; portb <<= 1){
en esta parte que resalto en negrita que significa "portb" solamente, a que hace referencia ya que no esta iniciada.. y finalmente en el codigo que me compartes haces la cuenta sobre 8 bits si solo fuera a utilizar 5 que deberia modificar ya que trate de hacerlo y me saca efectos diferentes.