Funciones basicas de word a bits y viceversa

International Español Software
1

Hola estoy intentando hacer algunas cosillas con el arduino nano y no encuentro la forma de pasar una variable int o word a Bits individuales y al revés
Como vengo del ámbito de los PLC quería hacer alguna cosilla similar a la que hace un PLC industrial tipo Siemens Omron Hitachi Modicon etc. con un arduino pero me encuentro que lo que es tan básico en un PLC que seria como leer o escribir un bit individual de una palabra no se como hacerlo.

Quería hacerme una biblioteca de funciones típicas de PLC como los bits de Clock de FirstScan Los temporizadores y contadores y ya tengo alguna cosilla, pero para el tema de los bits estoy atascado porque no me funciona ni una puñetera funcion OR de dos palabras
Se me había ocurrido hacer una funcion con algo así pero no traga

Void word_to_Bit (int Wordin , boolean BitSal[16]:wink:
// Wordin=0; palabra que queremos pasar a bits
// boolean BitSal[16]; array de salida para acceder a los bits individuales

/ / Se crean unas palabras mascara de 16 bits que contengan todos los bits a cero menos 1 el que queremos testear
int MaskBit00=1;
int MaskBit01=2;
int MaskBit02=4;
int MaskBit03=8;
int MaskBit04=16;
int MaskBit05=32;
int MaskBit06=64;
int MaskBit07=128;
int MaskBit08=256;
int MaskBit09=512;
int MaskBit10=1024;
int MaskBit11=2048;
int MaskBit12=4096;
int MaskBit13=8192;
int MaskBit14 =16384;
int MaskBit15 = -32768;

Wordresul =0:

Wordresul = {Wordxx && MaskBit00 }; // funcion & de dos palabras de 16 bits

// si el resultado de la and con la mascara es distinto de 0 es que el bit era 1 si no era 0
if (Wordresul != 0)
{
BitSal[0]=1;
}
Else
{
BitSal[0]=0;
}

Wordresul = {Wordxx && MaskBit01 };
if (Wordresul != 0)
{
BitSal[1]=1;
}
Else
{
BitSal[1]=0;
}

Wordresul = {Wordxx && MaskBit02 };
if (Wordresul != 0)
{
BitSal[2]=1;
}
Else
{
BitSal[2]=0;
}

Etc Etc Etc hasta el bit 15

Si alguien sabe como pasar de word a bit mas fácil le agradecería me lo explique o me indique algún manual tipo ensamblador
Gracias

2

que mezcolanza de cosas.
Primero si vas a trabajar con máscaras no uses números con signo sino SIN signo, en este caso

usigned int => 0 a 2^16.

Luego para que tanto lío con las máscaras si puedes usar 1<< Bit donde Bit es la posicion del bit de 0 a 15, con eso calculas las máscaras.

void word_to_Bit (unsigned int Wordin , boolean BitSal[16]){
      for (int i=0; i<16; i++) 
           BitSal[i] = Wordin && (1<<i); 
}
3

Esto si es una respuesta rapida y concisa tienes una cerveza pagada cuando nos veamos
Por cierto donde esta el manual de estos detallitos que no conozco ni entiendo "(1<<i)"

Gracias

4

En el lenguaje C básico. Se llama desplazamiento a izquierda y también lo hay a derecha.

Bitwise Operators

& (bitwise and)
| (bitwise or)
^ (bitwise xor)
~ (bitwise not)
<< (bitshift left)

(bitshift right)

Mira acá Arduino HomePage Learning
Ahi esta todo.

Entre ellas para bitshift << tienes esto

2, the following expressions can be employed:

1 << 0 == 1
1 << 1 == 2
1 << 2 == 4
1 << 3 == 8
...
1 << 8 == 256
1 << 9 == 512
1 << 10 == 1024

5

Lo siento surbyte pero creo que tu codigo no esta bien...

word_to_Bit (unsigned int Wordin , int BitSal[16])
 {
      int i;     
      for (i=0; i<16; i++) 
           BitSal[15-i] = (Wordin & (0x0001<<i))!=0;   // BitSal[0] Mayor Peso
 }

word_to_Bit (unsigned int Wordin , int BitSal[16])
 {
      int i;     
      for (i=0; i<16; i++) 
           BitSal[i] = (Wordin & (0x0001<<i))!=0;   // BitSal[0] Menor Peso
 }
6

y porque invertís los pesos? Si el MSB es 15 y el LSB es 0.

7

Saludos
Añadiendo a lo que Surbyte, tambien hay una forma de trabajar directamente con bits
Referencia de BitSet

8

Era un ejemplo, algunas veces necesitas que el primer bit sea el MSB y otras que el primer bit sea el LSB, solo le he dado las dos posibilidades de programación....
El problema en tu codigo era que ponias 2 && al hacer la AND.

9

esta bien, solo con un & pero toda tu respuesta parecía como que TODO lo que yo sugería estaba mal.

pero en eso tienes razón.

10

Gracias a todos el primero lo probe i no me iba pero pense que seria algo de paso de parametros por referencia y como tenia que marchar de viaje lo deje
al volver he visto vuestras respuestas y OK funciona

unsigned int pal_0,pal_1,pal_2,pal_3,pal_4,pal_5,pal_6,pal_7 = 0;

boolean E01,E02,E03,E04,E05,E06,E07 = 0;
boolean Ent,Sal,Mem,m2 = 0;
boolean Mem0,Mem1,Mem2,Mem3,Mem4,Mem5,Mem6,Mem7 = 0;

boolean BitSal[16];
boolean pal_bit0[16];
boolean pal_bit1[16];
boolean pal_bit2[16];
boolean pal_bit3[16];

void setup() { //********************************************************************************

Serial.begin(9600);

}
// ************* Funciones *************************************************************************
void pal_to_Bit (unsigned int pal_in , boolean BitSal[16])
{
int i;
for (i=0; i<16; i++)
BitSal = (pal_in & (0x0001<<i))!=0; // BitSal[0] Menor Peso
}

void loop() { //***********************************************************************************

  • pal_0++;*

  • pal_to_Bit(pal_0,pal_bit0);*

  • Serial.print(" , Numini =");*

  • Serial.println(pal_0);*

for (byte Num=0; Num<16; Num++)
{

  • // Serial.print(" , Num =");*
  • // Serial.print(Num);*
  • // Serial.print(" Valor =");*
  • Serial.print(pal_bit0[Num]);*
  • // digitalWrite(Num, pal_bit0[Num]);*
    }
  • Serial.println(" ");*
    } //FINAL DEL PROGRAMA
    RESUTADO
    , Numini =1
    1000000000000000
    , Numini =2
    0100000000000000
    , Numini =3
    1100000000000000
    , Numini =4
    0010000000000000
    , Numini =5
    1010000000000000
    , Numini =6
    0110000000000000
    , Numini =7
    1110000000000000
    , Numini =8
    0001000000000000
    , Numini =9
    1001000000000000
    , Numini =10
    0101000000000000
    , Numini =11
    1101000000000000
    , Numini =12
    0011000000000000
    , Numini =13
    1011000000000000
    , Numini =14
    0111000000000000
    , Numini =15
    1111000000000000
    , Numini =16
    0000100000000000
11

Si uno quiere ser estricto, la forma de presentarlo estaría mal. Los bits van de MSB en la posicion 15 a LSB en la posición 0.

MSB -- -- -- -- -- -- -- -- -- -- -- -- -- -- LSB
15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00

Pero tal vez sea la manera que yo estoy acostumbrado a leerlos y representarlos.
Usando programas de todo tipo, siempre los he visto de este modo y no a la inversa.
Finalmente cada uno los representa como mas le guste.

12

Esto es solo la forma en que lo imprimí en pantalla lo me que importa es que el array el bit de menos peso sea el [0] simple por lógica
En tema de orden de bits recuerdo que antiguamente había dos familias
Por ejemplo los micros que usaba omron ordenaban los bits al revés que los de siemens por eso cuando pasábamos programas de uno a otro siempre había lio
No sé si con el tiempo se ha estandarizado o cada familia sigue a lo suyo

Sigo trabajando a ratos en el programa PLC alguna cosa ya me va por eso ahora estoy diseñando interfaces entrada salida robustos tipo PLC os dejo un prototipo Son salidas opto acopladas aisladas para pilotar cargas de hasta 0,5A a 24 V
Estoy liado con las entradas pero quiero que lleven un buen filtro de picos de tensión y interferencias y naturalmente opto acopladas a 24 V
Todo va con la intención de conseguir un equipo tan robusto como un PLC industrial

También estoy haciendo un amplificador de instrumentación para adaptar la entrada de una PT 100 a la tensión de 0-5 V de las entradas analógicas del arduino, en un rango de 0 a 100ºC. Con lo que podría tener una precisión de una décima de grado

El problema es el tiempo tengo muy poco pero esto me gusta
Me parece que estoy volviendo a mis 20 años je je