Anemometro per chiudere la tenda... con arduino.

Ebbene, dopo 9 memsi che ho acquistato un kit Arduino per imparare, oggi l'ho aperto :-) Con la stampante ho creato un anemometro a 3 coppe con sensore di hall e vorrei usarlo per far chiudere la tenda in caso di forte vento. Sono praticamente quasi a zero in programmazione, per ora ho acceso il led, poi ne ho accesi due, poi col tastino ecc ecc quindi sono molto indietro ma ho scaricato diversi manuali per principianti e piano piano sto leggendo anche se con molta fatica.

seguente: leggo il sensore (4 impulsi al secondo per 1m/s), confronto la lettura col parametro variabile di un trimmer che setta il valore di intervento, se il valore coincide o viene superato allora, dopo un certo tempo

Premesso che la tenda ha i fine corsa interni che fermano il motore, con

dovrebbe succedere nulla se non si rompe un fine corsa ma non trovo un

Per chi volesse vedere l'anemometro, dopo varie modifiche il risultato

formatting link

--
Saluti da Drizzt. 


www.agidone.altervista.org 
 Click to see the full signature
Reply to
Drizzt do'Urden
Loading thread data ...

Drizzt do'Urden ha scritto:

i
e

? la

,

econdi.

n

non

nte

sa.

nuamente?

complimenti per la realizzazione pratica! possiedi un tornio...direi per fare certi pezzi ?

sino a che un fine corsa rileva la chiusura della tenda? idem per l'apertura. escludendo arduino,visti i tuoi problemi di programmazione,puoi risolvere il problema con qualche opamp

Reply to
emilio

Il 23/08/2019 22:07, emilio ha scritto:

Stampante 3D :-)

diciamo che per l'apertura non mi serve, la apro io in manuale quando serve, per la chiusura, i 60 secondi sono il tempo massimo che serve

Quindi consigli di montare un fine corsa che indichi al circuito quando

la giornata la sposto in base al sole.

ci avevo pensato e per me sarebbe meno complicato ma poi mi sono detto

Comunque, nel caso non ci riuscissi, andrei di elettronica classica :-)

--
Saluti da Drizzt. 


www.agidone.altervista.org 
 Click to see the full signature
Reply to
Drizzt do'Urden

usa lo stesso fine corsa :) a quanti volt funziona il motore ? se sono 220, prima ho chiesto a Claudio se funzionava ancora il suo circuito con fotoaccoppiatore. Fa proprio quello che serve a te, prende tensione a 220 e comunica al micro il fine corsa. Bel lavoro :)

Reply to
Franco Af

Il 23/08/2019 22:41, Franco Af ha scritto:

Reply to
Franco Af

Qualsiasi cosa tu voglia fare in questo genere di problemi (ovvero frequenza caratteristica molto diversa dai tempi di intervento degli attuatori) ti suggerisco magari in seconda battuta di implementare sempre una coda con N

previsioni. Per esempio come si gestiscono sequenze di raffiche brevi? Si rischia di tentare di inseguire il fenomeno stressando tenda, motori e meccanismi. Se invece si incorpora nel codice l'euristica per trattare questo e altri casi, spesso si riesce a migliorare il comportamento.

confidenza con la programmazione e una struttura dati (la coda) spesso molto utile.

--
- Era ferma e nuda, cos'altro avrei dovuto fare? 
- Ehm... L'autopsia.
 Click to see the full signature
Reply to
Archaeopteryx

Il 23/08/2019 22:46, Franco Af ha scritto:

--
Saluti da Drizzt. 


www.agidone.altervista.org 
 Click to see the full signature
Reply to
Drizzt do'Urden

Il 23/08/2019 23:00, Archaeopteryx ha scritto:

Sai che ci avevo pensato? Le raffiche improvvise, magari che durano pochissimo ma sono tante,

durata della raffica. La vedo dura, per ora ho solo acceso due led :-D :-D

Ho visto che ora, invece di montare un anemometro, montano direttamente nell'asta che raccoglie la tenda, un sensore di vibrazioni tarabile.

--
Saluti da Drizzt. 


www.agidone.altervista.org 
 Click to see the full signature
Reply to
Drizzt do'Urden

Anzitutto ti serve una variabile in cui accumulare le letture rapide, con un contatore associato. Ovvero, leggi, aggiungi il valore a questa variabile, incrementi il contatore e quando raggiunge gli N valori, dividi per N e

