Tutti noi possediamo nei nostri laboratori (o presunti tali) un quantitativo enorme di componenti elettronici di vario genere. Resistenze, condensatori, transistor e integrati. Mentre per le prime tre categorie il test del componente (magari di recupero) è abbastanza semplice…riguardo gli integrati la cosa si complica. Di solito si fa prima a comprarlo nuovo che a cercare il funzionamento su internet e capire come dovrebbe rispondere in base all’impulso dato.

Dovendo riparare una scheda non funzionante contenente una miriade di integrati TTL ho cercato su internet qualche circuito che potesse testare la maggior parte dei componenti…per evitare di ricomprare il tutto.

Sul famoso sito di aste online….trovo questo aggeggio

Circuito stampano nudo e crudo…alloggiamento per 1 pila AAA (ministilo) , un display a 7 segmenti , un pulsante e uno zoccolo ZIF. Totale 22 euro…ovviamente dalla CINA

Dalla descrizione sembra testare tutto…o quasi Si va dal semplice led, a tutta la serie TTL . Ci penso un po e poi lo compro!

Passati i soliti 15gg arriva a casa in un busta. Zero istruzioni…..metto una pila e scendo in laboratorio.

Non sto qui a dilungarmi….guardatevi il video

I primi 2 integrati sono funzionanti e vengono letti con la propria sigla….l’ultimo e’ bruciato e viene letto con la sigla ERR.

Appena possibile sperimento “l’aggeggio” con altri componenti…vediamo fino a dove arriva

In questi giorni mi sto dilettando a rimettere in sesto un vecchio Apple IIe. Lavorare con questi computer (anno 1982) vuol dire ricominciare a parlare di Eprom (Erasable Programmable Read Only Memory) e quindi riaprire vecchi scatoloni impolverati con tanto materiale elettronico di recupero.

Tra le tante problematiche incontrate (farò un articolo a parte con tutta la storia) ho perso molto tempo con il recupero di una scheda seriale (Super Serial Card II). Tale interfaccia una volta installata nel computer risultava non funzionante e la eprom presente a bordo iniziava a scaldare come un fornetto.

Super Serial Card II Apple

Dopo un breve controllo al circuito e agli integrati TTL presenti arrivo alla conclusione che l’unico componente non funzionante sarebbe stato l’eprom!
Per essere più sicuro rispolvero il mio vecchio programmatore e tento di leggere la 2716 presente su questa seriale. Effettivamente presentava dati stranissimi e ripetuti…e una volta cancellata non si riusciva a riprogrammarla! Il posto giusto non e’ piu lo zoccolo del circuito stampato…ma il cestino del laboratorio
Si deve rifare l’eprom!!
Il bello del mondo Apple (anni 80) e’ che su internet si trova di tutto….anche le immagini delle rom! Basta usare google…o andare direttamente sui siti contenenti gli archivi piu conosciuti e si trova il file immagine.
Ora pero’ viene il bello….mi serve una Eprom M2716! Inutile passare dai rivenditori di elettronica della mia città…e’ materiale troppo datato. Non volevo ricorrere nemmeno ad acquisti online per non dover comprare un oggetto che costa meno delle spese di spedizione…

Nel mio laboratorio avevo delle 2732 che hanno piedinatura compatibile ma capacità doppia rispetto alle 2716. Non pensiate sia come le pennette USB odierne…qui e’ tutta questione di indirizzi e inizio lettura.

Ovvero…non basta avere spazio e piedinatura compatibile. Se avessi messo il file direttamente sulla eprom, si sarebbe posizionato in un area che non sarebbe stata letta dal computer….e quindi non avrebbe funzionato.

Cerco, mi documento, contatto amici….le competenze si perdono e si spazia dal consiglio di mettere a massa un piedino per forzare la lettura da uno specifico indirizzo a chi mi consiglia di usare un editor per duplicare il codice.

Alla fine imbatto in un forum americano frequentato da riparatori di vecchi flipper….sapete come risolvono un problema??? con un semplice comando DOS!

Ipotizziamo che il file della nostra eprom si chiami “2716.bin”…

con il semplice comando COPY lo sommano ad un altro file uguale…e lo caricano sulla 2732!

Più precisamente :

COPY /B 2716.BIN+2716.BIN 2732.BIN

quindi con il parametro /B che copia file in modo binario si ha un file composto dalla somma dei due file identici. Quindi se il sistema va a leggere nel primo o nel secondo banco di memoria…trova sempre lo stesso file!

Un po scettico…creo il file…lo carico sulla eprom….monto il tutto…eeeee….VAAAIIII … funzionaaa!!

2732 montata al posto della 2716

La super serial card ricominicia a funzionare!!

Apple SSC funzionante!

Divertitevi

Parto da lontano….ma se avrete la pazienza di leggere…questo articolo potrebbe risultare divertente (…oltre che istruttivo).

Un pomeriggio scendo nel garage dei miei suoceri per cercare degli oggetti … e sotto un cumulo di macerie…trovo un Apple IIe impolvetato e malconcio. Non mi dilungo con tutta la storia del recupero (di cui prometto farò un altro articolo) e in breve vi dico che lo porto a casa e cerco di salvarlo. La scheda madre e’ malconcia e alcuni chip sono fuori uso.

