Corrimiento de bits y SWAPF en XC8

[albertoie1]

Buenas taardes

Mi consulta es la siguiente cuando efectuo corrimiento en una variable y llego al bit mas significativo en el siguiente corimiento el bit se pierde, alguien me podria explicar porque sucede esto, la viariable es de 8 bits sin signo.

La otra consulta es como puedo reemplazar la instruccion SWAPF para intercambio de nibles en XC8

Gracias por la ayuda

[KILLERJC]

Mi consulta es la siguiente cuando efectuo corrimiento en una variable y llego al bit mas significativo en el siguiente corimiento el bit se pierde, alguien me podria explicar porque sucede esto, la viariable es de 8 bits sin signo.

Esto por que el se escala primero a un resultado que pueda albergarlo todo y luego se recorta. Una explicacion simple seria:

uint8_t i,j;

i =1;
j = i << 8;

Eso seria igual a 512, la operacion de desplazar 8 veces a la izquierda supera los 8 bits entonces "promueve" a i a 16bits, pensale como que temporalmente  se crea en memoria una variable de 16 bits que vamos a llamar temp y que va a alojar el resultado intermedio antes de pasarlo a i, entonces el valor de temp (o mejor dicho el valor de la operación hasta el momento) es:

temp es 0000 0001 0000 0000

Ahora ese resultado lo debe poner en uno de 8bits, por lo tanto se recorta y queda en 0000 0000 por eso mismo ves que los bits se pierden, y no hay equivalencia con el RRF y RLF de ASM.

Podes realizar un RLF o RRF sin carry haciendo lo mismo que voy a hacer con el SWAPF pero esta ves el corrimiento no es 4 en ambos, pero la suma es 8 por igual. No se que codigo generara el compilador en esta cirscuntancia.

La otra consulta es como puedo reemplazar la instruccion SWAPF para intercambio de nibles en XC8

La unica que vi es:

x = (x << 4) | (x >> 4);

Es decir uno pasa el nibble inferior al superior, los bits que restan se pierden y luego el otro pasa el nibble superior al inferior, dejando los bits de arriba en 0. Esto el compilador luego lo traduciria a un SWAPF (o deberia).

[albertoie1]

Buenas tardes

Gracias por la respuesta pero me queda una duda en lo del corriemiento de que forma debo implementarlo cuando llego al bit mas significativo?

Tengo otra consulta como puedo cambiar el estado de un solo bit en una variable.

Gracias por la ayuda

[KILLERJC]

2 formas:

Usando tablas:

Código: C

1. const valores[8] =      {
2.                                 0b00000001,
3.                                 0b00000010,
4.                                 0b00000100,
5.                                 0b00001000,
6.                                 0b00010000,
7.                                 0b00100000,
8.                                 0b01000000,
9.                                 0b10000000
10.                         };
11.  
12. for(i=0;i<7;i++)
13. {
14.         PORTB = valores[i];
15.         //delay aca
16. }

Sin tablas y usando el puerto

Código: C

1. for(PORTB = 1; PORTB != 0; PORTB <<= 1)
2. {
3.         //delay aca
4. }

Para cambiar el estado de un solo bit simplemente haces :

PORTBbits.RB5 = 1;
PORTAbits.RA1 = 0;

Es decir todos los registros suponete el TRISA si queres cambiar bit a bit, usas la estructura TRISbits, cuando pones el punto automaticamente te aparecen los valores que pueden ir como TRISA1 y luego asignas el valor.

El nombre de los bits y el nombre de los registros coinciden con los del datasheet. Te podes ayudar presionado Ctrl + barra espaciadora, que es para autocompletar.

[albertoie1]

Bunos dias

gracias por la ayuda y las aclaraciones, una inquietud mas para los registros del pic entendi como se cambian los bits pero intente hacer lo mismo con una variable que yo cree y me da error de sintaxis, porque se presenta esto

Gracias por la ayuda

[colotron]

Bunos dias

gracias por la ayuda y las aclaraciones, una inquietud mas para los registros del pic entendi como se cambian los bits pero intente hacer lo mismo con una variable que yo cree y me da error de sintaxis, porque se presenta esto

Gracias por la ayuda

Los puertos PORTB/TRISB etc, están definidos como structs si mal no recuerdo.

Podrías usar máscaras de bits y no hace falta definir structs. Ejemplo:

Código: [Seleccionar]

#define BIT0 (1U)
#define BIT1 (2U)
#define BIT2 (4U)
//o si te gusta más seguimos definiendo como
#define BIT3 (0b00001000)
#define BIT4 (0b00010000)
#define BIT5 (0b00100000)
//o si te gusta hacer como los que usan ARM:
#define BIT6 (1U<<6)
#define BIT7 (1U<<7)

unsigned int algo;

//Limpiar o poner a 0 el bit 3 de la variable algo (sin cambiar el resto de los bits):
algo &= ~BIT3;

//Setear o poner a 1 el bit 5 de la variable algo:
algo |= BIT5;

//Cambiar/negar/toggle el bit 1 de la variable algo:
algo ^= BIT1;

//Setear/limpiar/togglear varios bits a la vez:
algo |= (BIT0 | BIT2 | BIT4); //pongo a 1 bits 0,2,4
algo &= ~(BIT1 | BIT3); //pongo a 0 bits 1 y 3
algo ^= (BIT5 | BIT6); //niego bits 5 y 6