Newsgroup: it.comp.lang.c
Titolo: codifiche a correzione d'errore

Ciao gente,
non posto su questo ng da almeno 3 anni, come va?
Vengo al nocciolo:
Ho l'esigenza di scrivere un programma che esegua la decodifica di
simboli di 4 bit codificati con parole di 8. In particolare volevo
usare una codifica/decodifica di hamming.
Ora: Come faccio in C a prendere numeri di 8 bit e sdoppiarli in due
cifre di 4 bit?
E poi per ricongiungerle?
Per quanto riguarda la codifica mi trovo da solo l'algoritmo.
Probabilmente è una cosa scema, con 2 porte logiche sarebbe
facilissimo da fare, ma io devo farlo via software.
Grazie in anticipo
Franco
PS
Eventualmente come si potrebbe fare in assembly?

 Eventualmente come si potrebbe fare in assembly?
dipende dall'assembly (insomma dal processore).
Ma in C si fa prima.
Ciao Jack
PS: se qualcuno conosce un metodo piu' veloce e' pregato di dirlo :)
-- 
Eroi non si nasce, ti incastrano
- Jim Belushi

 E poi per ricongiungerle?
--8<-- cut here -----8<-- cut here -----8<-- cut here ---
unsigned char num;
unsigned char high;
unsigned char low;
/* Spezza num*/
high = num >> 4;
low  = num & 0xF;
/* riunisce num */
num = high << 4 | low;
--8<-- cut here -----8<-- cut here -----8<-- cut here ---
 > PS
 > Eventualmente come si potrebbe fare in assembly?
dipende dal processore target ma ti bastano shift a destra, shift a 
sinistra, or ed and la logica e' la stessa del frammento C.
Eventualmente attento ai segni. Se lo shift a destra è con segno e la 
variabile è signed ti entrano 1 da sinistra invece che 0. Al limite fai:
high = (num >> 4) & 0x0F;
e sei a posto.
Remo D.

 
Ma sei sicuro di questo?
A me pare che in c vengano sempre inseriti degli zeri indipendentemente 
dal tipo della variabile.
Con il C dei DSP Texas ne sono quasi certo.
Nella specifica ANSI C e' specificato il comportamento dei compilatori 
in questo caso?
Ciao
Giuseppe

 dal tipo della variabile.
In effetti sono andato a memoria, avrei dovuto dire che "potrebbero 
entrare degli 1 da sinistra". Lo standard dice (1124.pdf):
6.5.7
   5) The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 
has an unsigned type or if E1 has a signed type and a nonnegative value, 
the value of the result is the integral part of the quotient of E1 / 
2^E2. If E1 has a signed type and a negative value, the resulting value 
is implementation-defined.
Quindi se E1 č signed ed ha valore negativo il risultato dipende dal 
compilatore (implementation defined). Non saprei dire dove ma ricordo di 
aver dovuto dare la caccia ad un bug provocato da uno shift a destra di 
un valore negativo tanto tempo fa. Credo fosse su una Sun ma non ci 
giurerei.
Remo.D


Dei segni non mi importa, ho tutti valori positivi tanto.
L'unico problema è se mi riempie le parole di 1 invece che di 0 quando
l'uno è l'MSB.
Comunque ho capito il concetto.
Come microcontrollore pensavo di farlo su un ATMEL ATmega 8535,
eventualmente posso usare anche porte logiche lato periferica, il
reale problema è lato pc, è li che devo prendere i dati e
decodificarli via software.

Ho provato con la maschera di bit e funziona benissimo.
Per risolvere il problema degli shift è facile,
in fase di codifica metto i bit di correzione in maniera alternata o
come 4 MSB o come 4 LSB.
Quando poi ricevo i simboli li memorizzo a due a due e li riunisco
come:
elemento= elem_low &elem_high
Ovviamente quando ricevo un valore pari faccio:
if((i%2)==0){
          elem_low= buffer[i] & 0x0F;
}
se è dispari:
if((i%2)==1){
        elem_high= buffer[i]&0xF0;
        elemento= elem_low &elem_high;
}
e a questo punto ricomincio il ciclo.
elem_low, elem_high, elemento e le celle del buffer sono di tipo char
(1byte).
Così penso che funzionerà anche una volta implementato.
Se volete posto pure il codice per la modulazione e demodulazione di
frequenza appena lo scrivo :-)
Ciao