Nonostante la mia passione in campo elettronico nasce circa 20 anni fa….la strumentazione in mio possesso non supera qualche tester e qualche alta apparecchiatura autocostruita. Riparare un computer con un tester…non e’ cosa facile….e tutti nel cercare di darmi una mano mi chiedono “hai una sonda logica????” oppure “hai un oscilloscopio???”.

Alla mia risposta negativa….tutti alzano le mani….non riuscendo a darmi altri consigli se non quelli riguardanti in controllo delle tensioni o di componenti danneggiati!

Inutile dire che la notte non dormo per il pensiero del povero Apple non funzionante….e quando sono al pc….passo ore su ebay per trovare qualche oscilloscopio a poco prezzo…

Decido di fare le cose per gradi….mi costruisco una sonda logica….

La sonda logica e’ costituita da un semplice puntale che analizza lo stato Alto o Basso (Uno o Zero) in determinati punti di un circuito da testare. Roba da pochi euro….

Passa del tempo e mi chiedo se non sia più sensato spendere soldi per un oscilloscopio….

Alla fine….lampo di genio….mi viene in mente una pagina di un manuale del mio programmatore PicKit2.

Cos’e’ il PicKit2 ???

Vi ricordate qualche anno fa…quando vedevate “a gratisss” la televisione satellitare?? Usavate un programmatore autocostrutito per scrivere i codici su un processore chiamato Pic ….più precisamente Pic16f84. Immagino che ricordandovi il momento…stiate ridendo

Ecco il PicKit2 e’ la versione ufficiale del programmatore … venduto direttamente dalla Microchip.

Pensate che costa solo 30 euro…si connette al pc via USB…e non sbaglia un colpo!

Mi viene in mente una pagina del manuale…con le parole Logic Tools.

Google mi aiuta…e dopo anni ritrovo la pagina del manuale….BINGOOOOOO!!!!

Questo splendido AGGEGGIO….oltre a programmare….viene utilizzato come strumento di debugging! Fa da Sonda Logica, da Iniettore di segnali e da Analizzatore/Oscilloscopio!!!!!!!

Attenzione….non dico di aver risparmiato 1000 euro di attrezzatura … ma di avere uno strumentino che ci da un’ottima base di partenza per analizzare i nostri circuiti.

Ecco come si presenta il Bus :

Bus PicKit2

VDD e GND sono da connettere all’alimentazione del circuito da controllare….. e 4,5 e 6 sono i 3 canali utilizzabili.

Connettiamo il tutto e apriamo il programma PicKit Programmer….andiamo su Tools…e poi Logic Tools.

Subito ci compare la funzione di Sonda Logica :

PicKit2 – Sonda Logica

Se premiamo Analyzer passiamo alla sezione Oscilloscopio (o quasi)…

PicKit2 – Oscilloscopio

Anche qui sono dovute le precisazioni….non si tratta di un vero e proprio oscilloscopio (anzi e’ molto lontano) ma più di un analizzatore di segnali. Sui 3 pin controlla lo stato logico e ne tira fuori un grafico nel quale e’ possibile studiare l’onda quadra. Ha una frequenza di campionamento che arriva a 1Mhz…niente male.

Volevo testare il tutto….o meglio vedere se quello che c’era scritto corrispondeva a verità.

A chi chiedo aiuto??? Al caro Arduino

Arduino – generatore onda quadra

Carico sopra il pluriusato programmino BLINK….e modifico i millisecondi della funzione delay da 1000 a 1.Verrà generato quindi un impulso ogni millisecondo …e quindi 1000 impulsi al secondo. Mi aspetto quindi di vedere un risultato di 1000Hz.

Arduino – Blink

Questo programma mi cambia lo stato logico da 0 a 1 nel piedino 13.
I collegamenti sono :

VDD ai +5v dell’arduino
GND al GND dell’arduino
Pin 6 al 13 di arduino

e faccio partire Arduino e analizzatore…..

Ecco cosa esce :

Software Pickit2

Con i tasti del mouse mi posiziono all’inizio e alla fine dell’onda quadra…..e sopra mi da il risultato ….1000Hz. Precisooo!!!!!!

Ora basta trovare un notebook da quattro soldi….metterlo nel nostro laboratorio….e BUON DIVERTIMENTO

Alla prossimaaaaa

Abbiamo acceso il led….abbiamo controllato la temperatura della stanza….vogliamo andare oltre???? Pubblichiamo il tutto su internet????
Qualche giorno fa un lettore mi chiede consigli per la realizzazione di una stazione meteo con Arduino e magari con una Raspberry per pubblicare il tutto su internet….
Facendo due conti mi sono reso conto che c’era troppa roba…basta solo l’arduino e rispondendo alla mail con qualche piccolo consiglio passo la palla al lettore.

Casualmente dopo un paio di giorni mi arriva una ethernet shield per arduino dalla Cina….quale migliore occasione per poter testare il funzionamento…se non quello di studiare il sistema per l’amico appassionato?

