Unir datos de un arreglo

[match82]

hola amigos, estoy haciendo un codigo en ccs, y quiero capturar una cadena de bits y guardarlo en una variable, bueno en realidad en dos variables, lo quee estoy haciendo es primero guardar los bit en un arreglo, y lo que no se aun ees como poder unir los valores ddel arreglo en una variable.

char data[26]; es el arreglo donde sse guardan los 26 bits
unsigned char code1; // para 8 bits
long int code2; /// para 16 bits

capturo los bits 1 a 1 y lo guardo todos en char data[26]

como junto esos valores en dos variables

Saludos ...

 

[Dr. Zoidberg]

Mejor que rehagas la consulta MUY CLARAMENTE por que no se entiende NADA de lo que querés hacer.

 

[ByAxel]

Hola.
Pueba esto...

unsigned char buff[8];
unsigned char dat, i;

void main()
{
   while(TRUE)
   {
      for(i=0 ; i<sizeof(buff) ; i++)
      {
         if(buff[i] == 1)
            bit_set(dat, i);
         else
            bit_clear(dat, i);
      }
   }
}

Ojo con la longitud del array y la longitud de bits de las variables.
Saludos.

 

[TRILO-BYTE]

bueno si estas en CCS

es como andar en triciclo

digamos que leo del puerto serie o de algun periferico
chars y las guardo

digamos que me llegan 4, 5, 6 ,7
y los guarde cada dato en un char
ejemplo cada char valdra
char[0]=4;
char[1]=5;
char[2]=6;
char[3]=7;


y yo quiero que sea 4567

bueno
tengo mi arreglo

char cadena[12];

y los quiero meter en un int16

int16 numero;

bueno lo ideal seria usar un atoi pero como estamos usando en CCS algo mas grande que 0 a 255 usaremos long esta atol

entonces

meto mi cadena en el numero con atol
numero=atol(cadena);


el ejemplo en codigo seria asi


char cadena[10];
int16 numero=0;

while(1)
{
//codigo que mete valores en el char

//despues al atol
numero=atol(cadena);
}

 

[match82]

Hola, lo que dice en la primera parte TRILO-BYTE, es lo que quiero hacer, en mi arreglo solo tengo bits de 0 o 1.
char[0] = 0
char[1] = 1
char[2] = 0
....
char[26] = 1

y los quiero juntar en variables

int116=1...010

estoy leyendo sobre la sentenciaa atol, pero aun n lo entiendo del todo.

Saludos

 

[ByAxel]

Para el caso no es posible ya que atoi y derivados solo trabajan con valores ascii o en cadena como string.

Es decir si tu tienes una cadena como:
char buff[4]={"1", "0", "1", '\0'}
El valor devuelto por atol sería 101 = ciento uno, que en binario es 1100101.

Mencionas antes que tienes solo bits en un array no ascii, por lo tanto solo son 0's y 1's, por lo que veo es necesario que sea manual la conversión... como antes mencioné.

Si usas el puerto serie debes de ver si lo que recives son 0's y 1's en ascii o valores numéricos para la comparación.
Si usas un pin para obtener los 0's y 1's hay mejores formas como usar shift_left por ejemplo.

Saludos.

 

[Dr. Zoidberg]

Hola, lo que dice en la primera parte TRILO-BYTE, es lo que quiero hacer, en mi arreglo solo tengo bits de 0 o 1.
char[0] = 0
char[1] = 1
char[2] = 0
....
char[26] = 1

Sigo sin entender NADA. Vos decís que en el arreglo SOLO TENES BITS 0 o 1 sin embargo el arreglo es de char y cada char tiene 8 bits, así que sería bueno que explicaras si en cada char tenes un 1 entero (0x01) o un '1' caracter (0x31) y los mismo para los ceros.
De lo otro que escribís PARECE deducirse (digo parece por que aún no te has expresado correctamente, y no sabemos si tenés una secuencia de enteros o de caracteres en el arreglo: lo que he marcado arriba son ENTEROS no caracteres) que la secuencia es de carateres, y en ese caso es muy simple hacer lo que querés, solo que aún no sabemos si el dato en la posición [0] del arreglo es el MSB o el LSB.

Te repito: expresate claramente en lo que estás consultando por que están tirando código al boleo y nadie sabe en que va a terminar este tema, o vas a caer en moderación. Estas avisado.

 

[match82]

Ok, trataré de explicarme mejor, estoy tratando de leer una cadena de bits que me entrega una lectora de proximidad, la lectora me entrega 26 bits por dos hilos y yo estoy tratando de capturar uno a uno los bits y guardarlos en un arreglo, entonces yo creé un arreglo char[26] para guardar los bits ahí
¿Está bien como lo pensé?

