Newsgroup: it.hobby.elettronica.digitale
Titolo: Invertire l'ordine dei bit in un byte

Buongiorno a tutti.
Non so se è l'NG più logico a cui chiedere ma ci provo lo stesso.
Ho una scheda elettronica di acquisizione che scrive continuamente su 
una porta 8 bit di dati.
Chi ha disegnato il master ha invertito i singoli bit della porta.
Mi trovo quindi nella situazione:
B7 B6 B5 B4 B3 B2 B1 B0
Io li dovrei trasformare a software all'opposto cioè
B0 B1 B2 B3 B4 B5 B6 B7
A parte shiftare 8 volte, esiste un "artificio matematico" che mi 
consenta di fare la cosa più velocemente dello shift?
Grazie a tutti
-- 
Ciao da Stefano

 Chi ha disegnato il master ha invertito i singoli bit della porta.
(cut)
ma non fai prima a prendere un connetore maschio e uno femmina (immagino
sia un DB 25) e cablarti un "adattatore"??
E poi cmq anche se shifti mica inverti l'ordinde dei bit... cioè
01234567
70123456
67012345
56701234
45670123
34567012
23456701
12345670
01234567
e sei allo stesso punto di prima
Saluti
AlphaPi

Il giorno Tue, 20 Feb 2007 12:36:57 +0100, AlphaPi
<com....@alphapi.RIGIRA.INVALID> ha scritto:

Infatti, deve usare un flag, di solito si usa il Carry e fare due shift in senso
opposto con il Carry.
--
ciao
  Stefano

LoScalzo ha scritto:

Se il problema è che il masterista non ha rispettato le specifiche, la soluzione 
va presa a livello hardware. In pratica se esistono le specifiche, sia hw che sw 
devono rispettarle.
Cercare di correggere via sw il problema è una soluzione che _sembra_ semplice 
(implementativamente lo è e come diceva un mio cliente "Il sw non fa macerie"), 
ma è un accrocchio assolutamente osceno che porta una maggiore pesantezza del sw 
(questo può impedire modifiche future al sw che, al contrario di questo o altri 
accrocchi, possono avere senso), oltre che a problemi in caso di future 
modifiche, manutenzioni (devi sempre ricordarti che le specifiche sono cambiate) 
e in caso di produzioni in serie è una bomba non ignorabile.
LP

 e in caso di produzioni in serie è una bomba non ignorabile.
Bomba non ignorabile in produzione in serie????
Se il firmware funziona invertendo il byte, cosa c'entra la produzione in
serie?

 senso opposto con il Carry.
Sì effettivamente volevo poi fare così solo ho saltato un pezzo del 
discorso :D
Mi interessa sapere solo una cosa però: come si fa con 2 shift :D ?
-- 
Ciao da Stefano


Sì scusami non mi ero spiegato bene prima!
Io vorrei fare così usando un flag il quale puà essere il carry..
-- 
Ciao da Stefano

 LP
Sì se emergono altri errori hardware mi sa che lo rifaremo.
Per adesso volevo solo provare la nuova scheda e cercavo di risolvere 
con qualche "stratagemma"
Se vedo che la cosa si risolve facilmente allora ok e magari lasciamo 
anche stare il masterista.
Altrimenti correggiamo il tutto...
-- 
Ciao da Stefano

Mi interessa sapere solo una cosa perň: come si fa con 2 shift :D ?
2 shift per ogni bit, naturalmente.  >>  e  <<
poi dipende in che linguaggio la fai
--
ciao
  Stefano

Altrimenti correggiamo il tutto...
Sono d'accordo ma soprattutto ricordatevi di avere fatto quella modifica.
Mi ricordo di un errore sul pcb che ha richiesto un workaround software, poi
subito corretti lo schematico e il pcb, alla prima versione modificata fatta
dopo diverso tempo non funzionava piů nulla.
E prima di ricordarsi del giochetto software abbiamo passato diverse ipotesi,
con conseguente tempo perso, sudori freddi e imprecazioni, per poi scoprire che
era una cavolata.
--
ciao
  Stefano

 
In rimando alla tua affermazione precedente, se qualcun altro dovesse mettere 
mano al sw in un secondo tempo e non invertisse il byte o accedesse direttamente 
a qualche bit (magari in modo indiretto)?
Mi è capitato di mettere mano a programmi per macchine industriali con queste 
schifezze (forse è per questo che mi comporto in modo così talebano :-) ), e 
dopo aver smadonnato molto tempo per cercare di mettere mano a programmi dove il 
primo sviluppatore ha preferito queste pezze sw per l'hw con il rischio anche di 
uccidere gente (se staccando un freno per errore una macchina di 800Kg dovesse 
cadere in testa ad un poveraccio, non basta un Moment), con la paura di fare io 
stesso degli errori nel toccarli (infatti nei casi peggiori ho riscritto il sw), 
tendo ad infervorarmi quando vedo cose simili.
É il metodo ad essere sbagliato.
Poi va da se che se il progetto consta di un solo pezzo, che solo il nostro 
amico utilizza e gestisce senza rischi di ferire persone o danneggiare cose, 
allora poi può fare quello che gli pare.
Chiedo scusa a tutti per il mio tono, ma su queste cose è una questione di 
principio.
LP

 che era una cavolata.
Immagino ed hai perfettamente ragione...
Siamo ancora abbondantemente in fase di test ma perdere tempo per una 
cretinata del genere non ne vale certo la pena!
-- 
Ciao da Stefano


Beh su tutto questo sono d'accordo...
Quello che vorrei far notare è che le uscite in questione invertite 
sono quelle che vanno ad un display; al max si incasina quello :D
A parte gli scherzi, su tutto il resto hai ragione!
-- 
Ciao da Stefano

 Non me ne devo ricordare io...
Non conosciamo il tuo software. Quello che Luca voleva dire è che se hai 
più punti del programma che accedono direttamente a quel bus di I/O 
allora dovrai cambiare il codice in tutti quei punti.
Ovvio che se hai un'unica routine chiamata più volte il problema non si 
pone. Ma concordo anch'io (in ambito industriale) con il punto di vista 
di Luca.
Ciao,
Marco / iw2nzm


'azz oggi son proprio rincretinito!
Avete ragione :D
Quindi concordo con Luca su tutto :D
-- 
Ciao da Stefano


Ciao, secondo me (se hai spazio in ROM) la cosa più veloce è una look
up table (da usare ovviamente solo quando accedi a quel bus)
Capoccetta

 wrote:

Vedo che i colleghi sono molto propensi alle chiacchiere, ma poco
inclini ai fatti concreti.
Io ho avuto lo stesso problema. Ho risolto il tutto con una semplice
routine in C che inverte l' ordine dei bit.
Ti posso assicurare che neanche per un istante ho pensato di rifare il
master per una banalita' di questo tipo.
/********************************** REVERSE
***********************************/
/* Routine di inversione del byte */
unsigned char reverse(unsigned char Cin)
{
unsigned char Cout;
Cout=0;
if(Cin&0x01)
	Cout|=0x80;
if(Cin&0x02)
	Cout|=0x40;
if(Cin&0x04)
	Cout|=0x20;
if(Cin&0x08)
	Cout|=0x10;
if(Cin&0x10)
	Cout|=0x08;
if(Cin&0x20)
	Cout|=0x04;
if(Cin&0x40)
	Cout|=0x02;
if(Cin&0x80)
	Cout|=0x01;
return Cout;
}

 inclini ai fatti concreti.
Ci piace fare 4 chiacchiere ogni tanto, sai com'č... ogni tanto ci vogliono
anche quelle... :-)