La temperatura la sappiamo leggere…..su internet ci sappiamo andare….mancava unire il tutto presentandolo con una grafica accattivante……magari sapendo quasi niente di programmazione web

Partiamo da zero…

L’ethernet shield e’ una schedina che si monta sopra arduino. Non c’e’ da saldare nulla…coincide con i piedini e si alimenta direttamente da arduino. Abbiamo un tasto reset e uno slot per una SD nel caso in cui volessimo fare data logging in locale. Installandola restano comunque liberi i piedini per la connessione con l’esterno (qualcuno e’ occupato per la connessione con la shield).

Ci collego sopra un LM35….sensore di temperatura identico a un comunissimo transistor con il case in plastica (BC237, 337….)

Le connessioni sono banali….ha 3 piedini….

1) +5v
2) v_out
3) GND

LM35 – connessioni pin

quindi colleghiamo direttamente 1 e 3 rispettivamente a +5v e GND di arduino…..e il 2 ad un ingresso analogico…io ho scelto il 2.

Fine connessioni….passiamo alla programmazione.

Anzi no….

Perché in questo caso il codice da dare in pasto ad arduino … ce lo da direttamente il sito su cui pubblicheremo i dati

Scopro l’esistenza di COSM.COM … un “raccoglitore di dati”….gratuito!

Ci si iscrive….si configura il tutto…e vediamo pubblicati (e utilizzabili) i nostri dati. Dal sito stesso poi possiamo prendere i dati in diversi formati e trasmetterli al nostro sito web personale. GRANDIOSO!!

Procediamo per passi….

Andiamo sulla home page ….. http://www.cosm.com e ci registriamo.

HomePage – www.cosm.com

Subito dopo ci permette di iniziare a creare  aggiungendo il nostro arduino…(ma anche altri device)

cosm.com – Aggiunta di un “device”

Scegliamo Arduino….riempiamo i 3 campi richiesti con i dati riguardanti il nostro progetto e alla fine ci viene generato il codice da programmare con le KEY riferite al nostro utente.
Il codice e’ creato in modo da leggere i dati provenienti dal pin 2 (analogico) ….e i dati sono riportati in modo grezzo…quindi da convertire per riportare un dato esatto (in questo caso la temperatura).

Ecco cosa il listato generato e già convertito alla riga 79 per ottenere la temperatura in gradi centigradi utilizzando l’LM35.

/**
 * Cosm Arduino sensor client example.
 *
 * This sketch demonstrates connecting an Arduino to Cosm (https://cosm.com),
 * using the new Arduino library to send and receive data.
 *
 * Requirements
 *   * Arduino with Ethernet shield or Arduino Ethernet (board must use the
 *     Wiznet Ethernet chipset)
 *   * Arduino software with version >= 1.0
 *   * An account at Cosm (https://cosm.com)
 *
 * Optional
 *   * An analog sensor connected to pin 2 (note we can still read a value from
 *     the pin without this)
 *
 * Created 8th January, 2013 using code written by Adrian McEwen with
 * modifications by Sam Mulube
 *
 * Full tutorial available here: https://cosm.com/docs/quickstart/arduino.html
 *
 * This code is in the public domain.
 */

#include <SPI.h>
#include <Ethernet.h>
#include <HttpClient.h>
#include <Cosm.h>

#define API_KEY " KEY FORNITA AUTOMATICAMENTE" // your Cosm API key
#define FEED_ID ID FORNITO AUTOMATICAMENTE // your Cosm feed ID

// MAC address for your Ethernet shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// Analog pin which we're monitoring (0 and 1 are used by the Ethernet shield)
int sensorPin = 2;

unsigned long lastConnectionTime = 0;                // last time we connected to Cosm
const unsigned long connectionInterval = 15000;      // delay between connecting to Cosm in milliseconds

// Initialize the Cosm library

// Define the string for our datastream ID
char sensorId[] = "sensor_reading";

CosmDatastream datastreams[] = {
  CosmDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT),
};

// Wrap the datastream into a feed
CosmFeed feed(FEED_ID, datastreams, 1 /* number of datastreams */);

EthernetClient client;
CosmClient cosmclient(client);

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);

  Serial.println("Cosm Sensor Client Example");
  Serial.println("==========================");

  Serial.println("Initializing network");
  while (Ethernet.begin(mac) != 1) {
    Serial.println("Error getting IP address via DHCP, trying again...");
    delay(15000);
  }

  Serial.println("Network initialized");
  Serial.println();
}

void loop() {
  // main program loop
  if (millis() - lastConnectionTime > connectionInterval) {
    // read a value from the pin
    int sensorValue = analogRead(sensorPin);
    sensorValue = (5.0 * sensorValue * 100.0)/1024.0; 
    // send it to Cosm
    sendData(sensorValue);
    // read the datastream back from Cosm
    getData();
    // update connection time so we wait before connecting again
    lastConnectionTime = millis();
  }
}

