Buondì a tutti 
Ho visto che il valore letto da un pin analogico flottante varia abbastanza, e pensavo di metterlo in XOR con la random per un mio progetto dove preferirei avere valori un po' casuali(senza usare librerie crittografiche o mettermi a leggere valori di ram a muzzo)..
La mia domanda è: alla lunga potrei danneggiare l'arduino a forza di leggere correnti elettrostatiche con l'A/D??
grazie..
no, non credo che si danneggi in alcun modo.
bene..grazie mille 8)
Non capisco la Tua idea di modificare il valore dato dalla funzione random per aumentare la casualitá. Mettendo un numero di partenza per la sequenta random gia ricevi serie di numeri pseudocasuali diversi.
randomSeed(analogRead(0));
http://arduino.cc/en/Reference/RandomSeed
Ciao Uwe
uwefed:
http://arduino.cc/en/Reference/RandomSeed
Ciao Uwe
Uwe, la tecnica di usare un ingresso analogico per il seme della random è descritta anche nel reference, infatti lo sketch di esempio ne fa uso 
Il motivo per cui per cui può essere necessario un seme sempre diverso è che in questo modo non generi la stessa sequenza di numeri pseudo casuali ad ogni accensione/reset.
Esistono poi diverse implementazioni di algoritmi PRNG (Pseudo-random number generator) più efficienti di quello integrato nell'Arduino. Ad esempio per un mio progettino avevo convertito in C alcuni vecchi algoritmi. Questo è molto semplice:
unsigned long m_w = 1;
unsigned long m_z = 2;
(...)
void setup() {
(...)
m_w=analogRead(A0);
m_z=analogRead(A1);
(...)
}
// ** Functions **
unsigned long getRandom() //return a random number between 0-(2^32-1)
{
m_z = 36969L * (m_z & 65535L) + (m_z >> 16);
m_w = 18000L * (m_w & 65535L) + (m_w >> 16);
return (m_z << 16) + m_w; /* 32-bit result */
}
Questo è un po' più complesso:
int seed1=1;
int seed2=1;
int seed3=1;
float minimo=0.0;
float massimo=0.0;
void setup() { .... }
void loop() {....}
float rndnumb2(int xp1, int xp2, int xp3) {
//min: -4.8204998970
//max: 4.7389950752
float totale;
seed1=171*(xp1%177)-2*(xp1/177);
seed2=172*(xp2%176)-35*(xp2/176);
seed3=170*(xp3%178)-63*(xp3/178);
if (seed1<0) { seed1+=30269; }
if (seed2<0) { seed2+=30307; }
if (seed3<0) { seed3+=30323; }
totale=seed1/30269.0+seed2/30307.0+seed3/30323.0;
return (totale-int(totale));
}
float random_stand_normal1() {
float tp1, tp2, tp3, tp4;
tp1=rndnumb2(seed1, seed2, seed3);
if (tp1>0.5) {
tp2=1-tp1;
} else {
tp2=tp1;
}
if (tp2 < 1E-20 ) {
tp4=10;
} else {
tp3=sqrt(-2*log(tp2));
tp4=tp3-((7.45551*tp3+450.636)*tp3+1271.059)/(((tp3+110.4212)*tp3+750.365)*tp3+500.756);
}
if (tp1>0.5) { tp4=-tp4; }
return tp4;
}
Richiami con numero=random_stand_normal1().
I valori
//min: -4.8204998970
//max: 4.7389950752
sono quelli che da prove mie empiriche sono i limiti max e minimo trovati.
Anche la libreria Avr-Crypto implementa un PRNG efficiente:
http://www.das-labor.org/wiki/AVR-Crypto-Lib/en#PRNGs
Ma occupa un po' di memoria e non so come lavori.
astrobeed:
uwefed:
http://arduino.cc/en/Reference/RandomSeed
Ciao UweUwe, la tecnica di usare un ingresso analogico per il seme della random è descritta anche nel reference, infatti lo sketch di esempio ne fa uso
Il motivo per cui per cui può essere necessario un seme sempre diverso è che in questo modo non generi la stessa sequenza di numeri pseudo casuali ad ogni accensione/reset.
@ astrobeed
Non ho contestato quello che scrivi Tu ma quello che scrive / ha in mente m_ri:
Ho visto che il valore letto da un pin analogico flottante varia abbastanza, e pensavo di metterlo in XOR con la random per un mio progetto dove preferirei avere valori un po' casuali...
Ho contestato il concetto di fare un XOR del valore letto da un pin analogico libero col valore dato dalla funzione random()per avere dei risultati numeri piú a caso.
Ciao Uwe
uwefed:
Non ho contestato quello che scrivi Tu ma quello che scrive / ha in mente m_ri:Ho visto che il valore letto da un pin analogico flottante varia abbastanza, e pensavo di metterlo in XOR con la random per un mio progetto dove preferirei avere valori un po' casuali...
Ho contestato il concetto di fare un XOR del valore letto da un pin analogico libero col valore dato dalla funzione random()per avere dei risultati numeri piú a caso.
Ciao Uwe
Perchè scusa? se non sbaglio, dati due numeri della stessa lunghezza generati da due generatori indipendenti, la XOR di questi due numeri darà un numero con entropia maggiore o uguale a max(entropia 1^ numero,entropia 2^ numero)... o sbaglio? è possibile che ci sia qlk correlazione,ma a occhio epsilon sarà minore di 2^-50..quindi non influente a fini pratici
@leo72: il primo codice mi sembra simile come procedimento a quello usato nella random statistica di molte implementazioni, il secondo codice invece mi sembra più interessante
non ho esigenze straparticolari, anzi ti spiego: ho fatto un antifurto usando un arduino mega e uno 1(casa e capannone) e son collegati da un cavo esterno dove dialogano continuamente(e se uno non sente più l'altro,partono sirene,cellulare..)...già che c'ero, davo fondo alle mie conoscenze crittoanalitiche per complicare la vita a qlkn che volesse entrare senza permesso
è solo che se usassi solo la rand di arduino avrei una sequenza troppo prevedibile..invece sporcando il tutto con sto valore flottante sarebbe meglio(e userei la rand modificata come "chiave di sessione"
@leo72: curiosità, il secondo codice dove l'hai preso? che a occhio direi che i semi non sono troppo distribuiti..poi x carità, per il mio progetto basta e avanza ...però son curioso..
Se parti con un valore casuale prendendola dalla entrata analogica anche la sequenza pseudocasuale é diversa ogni volta e non prevedibile.
Per conoscere il prossimo nr casuale del random() devi 1) conoscere la funzione usata per calcolare il random e second il valore di partenza che generi con randomSeed(analogRead(0)); .
Ma se vuoi complicarti la vita...
XOR funziona solo con variabili a 8 bit.
Ciao Uwe
uwefed:
Se parti con un valore casuale prendendola dalla entrata analogica anche la sequenza pseudocasuale é diversa ogni volta e non prevedibile.
Per conoscere il prossimo nr casuale del random() devi 1) conoscere la funzione usata per calcolare il random e second il valore di partenza che generi con randomSeed(analogRead(0)); .
o puoi anche prelevare qlk centinaio di valori e indovinare il successivo..anzi no,molti di meno..
uwefed:
Ma se vuoi complicarti la vita...
Dopo tutti i santi che ho tirato giù per il resto, con questo non dovrei aver problemi...
uwefed:
XOR funziona solo con variabili a 8 bit.
Ciao Uwe
vabbò così riuso i bitwise,che è da una vita che non li considero
ciao,
marco
@m_ri:
l'algoritmo è vecchiotto. E' una conversione arduinica di un codice trovato su un PDF in giro per la rete. Sono appassionato di crittografia (ho tradotto tante voci anche sulla Wikipedia in merito, soprattutto molti algoritmi di cifrari a scorrimento e diverse pagine "grosse" come la storia della crittanalisi) e ho cercato un po' in giro. Se ritrovo l'autore o il documento te lo passo.
leo72:
@m_ri:
l'algoritmo è vecchiotto. E' una conversione arduinica di un codice trovato su un PDF in giro per la rete.
vabbè lascia stare..cqm grazie
leo72:
Sono appassionato di crittografia (ho tradotto tante voci anche sulla Wikipedia in merito, soprattutto molti algoritmi di cifrari a scorrimento e diverse pagine "grosse" come la storia della crittanalisi) e ho cercato un po' in giro. Se ritrovo l'autore o il documento te lo passo.
forse può interessarti questo https://www.coursera.org/crypto
le prime lezioni sono basilari,ma poi va subito giù...
Trovato!! XD
http://cogprints.org/3723/
E' un saggio di Marc Brysbaert, è un documento vecchiotto ma le idee sono buone. Trovi diversi algoritmi su cui lavorare.
ok grazie..stass gli darò un'occhiata allora..