Buonasera a tutti sono nuovo in questo forum anche se lo ho utilizzato qualche hanno fa per un vecchio progetto, Arrivo al punto:
Ho bisogno di scrivere il programma su un Arduino UNO
in pratica ho bisogno di avere 6 uscite da dove escono degli impulsi 5v e 0 randomizzati cioè ogni uscita ha la sua frequenza di impulsi, questa frequenza random deve cambiare contemporaneamente per ogni uscita ogni qual volta io premo un pulsante.
Quindi in poche parole spingo il pulsante verrà assegnata una frequenza random su ogni uscita (6), questa frequenza deve rimanere la stessa finchè non spingo il pulsante da quel momento in poi viene assegnata un altra frequenza sempre random sulle uscite e cosi via
Ho fatto cose più semplici con Arduino questa mi sembra un po complicato per le mie conoscenze...
spero che qualcuno riesce ad aiutarmi
Grazie in anticipo.
Buongiorno,
essendo il tuo primo post, nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con molta attenzione tutto il su citato REGOLAMENTO ... Grazie. 
Guglielmo
P.S.: Ti ricordo che, purtroppo, fino a quando non sarà fatta la presentazione, nessuno ti potrà rispondere, quindi ti consiglio di farla al più presto. 
P.P.S.: Raccomando un'attenta lettura del REGOLAMENTO, ed in particolare del punto 16.1
grazie ho letto be se nessuno scrive il codice potete sempre aiutarmi a capire come fare
Chiarisci una cosa che forse sono tonto io e non ho capito, ma per ogni uscita la randomizzazione è sono nel tempo e quindi l'uscita alternerà lo stato HIGH e LOW di continuo (101010101010101) ogni N millisecondi oppure oltre al tempo anche lo stato è randomizzato ovvero ogni si può avere che l'usicta è 10000101111101101010100011?
oppure ogni uscita ha un pattern fisso e dovrà ripeterlo variando solo i millisecondi tra uno stato e il successivo?
Ovvero
uscita1="1000110101010"
uscita2="1110011010101"
e si ripetono all'infinito solo varianto il tempo?
Redmanx79:
...
cioè ogni uscita ha la sua frequenza di impulsi, questa frequenza random deve cambiare contemporaneamente per ogni uscita ogni qual volta io premo un pulsante.
Penso che voglia un generatore di frequenze diverse sui sei canali che cambiano ogni volta che preme il pulsante...
Anche perché se fosse una frequenza "random" non sarebbe una frequenza ma un casino....
Comincerei a studiare l'esempio BlinkWithoutDelay, che trovi nell'IDE a File=>Esempi=>02.Digital=>BlinkWithoutDelay.
Prova ad aggiungere un altro led che lampeggia a una frequenza diversa dal primo.
Ciao,
P.
Allora quello intendo per random è che praticamente varia in maniera random la durata dello stato HIGH e la durata dello stato LOW
in pratica facendo l'esempio del led acceso e spento:
void loop( ){
digitalWrite(3, HIGH);
delay(1000);
digitalWrite(3, LOW);
delay(1000);
in pratica quello che deve essere random è il delay quindi la durata dell'high e del low pero una volta che parte e viene impostato il delay random su ogni uscita deve restare quel valore di random finchè non spingo un pulsante che varierà il valore del random
Poi non so se in questo caso si usa il delay o altro però te l'ho scritto per rendere l'idea
Ok allora hai sequenze fisse e differenti tempi, segui l'indicazione di @pgiagno al post #6 ignorando temporaneamente il fatto che ti servirà il bottone per variare i tempi.
Se riesci a fare quello che ti ha suggerito sei quasi a cavallo
Prima scrivi:
Quindi in poche parole spingo il pulsante verrà assegnata una frequenza random su ogni uscita (6), questa frequenza deve rimanere la stessa finchè non spingo il pulsante da quel momento in poi viene assegnata un altra frequenza sempre random sulle uscite e cosi via
Poi però spieghi:
Allora quello intendo per random è che praticamente varia in maniera random la durata dello stato HIGH e la durata dello stato LOW
Questa richiesta e la seguente spiegazione sollevano ulteriori dubbi. Per frequenza si intende che il periodo T = 1/F, dove F è la frequenza del segnale da generare. T è espresso in secondi.
Un segnale ad onda quadra ha frequenza, periodo e duty cicle specificabile. Nel tempo T, ci sono due semi-periodi di durata dipendente dal duty cicle, se questo vale 0.5 (50%), un semi-periodo dura Tmezzo = T x 0.5. Esempio con un segnale ad onda quadra di frequenza 50Hz (oscillazioni per secondo) e duty cicle del 50%:
T = 1/50 = 0.02s
Tmezzo = 0.02s x 0.5 = 0.01s
Quando il duty cicle varia dal 50% un semi-periodo ha durata differente dall'altro semi-periodo. La frequenza rimane invariata a patto che la somma dei semi-periodi sia uguale a T.
Esempio 50Hz 0,019s (19ms) (alto), 0.001s (1ms) (basso). Allora 0.019 + 0.001 = 0.02s (20ms), F = 1/T = 1/0.02 = 50 Hz
Allora viene il dubbio circa la richiesta, che potrebbe essere:
6 Frequenze casuali e 6 valori casuali del duty cicle.
6 Frequenze casuali con duty cicle del 50%
6 Frequenze identiche ma con duty cicle casuale.
Comunque serve sempre definire i limiti almeno per il range di frequenze desiderato, ad esempio 6 frequenze differenti
casuali nel range 1÷100Hz, già è più chiaro e fattibile. Chiaro ma non realizzabile se il range vale 1÷1MHz.
Ciao.
Ciao si effettivamente è difficile dalla spiegazione pero andrebbe bene la stessa frequenza per tutti e 6 con il duty cicle variabile.
Scusatemi sono nuovo e imparero presto.
cmq lo rimetto qui come mi avete chiesto:
Buonasera
ho cercato di capire l'esempio che mi avete consigliato
(studiare l'esempio BlinkWithoutDelay, che trovi nell'IDE a File=>Esempi=>02.Digital=>BlinkWithoutDelay.)
e ne ho ricavato fuori questo:
const int ledPin = 2;
const int led2Pin = 3;
const int led3Pin = 4;
const int led4Pin = 5;
const int led5Pin = 6;
const int led6Pin = 7;
int ledState = LOW;
int led2State = LOW;
int led3State = LOW;
int led4State = LOW;
int led5State = LOW;
int led6State = LOW;
unsigned long previousMillis = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(led2Pin, OUTPUT);
pinMode(led3Pin, OUTPUT);
pinMode(led4Pin, OUTPUT);
pinMode(led5Pin, OUTPUT);
pinMode(led6Pin, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) { //led1
previousMillis = currentMillis;
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
digitalWrite(ledPin, ledState);
}
if (currentMillis - previousMillis >= interval) { //led2
previousMillis = currentMillis;
if (led2State == LOW) {
led2State = HIGH;
} else {
led2State = LOW;
}
digitalWrite(led2Pin, led2State);
}
if (currentMillis - previousMillis >= interval) { //led3
previousMillis = currentMillis;
if (led3State == LOW) {
led3State = HIGH;
} else {
led3State = LOW;
}
digitalWrite(led3Pin, led3State);
}
if (currentMillis - previousMillis >= interval) { //led4
previousMillis = currentMillis;
if (led4State == LOW) {
led4State = HIGH;
} else {
led4State = LOW;
}
digitalWrite(led4Pin, led4State);
}
if (currentMillis - previousMillis >= interval) { //led5
previousMillis = currentMillis;
if (led5State == LOW) {
led5State = HIGH;
} else {
led5State = LOW;
}
digitalWrite(led5Pin, led5State);
}
if (currentMillis - previousMillis >= interval) { //led6
previousMillis = currentMillis;
if (led6State == LOW) {
led6State = HIGH;
} else {
led6State = LOW;
}
digitalWrite(led6Pin, led6State);
}
}
sicuramente manca qualcosa o qualcosa è scritto male ma veramente sto impazzendo quindi se potete fatemi capire gli errore e se veramente si comporta come vorrei purtroppo non posso provarlo ora con arduino perche sto aspettando che me ne arrivi un altro visto che l'ultimo Arduino UNO l'ho utilizzato per una lettiera per gatti intelligente:)
Poi comunque fatemi capire come inserire il pulsante che dovrebbe cambiare i tempi di duty cycle quando viene premuto
Grazie dell'aiuto che mi state dando
Poi comunque fatemi capire come inserire il pulsante che dovrebbe cambiare i tempi di duty cycle quando viene premuto
Grazie dell'aiuto che mi state dando
Per adesso questo è l'ultimo dei tuoi problemi, io ancora non ho capito è certamente neanche tu, in sostanza capiamoci.
Non so se si riferisse anche a quello che ho scritto io quando ti risponde:
... sarà difficle, visto che NON leggi quello che ti si scrive. :
Sai perché, prima parli di frequenza, poi di duty cicle e poi il codice che hai postato potenzialmente ti permette
di ottenere 6 frequenze di lampeggio differenti a scelta, con duty cicle fisso al 50%.
Per cui io credo che si possa anche continuare per adesso con l'esempio che hai postato anche se poi
vorrai ottenere 6 duty cicle casuali a frequenza fissa.
Andiamo al codice. Tu hai copiato 1 volta e incollato 5 volte l'esempio blink senza apportare modifiche.
Io credo sia il caso di tornare indietro ad un solo blink e un solo led per il momento.
const int ledPin = 2;
int ledState = LOW;
unsigned long interval = 500; // intervallo espresso in millesimi di secondo (1s = 1000ms)
unsigned long previousMillis = 0;
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) { //led1
previousMillis = currentMillis;
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
digitalWrite(ledPin, ledState);
}
Intanto ho aggiunto la variabile interval è gli ho assegnato il valore 500.
Cosa mi aspetto che il codice faccia?
Il led rimarra acceso per 500ms.
si spegne e rimane spento per 500ms
Allora i due semi-periodi sono questi, ognuno vale 500 / 1000 = 0.5s
T = 0.5 + 0.5 = 1s, F=1/T = 1/1 = 1Hz.
Espresso letteralmente diciamo che il led lampeggia alla frequenza di 1Hz.
Come comprende il codice
Il valore che assume una variabile può essere stampato via seriale con serial.println().
Il valore che una variabile assume ad un dato istante può essere calcolato a mano per meglio comprendere
come funziona il codice che abbiamo scritto.
Per fare questa analisi attribuisco io devi valori plausibile alle variabili, valori validi per un dato istante.
La funzione loop() inizia nuovamente dopo l'ultimo '}'
In verità loop() termina ed previsto da codice interno ad arduino (che non vedi) che al termine venga chiamata nuovamente,
e ciò per sempre. Pertanto è un loop o ciclo infinito.
Io seguo. Andrebbe capito anche il "vero" motivo, sembra un tentativo di luci natalizie.
Redmanx79:
Buonasera
ho cercato di capire l'esempio che mi avete consigliato
(studiare l'esempio BlinkWithoutDelay, che trovi nell'IDE a File=>Esempi=>02.Digital=>BlinkWithoutDelay.)
e ne ho ricavato fuori questo:sicuramente manca qualcosa o qualcosa è scritto male ma veramente sto impazzendo quindi se potete fatemi capire gli errore e se veramente si comporta come vorrei purtroppo non posso provarlo ora con arduino perche sto aspettando che me ne arrivi un altro visto che l'ultimo Arduino UNO l'ho utilizzato per una lettiera per gatti intelligente:)
Ti dico la mia, non hai fatto quelle suggerito ma sei partito in quarta cercando di gestire subito tutto senza conoscere le basi per farlo, per giunta non puoi provare ma ipotizzare il flusso del programma scrivendolo e guardandolo, cosa fattibile certo, se si ha molta esperienza in ciò che si sta facendo. Detto questo per me la strada è difficile se intrapresa in tal modo, ovvero avrai sei uscite bene, dopo, tanto se riesci a capire come funziona davvero l'uso di millis per il tuo progetto con due led allora espanderlo a sei sarà cosa immediata. Quindi non incasinarti con tutto quel codice, limitati a due led, impara a farli lampeggiare con due frequenze differenti (come suggerito in altro posto), quando riesci a fare quello aggiugerei la gestione del pulsante, quando anche quella funziona espandere da due a sei ci metterai un secondo o due netti!
speedyant:
Io seguo. Andrebbe capito anche il "vero" motivo, sembra un tentativo di luci natalizie.
Lo subito pensato anch'io
Buongiorno
Avete ragione tutti sono troppo frettoloso e arrivo facilmente a conclusioni inutili....
Comunque ora ripartendo da quello che mi avete consigliato ho provato a fare tutto con solo 2 led
Questo è il codice:
const int ledPin = 2;
const int led2Pin = 4;
int ledState = LOW;
int led2State = LOW;
unsigned long interval =500;// intervallo espresso in millesimi di secondo (1s = 1000ms)
unsigned long previousMillis = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(led2Pin, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) { //led1
previousMillis = currentMillis;
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}}
if (currentMillis - previousMillis >= interval) { //led2
previousMillis = currentMillis;
if (led2State == LOW) {
led2State = HIGH;
} else {
led2State = LOW;
}}
digitalWrite(ledPin, ledState);
digitalWrite(led2Pin, ledState);
}
ho provato il codice su arduino il risultato è che i led lampeggiano se cambio il valore dell'intervallo cambia la frequenza di lampeggio il problema è che lampeggiano in maniera identica mentre io vorrei che lampeggiano con velocità diverse.
Poi si devo ripassare molti concetti per quello faccio difficolta a spiegare ma spero che possiate aiutarmi ugualmente.
ho provato il codice su arduino il risultato è che i led lampeggiano se cambio il valore dell'intervallo cambia la frequenza di lampeggio il problema è che lampeggiano in maniera identica mentre io vorrei che lampeggiano con velocità diverse.
Si esattamente questo è il comportamento, se ti stupisci di ciò non hai ancora afferrato come lavora quel codice, in particolare l'uso della funzione millis() la restituisce un valore differente tra due chiamate. Millis() ha risoluzione di 1ms, quindi se la chiami due volte a distanza di 2ms la prima chiamata avrà un valore inferiore di 2ms rispetto all'ultima chiamata.
Per potere variare la frequenza ti serve una variabile previousMillis per ogni led, stessa cosa per interval.
ad esempio: prevMillisLed1, intervalLed1 e prevMillisLed2, intervalLed2 e così via.
Le variabili intervalLedN (dove N 1, 2, 3 ...) dovranno essere inizializzate casualmente e allora avrai sei uscite a frequenza differente. Ti preoccuperai dopo di questo, prima dedicati a fare lampeggiare led a due frequenze differenti, poi separatamente di documenti sul generatore di numeri pseudocasuali, in seguito scoprendo cosa vuole dire pseudo ti documenterai se è possibile e come fare per fare in modo che siano davvero casuali e non solo pseudo.
PS: Ok, ho avuto conferma che ci siamo capiti e questo è l'importante il resto viene con il tempo.
Il nuovo codice
const int led1Pin = 2;
const int led2Pin = 4;
int led1State = LOW;
int led2State = LOW;
unsigned long intervalLed1 =500;// intervallo espresso in millesimi di secondo (1s = 1000ms)
unsigned long intervalLed2 =500;// intervallo espresso in millesimi di secondo (1s = 1000ms)
unsigned long prevMillisLed1 = 0;
unsigned long prevMillisLed2 = 0;
void setup() {
pinMode(led1Pin, OUTPUT);
pinMode(led2Pin, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - prevMillisLed1 >= intervalLed1) { //led1
prevMillisLed1 = currentMillis;
if (led1State == LOW) {
led1State = HIGH;
} else {
led1State = LOW;
}
}
if (currentMillis - prevMillisLed2 >= intervalLed2) { //led2
prevMillisLed2 = currentMillis;
if (led2State == LOW) {
led2State = HIGH;
} else {
led2State = LOW;
}
}
digitalWrite(led1Pin, led1State);
digitalWrite(led2Pin, led2State);
}
PS: Non fidarti tanto del codice postato ho problemi di vista, quindi se non funziona controlla il codice e vedi
di risolvere tu, se non ci riesci chiedi.
Ciao.
Grazie della pazienza..... capisco che è difficile... cmq ho inserito il codice e sono riuscito a variare la frequenza variando il valore di intervalLed1 e intervalLed2 cosi fa quello che desidero, ora il problema come dici tu resta randomizzare questi valori all'inizio, ora cercherò di studiare quello che mi hai consigliato e vediamo se riesco a fare ciò.
Effettivamente adesso farlo per il resto dei led è facilissimo.....
Grazie vi aggiorno piu tardi
Allora non ti resta che cercare nel reference "random()" e "randomSeed()".