// send the supplied value to Cosm, printing some debug information as we go
void sendData(int sensorValue) {
  datastreams[0].setFloat(sensorValue);

  Serial.print("Read sensor value ");
  Serial.println(datastreams[0].getFloat());

  Serial.println("Uploading to Cosm");
  int ret = cosmclient.put(feed, API_KEY);
  Serial.print("PUT return code: ");
  Serial.println(ret);

  Serial.println();
}

// get the value of the datastream from Cosm, printing out the value we received
void getData() {
  Serial.println("Reading data from Cosm");

  int ret = cosmclient.get(feed, API_KEY);
  Serial.print("GET return code: ");
  Serial.println(ret);

  if (ret > 0) {
    Serial.print("Datastream is: ");
    Serial.println(feed[0]);

    Serial.print("Sensor value is: ");
    Serial.println(feed[0].getFloat());
  }

  Serial.println();
}

Noterete che sono richieste delle librerie particolari…..andate nella sezione SUPPORT/API e trovate il tutto.

Una volta programmato il tutto il sito vi riporta nella configurazione dei dati ricevuti….

cosm.com – configurazione dati

In questo caso ho configurato solamente Unit e Symbol….e poi premete in basso Save!

Abbiamo finito!!!!!

Non resta altro che collegare arduino alla nostra rete e dare corrente…..automaticamente riceverà un indirizzo IP sfruttando il DHCP e inizierà a inviare i dati al sito …

questi erano i dati relativi alla temperatura di una mia stanza..

cosm.com – dati analizzati

Semplice no???

Noterete che sotto la temperatura ci sono le scritte JSON… XML…CSV….i dati stessi possono essere esportati e utilizzati in tempo reale nei vostri siti … o nei vostri progetti…il tutto A GRATISSEEEE

Inutile dire che si possono analizzare più sensori presenti su arduino e che il sito non funziona solo in ricezione/pubblicazione ma anche in trasmissione….

E’ possibile inviare dati all’arduino e permettere che reagisca di conseguenza….

Si possono creare App da utilizzare nei nostri siti o nei nostri smartphone…..ma questa e’ un’altra storia….che troverete tra un po in queste pagine

Ciaooo

Mi hanno invitato ad una festa in maschera per carnevale….
Nasce subito il dubbio su come vestirsi….e visto che il tema della serata erano i FILMS….ho pensato subito ad uno dei miei preferiti : Ritorno al Futuro!

Molto difficile travestirsi da Doc…meglio puntare su Marty McFly interpretato da Micheal J. Fox.

L’abbigliamento era abbastanza semplice….un paio di jeans…piumino rosso e una camicia a quadretti….ma per non lasciare dubbi servivano degli oggetti che rendessero inconfondibile il tutto.

Flusso Canalizzatore e Skateboard della Mattel….

Li cerco in rete….e i costi superano il centinaio di dollari…ci penso un po e poi si scende in garage! Facciamo tutto da soli!

Dovevo creare una qualcosa che assomigliasse a questo :

Flusso canalizzatore – Ritorno al Futuro

Inizio a rovistare ….e accendo il saldatore…

Prendo una normalissima cassetta di derivazione per impianti elettrici :

Cassetta di derivazione

pratico un buco ovale sul coperchio frontale e con una bomboletta di vernice grigia inizio a rendere il tutto di color metallo.

Non volevo spendere molti soldi e quindi mi sono munito di pezzi di cartone rigido, tubi traparenti, pezzi di plastica varia e molta colla vinilica.

Si doveva creare anche un effetto luci e cercando in rete progetti similari, molti hanno usato Arduino per animare i led. Non volevo scomodare un processore così potente per fare un qualcosa di così semplice e quindi mi sono affidato ad un Pic 12f675. 1 euro di microprocessore.

Butto giù uno schema :

Schema elettrico Flusso Canalizzaotre

…e inizio a scrivere un paio di righe di codice per ricreare un’animazione piu o meno similare.

#define PIC_CLK 4000000
#define _LEGACY_HEADERS
#include <pic.h>
#include <stdlib.h>
#include "delay.c"
#define LED GPIO0
#define LEDD GPIO1
#define LEDDD GPIO2
__CONFIG (INTIO & WDTEN & PWRTEN & MCLRDIS & BOREN);

int main (int)
{
ANSEL = 0b00000000;
CMCON = 7;
VRCON = 0;
WPU = 0;
IOCB = 0;
TRISIO = 0;

while(1)
{
LED = 1;
DelayMs(50);
LED = 0;
LEDD = 1;
DelayMs(50);
LEDD = 0;
LEDDD = 1;
DelayMs(50);
LEDDD = 0;
DelayMs(375);
}
}

Alimentazione fornita da una semplice batteria a bottone da 3volt (CR 2032) e poichè in laboratorio non avevo led ad alta efficenza …. mi sono affidato a semplici led gialli.

Il tutto montato in aria….niente circuito stampato.

Pic 12f675 con batteria e interruttore. Tutto montato in aria

Connessione led installati su foglio di cartone

Vista interna e connessioni

Vista senza coperchio

Non sto qui a descrivere ogni singolo pezzo montato e incollato. Lasciate spazio alla vostra fantasia e cercate di adattare ciò che trovate in casa.

Il risultato finale e’ stato questo :

Simpatico no???