Entonces pensé tener :
char[0] = 0
char[1] = 1
char[2] = 0
....
char[26] = 1

Yo pienso que solo estoy guardando en el sub indice 0,1,2,...26 los datos de cada bit,
y al final quiero juntarlos para tener nuevamente el dato de 26 bits.

Saludos.

 

[TRILO-BYTE]

aaa ya entendi

no quieres leer bytes quieres leer bits

ejemplo 1010 que eso es en cadena de caracteres
y quieres que tenga un valor numerico que 1010 se transforme a 10 en decimal

eso es lo que entendi
debes hacer una funcion diferente deja te la busco

 

[ByAxel]

En el mismo evento que utilizas para capturar la secuencia de bits, se puede utilzar la funsión shift_left() o shift_right(), con esto te ahorras de estar guardando la trama de bits en una array un bit por posición como char... revisa el Help del CCS.

Tomado del mismo CCS.

byte buffer[3];

for(i=0; i<=24; ++i){
   // Wait for clock high

   while (!input(PIN_A2));
   shift_left(buffer,3,[B][COLOR="Blue"]input(PIN_A3)[/COLOR][/B]);

   // Wait for clock low

   while (input(PIN_A2));
}

// reads 24 bits from pin A3,each bit is read
// on a low to high on pin A2

En el ejemplo, los bits que entran por el PIN_A3 van directamente una variable o array...

 

[match82]

Si, quiero leer bits, como dije, la lectora de proximidad me entrega 26 bits y los capturo 1 a 1, luego tengo que juntarlos para volver a tener todos los bits y guardarlo en variables.

Gracias, saludos.

 

[TRILO-BYTE]

A-ver, acá lo tengo, está escrito en Borland C5, lo escribí hace años pero de que funciona, funciona.

#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <iostream.h>


void main()

{

char cadena[10];
int contador=0;
int x=0;
int a=0;

clrscr();



cout<<"valor" <<endl;
gets(cadena);


clrscr();

//-------FUNCION CONVIERTE CADENA BINARA A VALOR NUMERICO

//CON EL WHILE SE VA HASTA CARACTER NULO
while(cadena[contador]!= '\0')
{
      contador++;
}



contador=contador-1;      //SE POSICIONA UN VALOR ANTES DEL CARACTER NULO
                                //ES NECESARIO POR QUE EL BINARIO SE LEE DE DER. A IZQ.

//-----49 Y 49 ES EL ASCII 48 ES EL CERO Y 49 EL 1 "ESTO LO PUEDES CAMBIAR"
while(cadena[contador]==49 || cadena[contador]==48)
{
         if(cadena[contador]==49) //SI CADENA ES 1 CONVIERTE
       {
             a=a+1*pow(2,x);
             x++;
             contador--;
       }
         else                    //SI ES CERO NO CONVIERTE Y AVANZA
       {
             x++;
             contador--;
       }
}
//---------FIN DE LA FUNCION


cout<<a<<endl;           //IMPRIME EN PANTALLA

getch();


}

Solo cambia los cout por prints y el gets con cualquier función.

La idea es que tengo la cadena con las letras.
char cadena={1,1,0,1};

Que eso no tiene valor numérico pero si letras y las convierte en un valor numérico que es 13

Espero que funcione.

 

[match82]

Ok, pongo lo que hasta ahora tengo de código.
Yo estoy leyendo dos pines del puerto C por donde entran los datos .

#include <16F877A.h>       // PIC a utilizar
#FUSES HS                  // Crystal

#use delay(clock=20000000)  // Oscilador a 20MHz

/*#define lcd_data_port getenv("sfr:portd")       //"sfr:portb"
#define lcd_enable_pin pin_e1   
#define lcd_rs_pin pin_e0     
#define lcd_rw_pin pin_e2       
*/

//#include <lcd.c>    
#include <Flex_LCD420.c>  
//#include <Flex_LCD416.c>
//#include <LCD420.C> 