implementato con gli interi si impara molto.

A questo punto ti vai a vedere in rete come funziona la

altro contatore che viene incrementato ogni volta che leggi il valore dal passo precedente. Quando raggiunge M si azzera e ricomincia il ciclo; il valore va inserito nella cella corrispondente al contatore. In questo modo eviti di spostare tutti i valori dell'array ogni volta che vuoi inserire l'ultimo elemento, dato che l'ordine non ha quasi mai importanza sei a posto.

cose, per esempio una regressione per capire quanto rapidamente sta aumentando il vento e nel caso tentare di anticipare l'azionamento. Ovvio che se servisse solo per una media su tempi lunghi una coda sarebbe inutile (basterebbero valori di N maggiori nella prima sezione),

ma magari il problema ti suggerisce altri usi di questi dati.

Magari potresti fare una prima versione in float e poi fare il grande salto agli interi peraltro indispensabile per lavorare con questi aggeggi.

--
- Era ferma e nuda, cos'altro avrei dovuto fare? 
- Ehm... L'autopsia.
 Click to see the full signature
Reply to
Archaeopteryx

Il 23/08/19 22:41, Franco Af ha scritto:

Mi associo ai complimenti per i pezzi 3D, non ho capito bene l'innesto rotante (come fa ad essere privo di attrito).

Per l'opto direi di no, almeno non con quel circuito dove sono da leggere singoli impulsi (singole semionde) con doppio filtro software per evitare riconoscimenti errati, non e` una programmazione a portata di superprincipiante.

A lui servirebbe un circuito che fornisca un livello stabile come un interruttore o un finecorsa.

Mo ad esempio vado a ritrovare la lettura di quell'opto...

...

...

//---------------------------------------------------------- // FUNZIONE : readPulsCorridoio // DESCRIZIONE: Legge pulsante luce corridoio con debounce // e riconoscimento click e longpress. // La pressione genera impulsi LOW. // PARAMETRI : nessuno, imposta le variabili globali // onClicCorr e onLpressCorr // RETURN CODE: ignorato //---------------------------------------------------------- void readPulsCorridoio(void) { uint32_t static t1; uint32_t static t2; uint32_t static t3; uint8_t static w1 = 0; uint8_t static w2 = 0; uint8_t static w3 = 0; uint8_t static s = 0; uint8_t in = digitalRead(PULSANTE_CORRIDOIO);

// timer retrigg. livellamento impulsi 50Hz if (LOW == in) { w1 = 1; t1 = now; } else if (now-t1 > 20) { w1 = 0; }

// timer debounce 60ms if (w1 == w2) { t2 = now; } else if (now-t2 > 60) { w2 = w1; }

// timer Ton per long press if (!w2) { w3 = 0; t3 = now; } else if (now-t3 > 700) { w3 = 1; }

// macchina a stati per riconoscimento click / lpress onClicCorr = 0; onLpressCorr = 0; if (0 == s and w2) { s = 1; } else if (1 == s and !w2) { onClicCorr = 1; s = 0; } else if (1 == s and w3) { onLpressCorr = 1; s = 2; } else if (2 == s and !w2) { s = 0; } }

E lo schema fidocad:

[FIDOCAD] FJC C 3.0 FJC B 0.5 MC 80 30 0 0 200 MC 120 30 0 0 340 LI 115 30 120 30 0 LI 115 50 120 50 0 LI 95 30 100 30 0 TY 40 25 6 5 0 1 0 Courier++10++Pitch L MC 80 50 1 0 860 LI 80 30 50 30 0 LI 107 28 108 32 0 LI 108 32 110 28 0 LI 110 28 111 32 0 LI 100 30 103 30 0 LI 104 28 105 32 0 LI 105 32 107 28 0 LI 103 30 104 28 0 LI 115 30 112 30 0 LI 111 32 112 30 0 LI 111 52 112 50 0 LI 103 50 104 48 0 LI 104 48 105 52 0 LI 105 52 107 48 0 LI 107 48 108 52 0 LI 108 52 110 48 0 LI 110 48 111 52 0 LI 115 50 112 50 0 LI 100 50 103 50 0 LI 100 50 80 50 2 TY 105 21 4 3 0 0 3 Courier++10++Pitch 47k 1W TY 105 54 4 3 0 0 3 Courier++10++Pitch 47k 1W TY 75 20 4 3 0 0 3 Courier++10++Pitch 1n4007 TY 146 37 4 3 0 0 3 Courier++10++Pitch 4n25 LI 50 50 65 50 6 TY 40 45 6 5 0 1 6 Courier++10++Pitch N
Reply to
Claudio_F