Infine per poter completare il tutto ho creato anche lo Skateboard volante della Mattel….

Skateboard Mattel – Back to the future

Ma, come vedete dalla foto non sto nemmeno a dirvi come l’ho fatto!

Al prossimo carnevaleee……

“Grande Giove” (cit. Doc Brown)

Quando ancora il mondo Apple era per pochi utenti….quando ancora non si parlava di iPhone…iPod…iPad…quando ancora vi divertivate con le schermate blu di Windows95 (..hhihi…)….la Apple Computer…sfornava computer come quello che vedere in foto.

Si tratta di un Apple Performa 460. Un design che ancora fa impallidire molti produttori di computer…chiamato “cartone della pizza” per il basso profilo e la compattezza. Stiamo parlando di 1993!!!!!

Già ai tempi Apple si distingueva per pulizia nelle linee…niente fronzoli…e pochi cavi. Non considerate tutto quel groviglio di fili che vedete in foto (fanno parte del mio tavolo degli esperimenti). Le connessioni sono semplicemente tra computer e monitor…e tra computer e tastiera…che poi replica la connessione al mouse! In tutto 3 cavi (video,alimentazione e tastiera).

Volete sapere cosa ha passato questo computer…e come se ne è uscito vincitore??

Una decina di anni fa, presso una mercatino dell’elettronica, trovai questo computer sotto una pila di monitor usati. Insieme al venditore spostammo tutti i monitor e recuperammo il malcapitato. Alla domanda ..”Funziona???”… il venditore rispose semplicemente alzando le spalle!

10 euro e il piccolo trova posto nel cofano della mia macchina corredato di tastiera e mouse.

Arrivato in laboratorio, prima di accenderlo, lo apro per vedere com’era ridotto il suo interno e contemporaneamente mi rendo conto delle caratteristiche tecniche.

Processore : Motorola 68030 senza coprocessore matematico
Ram : 4Mb
Hard Disk : 80Mb SCSI

Tutto il resto era polvere e terra….chi sa dov’era conservato….o da dove e’ stato recuperato. Mi armo di compressore e pennello e inizio l’operazione di pulizia.

A fine lavoro volevo accendere il tutto…ma il connettore video dei vecchi Apple non sono come i nostri VGA. Una breve ricerca con il nostro caro Google e trovo lo schema per un adattatore.

Saldo, richiudo e connetto….pronti per dare corrente.

Incrocio le dita…e premo il tasto di accensione. Le mie orecchie sentono il famoso DAAAAAHHHHH. Il Performa e’ vivo!!!

Incredibile dopo 10 anni …e tanta polvere…funziona!! Parte con un vecchio MacOS 7.5 e qualche programma installato….chi sa chi lo utilizzava prima???

Spengo il tutto e riapro. Procediamo all’ upgrade.

Rovisto un po nel mio garage….cerco un po su Ebay…e aumento la ram a 32Mb e il disco a 1Gb. Mi procuro un MacOS 8 e procedo all’installazione.

Soddisfazioni….funziona tutto.

Ci gioco qualche settimana….e poi lo poso in uno scaffale.

In quello scaffale ci e’ rimasto fino a circa 1 anno fa….quando un violento temporale…ha allagato il mio garage…e ha fatto fare un bel bagno al mio Performa!

Era totalmente sommerso nella melma. Lo apro…lo pulisco con l’aria compressa….ma i segni dell’acqua sono ancora evidenti.

Performa aperto – dopo allagamento

Apple Performa 460 – vista frontale

Alcune parti sono proprio arrugginite. Sconsolato lo  richiudo e lo lascio nello stesso scaffale (in un piano più alto e riparato) fino a ieri .

Avevo un po di tempo libero e ho pensato di provare ad accenderlo. Recupero tastiera, mouse, cavi, adattatori e connetto il tutto.

Siamo nel 2013…quindi la creatura ha ormai quasi 20 anni…e un’alluvione sulle spalle.

Monto….collego e premo il tasto di accensione ….ehhh

Funzionaaaa!!!!

Tutto ciò per farvi capire chi è Apple…o meglio chi era Apple…la qualità dei prodotti e la robustezza.

Dalle foto potete anche percepire che il design non e’ solo esterno .. ma anche interno.

Provate a fare lo stesso con un Pc…con Windows 95

In ogni “laboratorio dell’hobbysta” che si rispetti non può mancare un alimentatore. Diciamo che dopo il saldatore e’ la prima apparecchiatura da acquistare o costruire. Ce ne sono diversi modelli…con tensione fissa o variabile…con strumenti o no. Ricordo che da piccolo…essendo squattrinato…ho utilizzato per anni un semplice alimentatore a tensioni fisse da parete (stile caricabatterie del cellulare).

Con il tempo ci rendiamo conto che un alimentatore non basta mai…e che le tensioni usate alla fine sono sempre le stesse … 5 volt e 12 volt.

