Un volgare led
Se non vuoi il led va bene anche una resistenza, puoi provare cercando dummy load.
Mi sorge spontanea una domanda... se rilevare l'assenza di tensione con 3/4 secondi di ritardo è un problema mi sembra che l'apparato sia un po' "mission critical" e non so se arduino sia la scelta corretta o comunque non può garantire la necessaria sicurezza che stai cercando, poi magari mi sbaglio è solo una mia curiosità.
docsavage:
Un volgare led
Seee ... se è un alimentatore fatto bene, con dei bei condensatori, con un LED (... anche fatto lavorare a 20mA) ce ne vuole di tempo ... meglio una bella resistenza da 33Ω 2W così si porta l'assorbimento a oltre 150mA ... vedi come va giù veloce 
Guglielmo
Non lo nego, anzi
Ma col led se la cava prima, è ha conferma di quello che si dice. Poi stasera compera la resistenza
Ma guardate anche che scenda a 2 secondi va bene! Anche perché riprovando più volte forse supero i 5/6 secondi per scaricarlo!
Quindi stasera provo sia con la resistenza e sia con un led e faccio le mie valutazioni!
Comunque per essere esatti:
Collego la massa del l’alimentatore alla massa, il cavo corrente alla breadbord con una resistenza, e da lì faccio partire il cavetto che va nel pin di arduino che legge la corrente.
Sbaglio qualcosa?
Perché attualmente ho il cavo corrente infilato direttamente dentro il pin arduino. E funziona peccato per il ritardo!
Però ora rileggendo i vecchi messaggi, qualcuno mi aveva consigliato di usare una resistenza 10K per sicurezza in caso di sbalzi di tensione....
Ma dove la collego questa resistenza 10K? Mi sto un po’ confondendo, ho paura di fare un pasticcio ahahah tra quella per la sicurezza e quella per scaricare l’alimentatore !
Ciao ragazzi ho fatto tutti i collegamenti e funziona. Ma ora leggendo un po’ in giro quello che consigliate sempre, cioè di stare alla larga dalla 220V mi è venuta un po’ la paranoia...
Il sistema funziona, devo solo concludere la parte audio, scosse non ne ho prese...ma siamo sicuri che non rischio di fare danni? Tenendo conto che deve restare acceso 24/24!
Capisco che l’alimentatore attaccato alla 220, riduca fino a 5V
Però ci potrebbero essere problemi? Chiedo a voi esperti!
miticobeppe:
Capisco che l’alimentatore attaccato alla 220, riduca fino a 5V
Però ci potrebbero essere problemi? Chiedo a voi esperti!
SE l'alimentatore è di buona qualità e non una "cinesata" da 2€, allora non c'è alcun problema ...
... ho alimenatori a 5V accessi 24/24 da anni e anni senza alcun problema 
Guglielmo
Ragazzi son due sere che non riesco ad andare avanti!! Non so perché ma la funzione mills impostata per il rilevamento tramite serial della corrente si abbina da sola alla funzione che fa partire l'audio!!
precisamente questo comando "myDFPlayer.play(12);" fa partire la traccia d'allarme, che dura circa 3 minuti, invece parte ma si looppa da sola, è smanettando tutto ho notato che segue il tempo del mills impostato per la lettura seriale!!
come posso risolvere? ho provato a mettere nel IF un void allarme ();
creando poi la funzione separata, ma niente non funziona in questo caso neanche parte l'audio!
Come separo i due meccanismi???
il lampeggio del led e la lettura seriale sono un conto, mentre la partenza audio è un altro conto! non capisco proprio perché vada in loop
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "Arduino.h"
#include "SoftwareSerial.h"
#include "DFRobotDFPlayerMini.h"
SoftwareSerial mySoftwareSerial(10, 11); // RX, TX
DFRobotDFPlayerMini myDFPlayer;
void printDetail(uint8_t type, int value);
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2
#define LOGO16_GLCD_HEIGHT 16
#define LOGO16_GLCD_WIDTH 16
static const unsigned char PROGMEM logo16_glcd_bmp[] =
{ B00000000, B11000000,
B00000001, B11000000,
B00000001, B11000000,
B00000011, B11100000,
B11110011, B11100000,
B11111110, B11111000,
B01111110, B11111111,
B00110011, B10011111,
B00011111, B11111100,
B00001101, B01110000,
B00011011, B10100000,
B00111111, B11100000,
B00111111, B11110000,
B01111100, B11110000,
B01110000, B01110000,
B00000000, B00110000 };
#if (SSD1306_LCDHEIGHT != 32)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif
int corrente = 52;
int ledPinVerde = 51;
int ledPinRosso = 53;
int ledState = LOW;
long previousMills = 0;
#define interval 300
long previousMills2 = 0;
#define interval2 500
void setup() {
mySoftwareSerial.begin(9600);
Serial.begin(115200);
Serial.println();
Serial.println(F("DFRobot DFPlayer Mini Demo"));
Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));
if (!myDFPlayer.begin(mySoftwareSerial)) { //Use softwareSerial to communicate with mp3.
Serial.println(F("Unable to begin:"));
Serial.println(F("1.Please recheck the connection!"));
Serial.println(F("2.Please insert the SD card!"));
while(true);
}
Serial.println(F("DFPlayer Mini online."));
pinMode(ledPinVerde, OUTPUT);
pinMode(ledPinRosso, OUTPUT);
/// DISPLAY
Serial.begin(9600);
// by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // initialize with the I2C addr 0x3C (for the 128x32)
// init done
// Show image buffer on the display hardware.
// Since the buffer is intialized with an Adafruit splashscreen
// internally, this will display the splashscreen.
display.display();
delay(2000);
// Clear the buffer.
display.clearDisplay();
// text display tests
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0,0);
display.println("Status Temperatura");
display.setTextColor(BLACK, WHITE); // 'inverted' text
display.println(3.141592);
display.setTextSize(4);
display.setTextColor(WHITE);
display.print("0x"); display.println(0xDEADBEEF, HEX);
display.display();
delay(2000);
display.clearDisplay();
}
void loop() {
// read the input pin:
int StatoCorrente = digitalRead(corrente);
// print out the state of the button:
// Serial.println(StatoCorrente); //Serial.println(StatoCorrente);
//delay(500); // delay in between reads for stability
unsigned long currentMillis = millis();
if (millis() - previousMills2 > interval2 ){
previousMills2 = millis();
Serial.println(StatoCorrente);
if (StatoCorrente == HIGH)
{
digitalWrite(ledPinVerde, HIGH);
digitalWrite(ledPinRosso, LOW);
myDFPlayer.disableLoopAll();
}
else if (StatoCorrente == LOW)
{
digitalWrite(ledPinVerde, LOW);
myDFPlayer.volume(30); //Set volume value. From 0 to 30
myDFPlayer.play(12); //Play the first mp3
unsigned long currentMillis = millis();
if (millis() - previousMills > interval ){
previousMills = millis();
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
// set the LED with the ledState of the variable:
digitalWrite(ledPinRosso, ledState);
}
}
}
}
miticobeppe:
Come separo i due meccanismi???
il lampeggio del led e la lettura seriale sono un conto, mentre la partenza audio è un altro conto! non capisco proprio perché vada in loop
Primo: per rispetto verso chi deve leggere (ma anche per sè stessi per non incasinarsi con le parentesi), il codice va indentato correttamente (almeno usare la funzione formattazione automatica dal menu strumenti). Poi meglio ancora sarebbe indentare a mano di 4 spazi invece che due che è ancora più chiaro, ma pazienza.
Secondo: Il problema nasce dal fatto che le istruzioni per l'avvio dell'audio vengono eseguite sempre ad ogni controllo in cui risulta assenza rete (quindi viene continuamante riavviato), mentre la loro esecuzione andrebbe effettuata una sola volta.
Basta impostare una variabile di stato (flag / indicatore) magari chiamata 'audio' per capire se lo abbiamo già fatto partire oppure no:
if (!audio) // se l'audio non e` gia` attivo
{
myDFPlayer.volume(30); // Set volume value. From 0 to 30
myDFPlayer.play(12); // Play the first mp3
audio = true; // segnalo audio attivato
}
Naturalmente quando ritorna rete il flag 'audio' lo rimettiamo a false:
if (StatoCorrente == HIGH)
{
digitalWrite(ledPinVerde, HIGH);
digitalWrite(ledPinRosso, LOW);
myDFPlayer.disableLoopAll();
audio = false;
}
Terzo: la variabile currentMillis non viene mai usata nel loop quindi inutile continuare ad aggiornarla con il valore di millis()
Quarto: Il lampeggio, che prevede un 'interval' di 300ms, è scritto all'interno del controllo che ha 'interval2' 500ms, quindi il lampeggio avrà anche lui la durata di 500ms e l'uso di 'interval' è inutile.
Quinto: in generale scrivere funzioni brevi invece di una sola lunghissima, facilita la comprensione e non ci si perde tra le parentesi, ad esempio la loop potrebbe limitarsi a:
void loop()
{
if (millis() - previousMills2 > interval2 )
{
previousMills2 = millis();
controllaCorrente();
}
}
La controllaCorrente potrebbe essere:
void controllaCorrente()
{
byte StatoCorrente = digitalRead(corrente);
Serial.println(StatoCorrente);
if (StatoCorrente == HIGH)
{
digitalWrite(ledPinVerde, HIGH);
digitalWrite(ledPinRosso, LOW);
fermaAudio();
}
else
{
digitalWrite(ledPinVerde, LOW);
avviaAudio();
lampeggia();
}
}
e così via, con solo uno o due if in ogni funzione.
Sesto: per la scarica dell'alimentatore basta una resistenza 220 Ω tra ingresso e massa, magari da mezzo watt. Questo fa assorbire 20mA come se ci fosse un LED, ma senza la caduta di tensione introdotta dal LED per cui l'ingresso arriva a zero più velocemente. L'energia consumata è quella di un LED, 1kWh all'anno.
Claudio_FF:
Primo: ... Poi meglio ancora sarebbe indentare a mano di 4 spazi invece che due che è ancora più chiaro, ma pazienza.
... per questo la soluzione c'è:
Nella cartella Arduino, sottocatrella lib, file formatter.conf, linea 11, modifichi il 2 nel valore che desideri ed il gioco è fatto
Ah, dopo aver modificato e salvato il file, occorre rilanciare l'IDE altrimenti NON vede la modifica.
Il perché poi questo valore NON sia nel file di configurazione dell'IDE (come l'espansione dei tab), ma in un file separato, rendendo complicata la cosa e costringendo l'utente a modificare DUE files ogni volta ... resta un mistero :
Guglielmo
Oooo, questo si che è bello ;D
Su Ubuntu si trova nel file: [color=blue]~/.arduino/preferences.txt[/color]
alla voce: [color=blue]editor.tabs.size[/color]
Claudio_FF:
Su Ubuntu si trova nel file:[color=blue]~/.arduino/preferences.txt[/color]
alla voce:[color=blue]editor.tabs.size[/color]
NO, quello è il tabs size (... presente su tutte le piattaforme) che NON ha nulla a che vedere con l'autoformattazione che è regolata dal parametro che ti ho detto.
Avevo segnalato la cosa se leggi bene ...
Guglielmo
Avevo letto dei due file, ma nel mio caso è bastata la modifica di editor.tabs.size e si è adattata anche l'auto formattazione.
Potrebbe essere una versione antiquata dell' IDE?
Non so bene come interpretare quel titolo, è la 1.0.5?
Claudio_FF:
Potrebbe essere una versione antiquata dell' IDE?
Non so bene come interpretare quel titolo, è la 1.0.5?
Mmm ... ho idea di SI ...
Perché non installi l'ultima versione (1.8.5) ? ... al limite in "portable mode" ... così rimane comunque separata da tutto il resto 
Guglielmo
gpb01:
NO, quello è il tabs size (... presente su tutte le piattaforme) che NON ha nulla a che vedere con l'autoformattazione che è regolata dal parametro che ti ho detto.Avevo segnalato la cosa se leggi bene ...
Guglielmo
credo di aver capito perchè sono due file di configurazione
il primo, quello nella cartella ~/.arduino.../preferences.txt serve all'editor (banalità direte voi)
il secondo quello citato da Guglielmo, serve al formatter, che è eseguibile separato e che viene solo richiamato dallo editor, viene eseguito dal SO e poi l'editor ne riceve il risultato
insomma, si tratta di un prodotto SW differente e differente è la sua configurazione
Scusate ritornando in argomento, e ho notato il problema che ci sono due mills tra cui uno nell’altro quindi inutile.
quindi come posso creare due mils diversi che lavorano in due tempi differenti?
Quindi dividere i gruppi