Ragazzi,
devo collegare una striscia led ad arduino.
Alimenterò la striscia led con un alimentatore esterno, come posso farsì che la striscia si accenda e spenga insieme all'arduino che sarà collegato ad un PC?
Grazie
questo schema, dite che va bene per far spegnere/accendere la striscia led insieme ad arduino?
Se Arduino è collegato al PC via USB, si accende/spegne con il PC 
Perché devi tenere collegato Arduino al PC ??
ciao
beh io utilizzerei un transistor (dimensionato alla striscia) e la base la collegherei, con opportuna resistenza, ai 5V di arduino, così che se accendi arduino il tranistor satura, contrariamente da quando è spento 
se non vuoi usare un transistor anche un banale relè con bobina a 5V va bene
MD
voglio fare un sistema ambilight con arduino ecco perchè devo tenerlo collegato al PC.
ma così come è fatto quel circuito, non blocca l'alimentazione della striscia led a seconda se arduino è alimentato o no da usb?
la terra dovrebbe fare questo gioco o no? ci serve per forza il relè?
Cominciamo con il dire che, dal tuo disegno, si capisce che stai usando una strip LED di quelle indirizzabili (WS2812 o simili) la quale, una volta ricevuto il comando per una certa "colorazione" dei LED, la mantiene sino a nuovo comando ...
... poi, hai poco chiaro il concetto di GND ... è SOLO un "riferimento" comune e non utilizzabile come pensi di usarla tu; oltretutto i WS2812 sono delicatissimi e, se per caso gli arriva qualche cosa sul pin di comando quando o manca l'alimentazione o altro ... si bruciano facilmente ...
... quindi, la soluzione migliore è TOGLIERE fisicamente i 5V alla strip-led quando Arduino non è alimentato e dargli i 5V (quindi alimentarla) PRIMA di cominciare ad inviare dati sul pin di controllo sul quale comunque, in serie, metterei una resistenza da 470Ω a protezione.
Puoi fare questo sia con un semplice MOSFET sia, come ti è stato indicato con un relè (... ma io preferisco la strada del MOSFET) ... vedi tu ...
Guglielmo
gpb01:
Cominciamo con il dire che, dal tuo disegno, si capisce che stai usando una strip LED di quelle indirizzabili (WS2812 o simili) la quale, una volta ricevuto il comando per una certa "colorazione" dei LED, la mantiene sino a nuovo comando ...... poi, hai poco chiaro il concetto di GND ... è SOLO un "riferimento" comune e non utilizzabile come pensi di usarla tu; oltretutto i WS2812 sono delicatissimi e, se per caso gli arriva qualche cosa sul pin di comando quando o manca l'alimentazione o altro ... si bruciano facilmente ...
... quindi, la soluzione migliore è TOGLIERE fisicamente i 5V alla strip-led quando Arduino non è alimentato e dargli i 5V (quindi alimentarla) PRIMA di cominciare ad inviare dati sul pin di controllo sul quale comunque, in serie, metterei una resistenza da 470Ω a protezione.
Puoi fare questo sia con un semplice MOSFET sia, come ti è stato indicato con un relè (... ma io preferisco la strada del MOSFET) ... vedi tu ...
Guglielmo
grazie Guglielmo, sono un programmatore ma non ci capisco quasi niente di elettronica e di elettrica.
apprezzo molto il tuo aiuto.
puoi dirmi a grandi linee perchè preferisci il MOSFET al relè?
dove dovrei mettere il MOSFET per farsì che la striscia led si accenda insieme all'arduino all'accendersi del PC?
grazie mille.
Preferisco i mosfet perché sono componenti a stato solido, più veloci ed affidabili di componenti meccanici come i relè. Inoltre, per comandare un relè con Arduino, comunque ti occorrerebbe o un trasistor o un mosfet e allora ... 
All'accensione di Arduno (quando lo colleghi al PC), prima di inizializzare la striscia, dai un segnale su un pin, attivi il MOSFET ed alimenti la striscia. A quel punto, magari dopo un breve delay(), puoi inizializzare la striscia e avviare le luci 
Guglielmo
gpb01:
Preferisco i mosfet perché sono componenti a stato solido, più veloci ed affidabili di componenti meccanici come i relè. Inoltre, per comandare un relè con Arduino, comunque ti occorrerebbe o un trasistor o un mosfet e allora ...All'accensione di Arduno (quando lo colleghi al PC), prima di inizializzare la striscia, dai un segnale su un pin, attivi il MOSFET ed alimenti la striscia. A quel punto, magari dopo un breve delay(), puoi inizializzare la striscia e avviare le luci
Guglielmo
mi stai indicando la strada ma sono ancora troppo inesperto per capire a pieno cosa mi stai dicendo...
continuo i miei studi, grazie per avermi indicato la strada...
se nel frattempo hai tempo e voglia di darmi qualche altro suggerimento sono qui
dove si metterebbe il mosfet nel circuito che ho in mente (nel frattempo grazie al tuo consiglio ho aggiunto la resistenza)?
come faccio a dare il segnale sul pin per attivare il mosfet all'accensione del PC (e quindi di arduino)
Io stacchere il +5V dalla strip-LED, quindi metteri un mosfet a canale P pilotato con un pin digitale di Arduino (pin HIGH mosfet non coduce, strip spenta, pin LOW mosfet conduce, strip accesa) in serie ... Source al +5V, Drain alla strip e Gate, con una resistenza da 470Ω ad un pin digitale di Arduno e con una resistenza da 10KΩ al +5V.
Occorre solo scegliere il giusto mosfet ... ad esempio, in versione SOT-3, io uso, per queste cose (fino a 700-800 mA), il FDN340P, ma altri mosfet, purché "logic-level" ed in grado di pilotare la corrente che ti serve, vanno bene.
Guglielmo
Che ne dici di fare uno schemino elettrico come quello che ho postato? So che richiede tempo ma magari potrebbe essere utile anche agli altri
Grazie di tutto
gpb01:
Una cosa così ...
Guglielmo
grazie mille, apprezzo molto
c'è chi dice che con il giusto programmino per arduino si può accendere e spegnere la striscia led 3 pin senza mosfet, semplicemente pilotandola con il terzo pin... vi torna? se fosse vero non servirebbe il mosfet.
Accendere e spegnere nel senso di togliere l'alimentazione (come serve a te)? Impossibile, un pin NON è in grado di dare l'alimentazione alla striscia.
Certo che, se tu sai quando toglierai l'alimentazione ad Arduino, glie lo comunichi in qualche modo (es. un bottone), da software, comandi tutti i led della striscia a spento (RGB = 0,0,0) e solo dopo spegni Arduino ovvio che, come detto, quelli pur restando alimentati, sono spenti ... ma:
La strscia è sempre alimentata, sono solo i led, ai quali devi aver dato colore (0, 0, 0), ovvero tutti e tre i colori a 0, ad essere spenti.
Devi poter indicare ad Arduino quando lo spegnerai e lui dovrà impostare tutti i led come da punto 1.
... non è però questo quello che tu hai chiesto all'inizio!
Guglielmo
gpb01:
Accendere e spegnere nel senso di togliere l'alimentazione (come serve a te)? Impossibile, un pin NON è in grado di dare l'alimentazione alla striscia.Certo che, se tu sai quando toglierai l'alimentazione ad Arduino, glie lo comunichi in qualche modo (es. un bottone), da software, comandi tutti i led della striscia a spento (RGB = 0,0,0) e solo dopo spegni Arduino ovvio che, come detto, quelli pur restando alimentati, sono spenti ... ma:
La strscia è sempre alimentata, sono solo i led, ai quali devi aver dato colore (0, 0, 0), ovvero tutti e tre i colori a 0, ad essere spenti.
Devi poter indicare ad Arduino quando lo spegnerai e lui dovrà impostare tutti i led come da punto 1.
... non è però questo quello che tu hai chiesto all'inizio!
Guglielmo
Ciao Guglielmo, scusami se non sono preciso nelle richieste ma sto cercando di capirci qualcosa e forse devo fare un passo indietro alle basi.
Mi hai fornito tutti gli spunti di studio necessari, partirô dai tuoi suggerimenti.
Alla fine a me andrebbe bene anche di spegnere i led via Arduino, anche se la striscia rimane alimentata i led sarebbero spenti. Vedi un problema in questo approccio che mi sembra più facile e senza MOSFET?
Grazie per la pazienza
sblantipodi:
Alla fine a me andrebbe bene anche di spegnere i led via Arduino, anche se la striscia rimane alimentata i led sarebbero spenti. Vedi un problema in questo approccio che mi sembra più facile e senza MOSFET?
... sei tu che devi decidere ... se ti sta bene, ogni volta, prima di spegnere Arduino, pigiare un bottone per spegnere i LED, va bene, se invece a te NON interessa o disturba e vuoi solo prendere e spegnere senza dover fare altro, allora ti tocca usare un qualche cosa che toglie fisicamnete l'alimentazione alla striscia.
Guglielmo
gpb01:
... sei tu che devi decidere ... se ti sta bene, ogni volta, prima di spegnere Arduino, pigiare un bottone per spegnere i LED, va bene, se invece a te NON interessa o disturba e vuoi solo prendere e spegnere senza dover fare altro, allora ti tocca usare un qualche cosa che toglie fisicamnete l'alimentazione alla striscia.Guglielmo
in realtà io userei uno sketch come questo che dovrebbe già gestire lo spegnimento dei led con un timeout
// Slightly modified Adalight protocol implementation that uses FastLED
// library (http://fastled.io) for driving WS2811/WS2812 led stripe
// Was tested only with Prismatik software from Lightpack project (version 5.9.1, 5.9.6 and 5.11.1 so far - 5.11.1 has some issues on startup in windows so I'm not using it)
#include "FastLED.h"
#define NUM_LEDS 44 // Max LED count
#define LED_PIN 11 // arduino output pin - probably not required for WS2801
#define GROUND_PIN 10 // probably not required for WS2801
#define BRIGHTNESS 64 // maximum brightness
#define SPEED 115200 // virtual serial port speed, must be the same in boblight_config
CRGB leds[NUM_LEDS];
uint8_t * ledsRaw = (uint8_t *)leds;
// A 'magic word' (along with LED count & checksum) precedes each block
// of LED data; this assists the microcontroller in syncing up with the
// host-side software and properly issuing the latch (host I/O is
// likely buffered, making usleep() unreliable for latch). You may see
// an initial glitchy frame or two until the two come into alignment.
// The magic word can be whatever sequence you like, but each character
// should be unique, and frequent pixel values like 0 and 255 are
// avoided -- fewer false positives. The host software will need to
// generate a compatible header: immediately following the magic word
// are three bytes: a 16-bit count of the number of LEDs (high byte
// first) followed by a simple checksum value (high byte XOR low byte
// XOR 0x55). LED data follows, 3 bytes per LED, in order R, G, B,
// where 0 = off and 255 = max brightness.
static const uint8_t magic[] = {'A', 'd', 'a'};
#define MAGICSIZE sizeof(magic)
#define HEADERSIZE (MAGICSIZE + 3)
#define MODE_HEADER 0
#define MODE_DATA 2
// If no serial data is received for a while, the LEDs are shut off
// automatically. This avoids the annoying "stuck pixel" look when
// quitting LED display programs on the host computer.
static const unsigned long serialTimeout = 150000; // 150 seconds
void setup()
{
// pinMode(GROUND_PIN, OUTPUT);
// digitalWrite(GROUND_PIN, LOW);
// FastLED.addLeds<WS2811, LED_PIN, BRG>(leds, NUM_LEDS);
FastLED.addLeds<WS2801, 11, 13, RGB>(leds, NUM_LEDS);
// Dirty trick: the circular buffer for serial data is 256 bytes,
// and the "in" and "out" indices are unsigned 8-bit types -- this
// much simplifies the cases where in/out need to "wrap around" the
// beginning/end of the buffer. Otherwise there'd be a ton of bit-
// masking and/or conditional code every time one of these indices
// needs to change, slowing things down tremendously.
uint8_t
buffer[256],
indexIn = 0,
indexOut = 0,
mode = MODE_HEADER,
hi, lo, chk, i, spiFlag;
int16_t
bytesBuffered = 0,
hold = 0,
c;
int32_t
bytesRemaining;
unsigned long
startTime,
lastByteTime,
lastAckTime,
t;
int32_t outPos = 0;
Serial.begin(SPEED); // Teensy/32u4 disregards baud rate; is OK!
Serial.print("Ada\n"); // Send ACK string to host
startTime = micros();
lastByteTime = lastAckTime = millis();
// loop() is avoided as even that small bit of function overhead
// has a measurable impact on this code's overall throughput.
for (;;) {
// Implementation is a simple finite-state machine.
// Regardless of mode, check for serial input each time:
t = millis();
if ((bytesBuffered < 256) && ((c = Serial.read()) >= 0)) {
buffer[indexIn++] = c;
bytesBuffered++;
lastByteTime = lastAckTime = t; // Reset timeout counters
} else {
// No data received. If this persists, send an ACK packet
// to host once every second to alert it to our presence.
if ((t - lastAckTime) > 1000) {
Serial.print("Ada\n"); // Send ACK string to host
lastAckTime = t; // Reset counter
}
// If no data received for an extended time, turn off all LEDs.
if ((t - lastByteTime) > serialTimeout) {
memset(leds, 0, NUM_LEDS * sizeof(struct CRGB)); //filling Led array by zeroes
FastLED.show();
lastByteTime = t; // Reset counter
}
}
switch (mode) {
case MODE_HEADER:
// In header-seeking mode. Is there enough data to check?
if (bytesBuffered >= HEADERSIZE) {
// Indeed. Check for a 'magic word' match.
for (i = 0; (i < MAGICSIZE) && (buffer[indexOut++] == magic[i++]););
if (i == MAGICSIZE) {
// Magic word matches. Now how about the checksum?
hi = buffer[indexOut++];
lo = buffer[indexOut++];
chk = buffer[indexOut++];
if (chk == (hi ^ lo ^ 0x55)) {
// Checksum looks valid. Get 16-bit LED count, add 1
// (# LEDs is always > 0) and multiply by 3 for R,G,B.
bytesRemaining = 3L * (256L * (long)hi + (long)lo + 1L);
bytesBuffered -= 3;
outPos = 0;
memset(leds, 0, NUM_LEDS * sizeof(struct CRGB));
mode = MODE_DATA; // Proceed to latch wait mode
} else {
// Checksum didn't match; search resumes after magic word.
indexOut -= 3; // Rewind
}
} // else no header match. Resume at first mismatched byte.
bytesBuffered -= i;
}
break;
case MODE_DATA:
if (bytesRemaining > 0) {
if (bytesBuffered > 0) {
if (outPos < sizeof(leds))
ledsRaw[outPos++] = buffer[indexOut++]; // Issue next byte
bytesBuffered--;
bytesRemaining--;
}
// If serial buffer is threatening to underrun, start
// introducing progressively longer pauses to allow more
// data to arrive (up to a point).
} else {
// End of data -- issue latch:
startTime = micros();
mode = MODE_HEADER; // Begin next header search
FastLED.show();
}
} // end switch
} // end for(;;)
}
void loop()
{
// Not used. See note in setup() function.
}