Volendolo comprare o costruire c’e’ sempre da spendere almeno 40-50 euro. Ma perché spendere soldi quando li abbiamo già pronti ogni giorno sotto i nostri occhi….anzi sotto le nostre dita?
Ebbene si … i computer che usiamo per leggere questo sito contengono un alimentatore silenziosissimo che ha come uscite proprio quelle che servono a noi…più precisa mente +3,3v +5v +12v e le negative -5v e -12v. Abbiamo anche troppo

Le tensioni positive arrivano anche a 20 Ampere e il tutto e’ protetto da cortocircuiti e sovratensioni!

Lo si trova in commercio per 15 euro….ma basta cercare un po in giro e qualche amico ne avrà qualcuno buttato in garage. Aggiungiamoci 3-4 euro di materiale e un’oretta di lavoro e abbiamo il nostro Alimentatore ATX da laboratorio.

Iniziamo…

Ecco come si presenta :

Cosi com’e’ … ci facciamo poco. Lo dobbiamo modificare…apriamolo a corrente sconnessa e tentiamo di capire qualcosa.

Alimentatore Atx – Interno

ATTENZIONE : E’ UN ALIMENTATORE SWITCHING CONTENENTE DEI CONDENSATORI CARICHI DI ALTA TENSIONE. UNA VOLTA TOLTA LA 220VOLT ATTENDERE QUALCHE MINUTO IN MODO DA FARLI SCARICARE!!!!

Noterete che ci sono molti cavi di colore simile…tagliamo i connettori e raggruppiamoli come segue :

Fili Arancioni : +3.3 Volt (da saldare insieme – molta corrente)
Fili Rossi : +5 Volt (da saldare insieme – molta corrente)
Fili Gialli : +12 Volt (da saldare insieme – molta corrente)

Fili Neri : 0 Volt – GND

Filo Blu : -12 Volt
Filo Bianco : -5 Volt

Filo Verde : PS-ON ( da portare a massa per accendere l’alimentatore)

Ecco una foto per chiarire il tutto :

Codifica Fili – Alimentatore ATX

Compriamo delle boccole in un negozio di elettronica e un interruttore da pannello…e iniziamo a montare il tutto…

Montaggio boccole e interruttore

Colleghiamo i vari fili alle boccole di riferimento e il filo verde con l’interruttore di mezzo verso massa (GND – Nero). Alcuni alimentatori vogliono “sentire” un carico connesso…quindi se non va…provate a connettere una resistenza da 10 Ohm/10 Watt tra i +5volt e la massa.

Ricontrollate la connessioni…e richiudete il tutto.

Alimentatore Finito

Io ho fatto una versione light…ma volendo lo potreste corredare di Amperometro e Voltmetro per monitorare il funzionamento. Come dicevo prima sulle tensioni positive arriva anche a 15-20 Ampere….mentre sulle negative non supera 1 Ampere.

Buon divertimento

Ho pensato di costruire un alberello decorativo ridotto all’osso! Una basetta millefori appositamente tagliata a forma di albero di Natale, una manciata di led colorati e un Arduino che fa da base e da processore!

Il circuito e’ semplicissimo….sfrutta le uscite in PWM (5,6,9,10,11) per gli effetti di FADE….e 4 pin normali per le accensioni alternate di  altre serie luminose.

Dai pins escono 5volt….ottimali per pilotare 2 led in serie….troppi per pilotarne uno solo. Quindi 2 led possono essere connessi in serie direttamente tra pin e GND, se usiamo invece un led mettiamo in serie al positivo una resistenza da 330 ohm 1/4 watt per limitare la corrente.

Ecco lo schema

Schema elettrico

E un paio di foto per farvi vedere il lavoro finito…

Albero – front

Albero – rear

Albero montato – rear

Il programma altro non e’ che una serie di combinazioni di giochi….cicli di FOR e DELAY …..potrete sbizzarrirvi con gli effetti più disparati.