convince il tenerlo sempre collegato alla 220 anche per giornate intere.

Sicuramente meglio la soluzione del fine corsa anche meno complessa

Reply to
Franco Af

Il 23/08/2019 23:30, Archaeopteryx ha scritto:

ehhh???? che cavolo stai dicendo Willis! :-P

Non ci ho capito una mazza, io sono arrivato a "accendi un led, spegni un led" :-)

Nella prossima vita voglio iniziare prima a capire la programmazione,

--
Saluti da Drizzt. 


www.agidone.altervista.org 
 Click to see the full signature
Reply to
Drizzt do'Urden

Il 23/08/2019 23:42, Claudio_F ha scritto:

ha un cuscinetto, si vede in una foto.

per quanto riguarda la programmazione devo approfondire ma la vedo moooolto dura :-)

--
Saluti da Drizzt. 


www.agidone.altervista.org 
 Click to see the full signature
Reply to
Drizzt do'Urden

Il 24/08/19 11:03, Drizzt do'Urden ha scritto:

Ah, ok, il perno della parte inferiore si innesta nel foro del cuscinetto, mentre la parte superiore si innesta sull'esterno di esso, giusto?

Se e` vero che per diventare "produttivi" con qualsiasi linguaggio, nel senso di non avere (troppi) dubbi su come procedere per risolvere un problema, serve non meno di un anno, e` anche vero che giocando con le basi e con problemi non troppo complessi in poche settimane se ne esce vivi:D (e ne vale la pena perche` si apre un mondo di possibilita`)

Reply to
Claudio_F

Il 24/08/19 10:33, Franco Af ha scritto:

Concordo sul finecorsa, ma comunque una normale spia led per interruttori, limitata con una resistenzina che scalda abbestia, e` venduta per essere sempre sotto tensione in impianti civili, ed e` sicuramente peggio di quel circuito (che invece ha straabbondanti margini si sicurezza su tensioni e dissipazioni).

Reply to
Claudio_F

Il 23/08/19 23:30, Archaeopteryx ha scritto:

Premessa indispensabile: non conosco il linguaggio in questione, mi sono occupato occasionalmente solo di Basic e Assembler, sto parlando sempre per idea generale e secondo i miei personali criteri di programmazione.

Per lavorare con gli interi secondo me e' sufficiente moltiplicare per k=10, 100 o 1000 il singolo valore da sommare. Alla fine, dividendo per N avrai un intero con la risoluzione di 10, 100 o 1000 a seconda di k.

Io di solito preferisco un registro circolare con numero di celle M, scelto tra le potenza di due. Incremento il contatore e facendo un AND con il massimo numero di eventi M meno 1, ottengo un registro che contiene tutti gli M eventi precedenti, senza necessita' di azzerare. Se voglio uno storico degli eventi basta che prendo l'indice N attuale e decremento M volte, sempre facendo un AND con M meno 1, aggiustando il segno. Piu' o meno...

Ma, naturalmente ogni programmatore e' un mondo a parte... (*) :-D

Come ho detto sopra si puo' passare direttamente agli interi.

angelo

p.s. confesso che definirmi programmatore e' un'esagerazione...

Reply to
angelo

Il 24/08/19 11:01, Drizzt do'Urden ha scritto:

Tardi non e` detto, basta un po' di metodo (e il caos di informazioni in rete spesso sbagliate non aiuta).

Ma, sintetizzando al massimo: hai un problema da risolvere, lo vuoi far risolvere in modo automatico alla macchina, ma ovviamente per poterlo "spiegare" alla macchina tu devi gia` sapere come risolverlo concettualmente "a mano" (questa e` l'analisi).

E qui viene il linguaggio di programmazione, cioe` le cose che la macchina puo` "comprendere", che alla fine sono molto poche. Il lavoro del programmatore e` escogitare la giusta sequenza di queste poche cose che risolve in modo automatico il problema di partenza.

Quindi conosci il problema, lo sai gestire concettualmente, sai cosa e` in grado di comprendere/eseguire la macchina, e quindi descrivi la procedura concettuale inventandoti una sequenza di passi comprensibili al micro.

Di cosa sono formati questi passi? Sempre delle stesse cose praticamente in ogni linguaggio imperativo:

- uso di variabili di diversi tipi per contenere i valori di lavoro

- operazioni aritmetiche/logiche possibili con le variabili o le costanti

- prendere decisioni in base a confronti (cosa fare se, if condizione ...)

- ripetere piu` volte una parte di programma (cicli while, for)

- funzioni per scomporre la logica in parti brevi e semplici

- array, tabelle, strutture per raggruppare/gestire le variabili in modo piu` comodo

- e giusto un accenno ai puntatori, che addirittura nel reference di Arduino viene saltato completamente etichettato come argomento avanzato.

Dopo di che c'e` solo la pratica, cioe` vedere in che modo determinati problemi sono gia` stati affrontati e risolti, e riuscire a capire quale "design" della sequenza ci semplifica la vita o, al contrario, ci infogna in qualcosa di irrisolvibile.

--
Nel caso in questione abbiamo la lettura della velocita`, che  
richiedera` un'apposita procedura (per frequenze cosi` basse e` molto  
 Click to see the full signature
Reply to
Claudio_F

Il 24/08/2019 18:10, Claudio_F ha scritto:

cut:

Ottima spiegazione, diciamo che fino a questo punto ci sono arrivato e che quello sketch l'ho capito, aggiungo che, parlando con un amico che monta qualche sensore del vento per tende, mi ha detto che funzionano in questo modo (quelli che monta lui):

se arriva una raffica che supera la soglia minima impostata (chiamiamola

massima (soglia 2) allora la tiene chiusa.

devo approfondire col mio amico per sapere come fa la centralina a

Al limite potrei collegare i pulsanti di apertura e chiusura al micro ma

aperta, anche se non precisamente di quanto.

Altra cosa: oggi mi sono messo a fare qualche prova con un pulsante e un led e mi sono imbattuto nel problema del rimbalzo del contatto, ho trovato uno sketch che risolve il problema ma non l'ho capito, fa una giravolta di istruzioni che mi rimbambiscono, non comprendo la logica di quelle istruzioni :-P

Riuscite a spiegarmelo senza troppi tecnicismi? :-)

//Cambia lo stato del led (acceso/spento) in seguito alla pressione del pulsante. //I microrimbalzi vengono filtrati grazie all'apposita funzione richiamata in sostituzione a digitalRead(pin)..

#define led_pin 13 #define button_pin 8

boolean led_state; boolean button_state; boolean previous_button_state;

int debounceDelay = 20;

******************************************************** ********************************************************

boolean debounce(int pin) { boolean state; boolean previousState; previousState = digitalRead(pin); for(int counter=0; counter < debounceDelay; counter++) { delay(1); state = digitalRead(pin); if( state != previousState) { counter = 0; previousState = state; } } return state; }

void setup() { pinMode(led_pin, OUTPUT); pinMode(button_pin, INPUT_PULLUP); }

void loop() { button_state = debounce(button_pin); if(button_state==LOW && previous_button_state==HIGH) led_state =

1-led_state; previous_button_state = button_state; if(led_state==1) digitalWrite(led_pin, HIGH); else digitalWrite(led_pin, LOW); }
--
Saluti da Drizzt. 


www.agidone.altervista.org 
 Click to see the full signature
Reply to
Drizzt do'Urden

Il 24/08/2019 19.07, Drizzt do'Urden ha scritto: ...

...

suo primo listato che leggo), ma direi che: si definisce la funzione logica debounce della

pin del processore), si legge inizialmente il valore del dato pin e lo si immagazzina nella variabile previusState, il ciclo for si ripete fino a quando lo stato rimane _invariato_ per una durata di tempo consecutiva di delay(1) * debounceDelay = 20 ms, poi il valore dello stato viene assegnato alla funzione debounce all'uscita dal ciclo.

Ciao

--
Giorgio Bibbiani 
(mail non letta)
Reply to
Giorgio Bibbiani

ElectronDepot website is not affiliated with any of the manufacturers or service providers discussed here. All logos and trade names are the property of their respective owners.