void main()
{

   set_tris_a(0b010000);       // configura el pin ra4 del porta como entrada
   set_tris_c(0b00000011);       // configura el pin rc0 y rc1 del portc como entrada
   output_a(0);                  // valor inicial para el porta
   output_c(0);                  // valor inicial para el portc
   
   char dat[26];                 /// 26 bit para toda la data
   unsigned char fcode;          /// para el facility code (0..255)
   long int code;                /// para el card number (0..65535)

   lcd_init();
   lcd_putc('\f');
   
   lcd_gotoxy(1,1);
   printf(lcd_putc, "****************");
   lcd_gotoxy(5,2);
   printf(lcd_putc, "WELCOME !");
   lcd_gotoxy(2,3);
   printf(lcd_putc, "                ");
   lcd_gotoxy(1,4);
   printf(lcd_putc, "****************");
   
   delay_ms(3000);
   
  while(true)
   {
   lcd_putc('\f');
   lcd_gotoxy(1,1);
   printf(lcd_putc, "INGRESO");
   delay_ms(3000);
   
            if(input(pin_c1)==0){             /// D1 a tierra?
            dat[i]=1;                         /// bit = 1
            i++;
            while(input(pin_c1)==0){};        /// esperando a que se libere
            }
            
            if(input(pin_c0)==0){             /// D0 a tierra?
            dat[i]=0;                         /// bit = 0
            i++;
            while(input(pin_c0)==0){};        /// esperando a que se libere
            }

Yo estoy guardando los 1 y 0 en el arreglo.
¿Cómo podría utilizar la función shift left aquí? Bueno aún no lo entiendo.

Saludos.

 

[Dr. Zoidberg]

Te estaba respondiendo con una posible solución, pero no entiendo como van los datos por C0 y C1. Podés dibujar un diagrama temporal??? Por que no me resultan nada claro los estados lógicos de cada pin... o explicá mejor como operan esas dos líneas.
PD: Mas simple que usar shift_left es usar el operado de desplazamiento propio del C, que es <<
.

 

[jvk85321]

Yo en vez de declarar dat[] como un arreglo de char lo declararia como un arreglo de bit, ademas echaria mano a los struct

atte
jvk85321

 

[Ardogan]

Como se complicó el hilo .
Como dice Dr. Zoidberg, es extraña la forma de leer datos por el puerto (por un pin se lee '0' y por el otro '1' en secuencia temporal?). Y coincido también que hay que usar operaciones de <<.
En definitiva se puede hacer con un arreglo de 3 bytes, y un byte extra con un valor inicial =1 que se va desplazando a izquierda conforme llegan nuevos bits. Ah sí, y una variable índice para el arreglo.

Pero es llamativa la forma de leer los bits, cómo se entera el que genera la serie de bits cuando enviar la información? ... será que hay un tipo apretando 2 botones (uno para '1' y otro para '0') donde ingresa un valor en binario después de que ve el mensaje en el LCD. O un micro que maneja una línea para '1' y otra para '0'?.
Buena suerte con encontrar un humano/micro que pueda mandar los datos con la precisión de microsegundos requerida para que ese programa (la parte que lee los bits) de información válida. Eso creo precisa corregirse antes que la forma más eficiente para convertir una serie de bits en un arreglo de bytes.

 

[cosmefulanito04]

Pero es llamativa la forma de leer los bits, cómo se entera el que genera la serie de bits cuando enviar la información? ... será que hay un tipo apretando 2 botones (uno para '1' y otro para '0') donde ingresa un valor en binario después de que ve el mensaje en el LCD. O un micro que maneja una línea para '1' y otra para '0'?.
Buena suerte con encontrar un humano/micro que pueda mandar los datos con la precisión de microsegundos requerida para que ese programa (la parte que lee los bits) de información válida. Eso creo precisa corregirse antes que la forma más eficiente para convertir una serie de bits en un arreglo de bytes.

Eso lo conozco como conexión one wire y existen varios sensores que se comunican de esa forma, con la linea con un pull-up, el uC dá la orden de empezar la comunicación poniendo en estado bajo la linea durante un cierto tiempo y luego el sensor toma control del bus y empieza a mandar la información. Por ej. el DHT11 (sensor de humedad y temperatura), trabaja con tiempos de decenas de uS.

Y estoy de acuerdo con lo que dicen, hay que usar shifters (<<) con un for/while para obtener los distintos bytes.

 

[Dr. Zoidberg]

Seee... pero esta es "two wire" ... y por un cable vienen los 1's y por el otro los 0's . Sigo sin entender para que usa los dos cables, a menos que sea transmisión sincrónica y uno de los cables lleve el clock... pero hasta que no lo aclare no vale la pena gastar neuronas.

 

[cosmefulanito04]

no leí que puso que era de dos hilos.

 

[TRILO-BYTE]

lo mejor seria subir el diagrama , subir la hoja de datos del X dispositivo
plantear la idea y en paint dibujar las formas de onda deseadas

como entan la cosas veo que si es one wire , two wire , al principio crei que leias 1 y 0 pero como caracter
pero resulta que no es asi, dicen que las resistencias pull up pero tampoco es asi.

los errores los hacemos todos pero es mejor explicar mejor.