long randNumber;
void setup() {
DDRB = B11111111;
DDRD = B11111100;
}
void loop()
{
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
analogWrite(11, fadeValue);
delay(30);
}
{
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
analogWrite(9, fadeValue);
delay(30);
} {
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
analogWrite(10, fadeValue);
delay(30);
} {
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
analogWrite(6, fadeValue);
delay(30);
} {
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
analogWrite(5, fadeValue);
delay(30);
}
for(int i = 0 ; i < 10; i++){
digitalWrite(12, HIGH);
delay(10);
digitalWrite(12, LOW);
delay(20);
digitalWrite(2, HIGH);
delay(10);
digitalWrite(2, LOW);
}
{
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(11, fadeValue);
delay(30);
}
{
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(9, fadeValue);
delay(30);
} {
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(10, fadeValue);
delay(30);
} {
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(6, fadeValue);
delay(30);
} {
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(5, fadeValue);
delay(30);
}
}
{
for(int e = 0 ; e < 10; e++){
digitalWrite(12, HIGH);
delay(10);
digitalWrite(12, LOW);
delay(20);
digitalWrite(2, HIGH);
delay(10);
digitalWrite(2, LOW);
}
for(int f = 0 ; f < 10; f++){
digitalWrite(7, HIGH);
delay(10);
digitalWrite(7, LOW);
delay(20);
digitalWrite(4, HIGH);
delay(10);
digitalWrite(4, LOW);
}
for(int k = 0 ; k < 30; k++){
PORTD= B11111100;
PORTB= B11111110;
delay(10);
PORTD= B00000000;
PORTB= B00000000;
delay(20);
PORTD= B01101100;
PORTB= B10110100;
delay(10);
PORTD= B00000000;
PORTB= B00000000;
}
for(int d = 0 ; d < 30; d++){
PORTD= B11111100;
PORTB= B11111100;
delay(40);
PORTD= B00000000;
PORTB= B00000000;
delay(60);
PORTD= B01101100;
PORTB= B10001011;
delay(40);
PORTD= B00000000;
PORTB= B00000000;
}
for(int w = 0 ; w < 30; w++){
PORTD= B11111100;
PORTB= B11111100;
delay(60);
PORTD= B00000000;
PORTB= B00000000;
delay(100);
PORTD= B01101100;
PORTB= B10001011;
delay(60);
PORTD= B00000000;
PORTB= B00000000;
}
PORTD= B00000000;
PORTB= B00000000;
delay(3000);
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(10, HIGH);
delay(1000);
digitalWrite(6, HIGH);
delay(1000);
digitalWrite(9, HIGH);
delay(1000);
digitalWrite(5, HIGH);
delay(1000);
digitalWrite(11, HIGH);
delay(4000);
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(11, fadeValue);
delay(10);
}
{
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(9, fadeValue);
delay(10);
} {
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(10, fadeValue);
delay(10);
} {
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(6, fadeValue);
delay(10);
} {
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(5, fadeValue);
delay(10);
}
delay(300);
PORTD= B00000000;
PORTB= B00000000;
delay(400);
for(int f = 0 ; f < 4; f++){
digitalWrite(7, HIGH);
delay(500);
digitalWrite(7, LOW);
delay(500);
digitalWrite(4, HIGH);
delay(500);
digitalWrite(4, LOW);
delay(500);
}
for(int f = 0 ; f < 2; f++){
digitalWrite(12, HIGH);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(10, HIGH);
delay(500);
digitalWrite(10, LOW);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(12, LOW);
delay(500);
}
{
for(int e = 0 ; e < 20; e++){
randNumber = random(2, 13);
digitalWrite(randNumber, HIGH);
delay(200);
}
{

for(int e = 0 ; e < 20; e++){
randNumber = random(2, 13);
digitalWrite(randNumber, LOW);
delay(200);
}
PORTD= B00000000;
PORTB= B00000000;
delay(1500);

for(int f = 0 ; f < 5; f++){
digitalWrite(10, HIGH);
delay(100);
digitalWrite(2, HIGH);
delay(100);
digitalWrite(6, HIGH);
digitalWrite(9, HIGH);
delay(100);
digitalWrite(7, HIGH);
digitalWrite(4, HIGH);
delay(100);
digitalWrite(5, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
delay(100);
digitalWrite(10, LOW);
delay(100);
digitalWrite(2, LOW);
delay(100);
digitalWrite(6, LOW);
digitalWrite(9, LOW);
delay(100);
digitalWrite(7, LOW);
digitalWrite(4, LOW);
delay(100);
digitalWrite(5, LOW);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
delay(100);

}

for(int f = 0 ; f < 5; f++){
digitalWrite(5, HIGH);
digitalWrite(11, HIGH);
digitalWrite(12, HIGH);
delay(100);
digitalWrite(7, HIGH);
digitalWrite(4, HIGH);
delay(100);
digitalWrite(6, HIGH);
digitalWrite(9, HIGH);
delay(100);
digitalWrite(2, HIGH);
delay(100);
digitalWrite(10, HIGH);
delay(100);
digitalWrite(5, LOW);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
delay(100);
digitalWrite(7, LOW);
digitalWrite(4, LOW);
delay(100);
digitalWrite(6, LOW);
digitalWrite(9, LOW);
delay(100);
digitalWrite(2, LOW);
delay(100);
digitalWrite(10, LOW);
delay(100);
}
delay(200);

}}}}}}}}}}}}}}}}

Consiglio di fare prima il circuito….provare le singole serie di led con un programmino semplice (anche il BLINK presente tra gli esempi di Arduino) e poi iniziare a pensare ai vari giochi di luce.

Ecco un video di ciò che ho realizzato :

BUONE FESTE

Da tempo ormai abbiamo imparato a smanettare con il nostro Arduino. Controlliamo apparecchiature complicatissime o accendiamo semplicemente un led. Siamo comunque sperimentatori…degli inventori….dei creativi….dei Makers

Il punto di forza di Arduino è come abbiamo detto molte volte…la semplicità…la praticità. Per far lampeggiare un led si impiegano pochi secondi….

Semplicità non vuol dire poca potenza…o giochi da bambini

Infatti … volendo … e’ possibile dialogare con il processore Atmega anche in maniera un po più diretta e “meno semplice”…il tutto per scoprire nuove funzioni e portare al massimo la CPU.

Se vogliamo accendere un led procediamo come segue:

settiamo il pin come output : pinMode(Pin, OUTPUT);
e poi portiamo il livello ALTO o BASSO con  : digitalWrite(Pin, HIGH);

magari se siamo più addentrati mettiamo un cliclo e facciamo lampeggiare il led alla velocità che decidiamo noi….

….e fin qui tutto ok!

Ma se vogliamo cambiare lo stato di 2 o più pin contemporaneamente????
Voi direte….metto 2 o più righe di digitalWrite.

Si ma……sono più righe di codice e comunque sono istruzioni separate…che il processore, per quanto veloce, fa una dopo l’altra.

Non mi piace….voglio un comando che in una riga mi cambia lo stato di tutte le uscite contemporaneamente!

E se si cerca…il comando c’e’ !!!

Vi mando alla pagina ufficiale….se ve la volete leggere tutta!

Se no ve la spiego io ….

Arduino ha 3 porte :

• B uscite digitali da 8 a 13
• C ingressi analogici
• D uscite digitali da 0 a 7

Iniziamo a parlare alla CPU a suoni di 1 e 0…..parliamo semplicemnte….1 e’ abilitato…0 disabilitato.

Voglio settare i pin da 1 a 7 come output e lo 0 come input in un unico comando?

Ecco come :
DDRD = B11111110;
Voglio settare i pin 7,5 e 3 come HIGH e tutti gli altri LOW….in un unico comendo???

Ecco :
PORTD = B10101000;

Notate che gli 1 sono in corrispondenza dei pin da settare…

Semplice no??????

I programmi creati saranno più snelli, corti….e di conseguenza occuperanno molto meno spazio nella preziosa e limitata memoria del nostro Arduino.

Il semplice programma per far lampeggiare il led che trovate tra gli esempi dell’IDE, opportunamente modificato per far lampeggiare 3 led contemporaneamente, occupa circa 1400 byte se scritto nel modo classico….e solo 600 byte se compilato usando questo metodo alternativo!

Buon Lavorooooo

Dopo qualche realizzazione pratica con Raspberry Pi, iniziamo a “smanettare” con Arduino.

Il progetto che andiamo a trattare riguarda un semplice termostato “di fortuna” realizzato in non più di 20 minuti utilizzando un Arduino, un display (compatibile HD44780) e un sensore di temperatura/umidità DHT11.

Avevo l’esigenza di accendere e spegnere una caldaia quando la temperatura ambientale scendeva sotto i 17 gradi…non volendo comprare un termostato nuovo…ho recuperato un display e ho cercato di visualizzare sopra tutti i dati rilevati.

Iniziamo con i collegamenti ….

Il display si collega così …

Connessione display LCD – arduino.cc

Il sensore si collega così …

Connessione sensore DHT11

Il relè per l’attivazione della caldaia va al pin 13….in questo progetto non e’ connesso perché e’ parte integrante dell’impianto di riscaldamento preesistente….testeremo il funzionamento con il led presente sulla scheda Arduino.

Prima di iniziare a scrivere il codice vi rimando a due pagine dove troverete le librerie per LCD e DHT11

Ecco il codice….realizzato scopiazzando tra i vari esempi già presenti nell’IDE di Arduino:

// carico le librerie
#include <LiquidCrystal.h>
#include "DHT.h"
// definisco il pin del sensore
#define DHTPIN 8
// definisco il tipo di sensore
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
// definisco a quali pin è connesso il display
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// definisco che il pin 13 è quello a cui è connesso il led
const int ledPin = 13;
void setup() {
// setto il tipo di display (colonne, righe)
lcd.begin(20, 2);
// scrivo sul display le parole fisse
lcd.print("Temperatura");
lcd.setCursor(0,1);
lcd.print("Umidita'");
lcd.setCursor(16,0);
lcd.print("Cald");
pinMode(ledPin, OUTPUT);
}
void loop() {
int t = dht.readTemperature();
int h = dht.readHumidity();
// posiziono il cursore alla colonna 12 e riga 0
lcd.setCursor(12, 0);
lcd.print(t);
lcd.setCursor(12, 1);
lcd.print(h);
// setto il limite di temperatura minore o uguale a 17 gradi
if (t <= 17) {
//
digitalWrite(ledPin, HIGH);
lcd.setCursor(16, 1);
lcd.print("Acc");
}
else {
// turn LED off:
digitalWrite(ledPin, LOW);
lcd.setCursor(16, 1);
lcd.print("Spe");
}
}

Tutto ciò che trovate dopo le // lo potete eliminare…sono solo commenti per farvi capire cosa succede in quel punto preciso del programma….

Una volta caricato il tutto….compariranno sul display temperatura e umidità dell’ambiente. Se la temperatura e’ inferiore o uguale a 17°C si accenderà il led…e quindi il relè ad esso connesso (tramite un transistor di potenza). Su display comparirà la scritta “Acc” che sta per Acceso.

Superati i 17°C il led si spegne e sul display compare la scritta “Spe”… che sta per spento!

Ecco un video…

Termostato con Arduino e DHT11 from danilo larizza on Vimeo.

Se volete aumentare o diminuire la temperatura di intervento basta modificare il valore nella riga :

<strong><em>if (t &lt;= 17)</em></strong>

Buon lavoro….