EtaBeta Studio - Makers per passione

giovedì 7 luglio 2016

Google DRIVE comodo, sicuro e collaborativo.

Come condividere in tempo reale documenti o immagini con altre persone?

Come poter lavorare su un documento a 4...6...8 … mani contemporaneamente?

Come scrivere un documento sul cellulare senza usare word o excel e condividerlo con colleghi o amici?

A questa ed a tante altre domande può rispondere un unico strumento messo a disposizione da GOOGLE …. GOOGLE DRIVE !!!

Cos’è e come funziona?

Google Drive altro non è che un Hard Disk online, messo a disposizione da google, che ci fornisce gratuitamente 15 GB (compresi mail e foto Google +) per poter archiviare documenti, immagini, file etc. accessibili tranquillamente da qualsiasi dispositivo (PC, MAC, Android, Apple) semplicemente sfruttando la connessione internet...

Come attivare google drive?

Semplicemente attivando un’ account GMAIL entrare nella posta e cliccare sul quadrato in alto a destra:

Cliccare su DRIVE

Ed ecco che si apre il meraviglioso mondo di GOOGLE DRIVE…

Vediamo cosa si può fare:

Cliccando su NUOVO è possibile:

Creare una Cartella
Caricare file presenti su pc o cellulare
Caricare un’intera cartella
Creare un Documento (tipo word)
Creare un foglio Google (tipo excel)
Realizzare una presentazione (tipo power point)

etc

Per la condivisione dei documenti ed il lavoro simultaneo come funziona?

Basta semplicemente creare un nuovo documento, nominarlo e cliccare sul tasto CONDIVIDI in alto a destra:

Inserire la gmail della persona con cui vogliamo condividere il file ed assegnargli delle proprietà:

Può modificare
Può solo commentare
Può solo visualizzare

La persona con cui condividete il file riceverà una mail con il link con cui avrà accesso al documento

Nel primo caso è possibile in questo modo lavorare contemporaneamente sullo stesso file anche in più persone, ognuno comodamente dal suo PC o cellulare, ed in posti del mondo diversi…

Attenzione però se lavorate online tutte le modifiche fatte saranno salvate e tutto ciò che avete fatto prima non è recuperabile, oppure se qualcuno con cui avete condiviso il FILE e gli avete dato la possibilità di modificarlo vi cancella tutto il documento è un bel problema !!!

Consiglio...fatevi sempre una copia di BACKUP.

Per la questione privacy come per qualsiasi altro servizio basato sulle tecnologie cloud, Google Drive prevede il trasferimento dei propri file ad un server remoto e il loro salvataggio online. Quindi conviene sempre evitare di collegarsi o scaricare l’applicazione da postazioni pubbliche o postazioni da cui accedono molte persone per evitare spiacevoli inconvenienti.

Buon Divertimento

Christian e Massimo

mercoledì 6 luglio 2016

Tutorial: Termostato remoto via web con Arduino o EDI

Come regolare e controllare la temperatura di casa a distanza??

Come accendere il riscaldamento a distanza via web?

In questo Tutorial andremo a creare una semplice paginetta web che ci informerà della temperatura interna di casa e sempre da remoto possiamo dare il consenso all'impianto di partire e di mantenere la temperatura impostata .

Per il tutorial utilizziamo la sonda di temperatura Dallas DS18B20 con protocollo 1-wire già utilizzata in un precedente tutorial per misurare la temperatura.

Vediamo prima di tutto cosa occorre per realizzare il nostro progetto:

Elenco materiale occorrente utilizzando ARDUINO 2009 / UNO :

n°1 Scheda ARDUINO 2009 / UNO (acquistabile qui).
n°1 Shield Arduino Ethernet (acquistabile qui).
sonda Dallas DS18B20 (acquistabile qui).

Resistenza da 1Kohm.
n°1 Relè a 5Vdc di tensione bobina tipo OMRON G5LA-14 o equivalenti.
n°1 Transistor BC337.
n°1 Diodo 1N4148.
n°2 Resistenze da 1K.
Cavo vari colori per breadboard.
Cavo di rete LAN.
Cavo USB.

Elenco materiale occorrente utilizzando ETABETA EDI:

n°1 Scheda EtaBeta EDI
n°1 Shield Arduino Ethernet
n°1 MicroSD da inserire nella Ethernet Shield (opzionale)
n°1 Cavo di rete LAN
n°1 Cavo USB

Per chi utilizza Arduino iniziamo a collegare tutti i componenti che ci occorrono sulla breadboard come da schema:

Mentre con ETABETA EDI occorre solo abilitare la sonda di temperatura ed il relè 1 configurando il dip switch DS1 come in foto:

Utilizziamo un transistor BC337 NPN in configurazione CBE (collettore - Base - Emettitore) per non danneggiare il micro.

Vediamo lo sketch funzionante per entrambe le soluzioni (ARDUINO ed ETA BETA EDI), il valore di temperatura viene stampato sulla pagina web da noi creata insieme allo stato della caldaia (Accesa / Spenta).

/*
 * Tutorial: Termostato remoto via web con Arduino o EDI
 *
 * Acqua - Pinto 
 * https://etabetastudio.blogspot.com
 */

 
#include <SPI.h>  
#include <Ethernet.h>
#include <OneWire.h> 
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 8
OneWire ourWire(ONE_WIRE_BUS);
DallasTemperature sensors(&ourWire);  
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };     //Mac address ethernet shield 
byte ip[] = { 192, 168, 1, 50 }; // indirizzo IP assegnato alla shield  
byte gateway[] = { 192, 168, 1, 1 }; // indirizzo ip del router  
byte subnet[] = { 255, 255, 255, 0 }; //subnet mask  
EthernetServer server(80);   //porta configurata sul router per collegarsi alla scheda anche in remoto
boolean a = true;   // in accensione la gestione automatica della caldaia è abilitata
int rele1 = 7; // pin collegato al relè 1 a cui collegare la caldaia
String readString;
boolean statocaldaia;  //Variabile di controllo stato caldaia (ACCESA/SPENTA)

void setup(){  
Ethernet.begin(mac, ip, gateway, subnet);  //inizializzare la ethernet shield
pinMode(rele1, OUTPUT);              // Impostare relè 1 come output
Serial.begin(9600);                  //inizializzare seriale
sensors.begin();
}  
  
void loop(){ 
 sensors.requestTemperatures();
 // Procedura x creazione pagina web 
EthernetClient client = server.available();         //richiesta del client della pagina web
if (client) {  
 boolean currentLineIsBlank = true;                 //  se la variabile currentLineIsBlank è nicazione con il client   
 while (client.connected()) {                       //Verificare la comunicazione cliet/server 
 if (client.available()) {  
 char c = client.read();  
 readString.concat(c); 
      
if (c == '\n' && currentLineIsBlank) {
Serial.print(readString);  
 client.println("HTTP/1.1 200 OK");  //Standard HTML
 client.println("Content-Type: text/html");  
 client.println();  
 client.print("<html><head><title>ETA BETA STUDIO WEB CONTROL ARDUINO EDI</title><meta http-equiv='Content-Type' content='text/html; charset=iso-8859-1' ></head><body>");   
client.println("<meta http-equiv=\"refresh\" content=\"10\">");    // REFRESH PAGINA WEB OGNI 10 SECONDI
client.print("Temperature (C): ");
client.println(sensors.getTempCByIndex(0));  
client.println("<br />");
if (statocaldaia == 1){
client.print("CALDAIA ACCESA ");
}
else{
client.print("CALDAIA SPENTA ");
}

Serial.print(readString);
 // IMPOSTO QUESTO IF PER ABILITARE L'ACCENSIONE O LO SPEGNIMENTO DELLA CALDAIA AL RAGGIUNGIMENTO DELLA TEMPERATURA STABILITA (20°C)
 if(readString.indexOf("ACCENSIONEAUTOMATICAON") > 0 ) {  
 if (sensors.getTempCByIndex(0) > 20 ){    //IMPOSTO IL VALORE DI TEMPERATURA SOTTO IL QUALE SI ACCENDE LA CALDAIA
digitalWrite(rele1, HIGH); 

a = true;
statocaldaia = 1;
  }
  else  {                           //IMPOSTO IL VALORE DI TEMPERATURA SOPRA IL QUALE SI ACCENDE LA CALDAIA                       
digitalWrite(rele1, LOW);

a = true;
statocaldaia = 0;
  }
 }
  if(readString.indexOf("ACCENSIONEAUTOMATICAOFF") > 0 ) {
   digitalWrite(rele1, LOW);
   a = false;
   statocaldaia = 0;
   }

 client.print("<h2><a href='/?ACCENSIONEAUTOMATICAON=1'>ACCENSIONE AUTOMATICA ABILITATA</a> | <a href='/?ACCENSIONEAUTOMATICAOFF=1'>ACCENSIONE AUTOMATICA DISABILITATA</a></h2>"); 
 client.println("</body></html>");
  readString="";  
 client.stop();  

 }   
 }   
 }   
 }

if (sensors.getTempCByIndex(0) > 20 && a == true) { // accende caldaia 
          digitalWrite(rele1, HIGH); //accendo
          statocaldaia = 1;
        }
if (sensors.getTempCByIndex(0) <= 20 && a == true) { // spegne caldaia
          digitalWrite(rele1, LOW); //spengo
          statocaldaia = 0;
        }
if (a == false) { 
          digitalWrite(rele1, LOW); //spengo
          statocaldaia = 0;
        }              
}

Buon Divertimento

Christian Acqua e Massimo Pinto

Come aprire le porte della Vodafone Station

Come configurare o aprire le porte del router?

Ecco un tutorial su come farlo per la vostra Vodafone Station

Come prima cosa accediamo all'apparato digitando il suo indirizzo ip nella rete che solitamente è 192.168.1.1

Appare la prima schermata riepilogativa che riporta le principali informazioni , come la connessione gli apparati presenti in rete etc.

Ora accediamo al menù di configurazione che si trova nel tab Avanzate > Port forwarding come in figura 2.

Figura 2

In questa schermata possiamo configurare le porte a seconda delle esigenze. Abbiamo 2 modi:

Configurazione predefinita
Possiamo scegliere tra un elenco di servizi come FTP, Telnet, HTTP etc.. dove i valori delle porte in entrata ed uscita sono già definiti ed a noi non resta che digitare solo l'indirizzo di destinazione del dispositivo interno alla rete che vogliamo sia raggiungibile (Figura 3).

Figura 3

Configurazione personalizzata
In questo caso dobbiamo inserire noi il tutto, i dati che occorrono sono:

Un nome a nostra scelta da dare alla configurazione.
L'indirizzo IP interno alla rete del dispositivo ( DVR, PC ect ) che vogliamo sia visibile all'esterno.
Il tipo di protocollo se TCP, UDP, in genere è TPC ma comunque è il produttore del dispositivo che vi dirà quale usare.
La porta esterna che associata all'IP pubblico ci permetterà di entrare
La porta del dispositivo.

In genere porta esterna e porta dispositivo sono uguali.

Figura 4

Come prima cosa dal menu a tendina servizio scegliamo personalizzato e diamo un nome a scelta, poi dal menu a tendina indirizzo locale scegliamo l'IP del nostro dispositivo , sempre dal un menu a tendina protocollo scegliamo il tipo ed infine scriviamo le porte nei campi come in figura, ovviamente con il valore che vi occorre. Facciamo ok ed attendiamo qualche secondo che i dati vengano salvati.

Ora possiamo accedere dall'esterno digitando l'IP + la porta.

Ciao!

martedì 5 luglio 2016

Tutorial: Lettore RFID - RC522 Arduino - EDI

Come si utilizza un lettore RFID con Arduino 2009 o con la scheda ETA BETA EDI ?

Come si memorizzano nelle celle EEPROM i codici dei tag ??

Per il nostro esperimento abbiamo utilizzato un lettore RFID - RC522 (acquistabile qui) e la nostra scheda ETA BETA EDI o arduino 2009.

Lo scopo del TUTORIAL è mostrarvi come si memorizzano i codici dei TAG RFID nelle celle EEPROM senza bisogno di aggiungerli a “mano” nel codice sorgente.

La libreria che abbiamo utilizzato è disponibile qui.

Di seguito gli schemi di collegamento realizzati con FRITZING sia per Arduino che per EDI:

SKETCH:

/*
 * Tutorial: Lettore RFID - RC522 Arduino - EDI
 * 
 * etabetastudio.blogspot.it
 * 
 * Christian Acqua - Massimo Pinto
 * 
 */



#include <SPI.h>
#include <MFRC522.h>
#include <EEPROM.h>
 
#define SS_PIN 10
#define RST_PIN 9
  
MFRC522 mfrc522(SS_PIN, RST_PIN);   // Creare un instanza di MFRC522
  
int ser;
int  programma=0;
byte puntatore = 0; // Puntatore card registrate
String uid_s1;
String uid_s;
String uidRFID[50];
boolean controllo;   //Variabile di verica card registrate
 
void setup() {
               
    Serial.begin(9600); // inizializzazione seriale
    SPI.begin();        // Inizializzazione BUS SPI
    mfrc522.PCD_Init(); // IInizializzazione MFRC522 reader
     
 // lettura da EEPROM --- IN ACCENSIONE SARANNO STAMPATI A MONITOR SERIALE I CODICI RFID DEI TAG PROGRAMMATI E LA CELLA EEPROM DOVE SONO MEMORIZZATI
 
  puntatore = EEPROM.read(0);
 
  if (puntatore == 2) {    // leggo valori
     puntatore=EEPROM.read(1);
  
   Serial.println(puntatore); 
     int i=1;
     while(i<=puntatore) {
       uidRFID[i-1]="";
       for (int p=i*8-8+2;p<i*8+2;p++) {
         uidRFID[i-1]=uidRFID[i-1]+char(EEPROM.read(p));
         }
      Serial.println(uidRFID[i-1]);
      i++;
      }
  }
  else {                        // mai scritta EEPROM
     EEPROM.write (0,2);
     EEPROM.write (1,0);
  }
}
  
void loop() {

 
//AVVICINARE IL TAG RFID AL LETTORE E POI DIGITARE LA LETTERA "a" SUL MONITOR SERIALE PER ENTRARE IN PROGRAMMAZIONE. 
//SE IL TAG NON è MEMORIZZATO QUINDI NON è PRESENTE NELLE CELLE EEPROM VERRà ACQUISITO
//SE IL TAG è GIà STATO MEMORIZZATO IN PRECEDENZA CI APPARIRà LA SCRITTA TAG GIA PRESENTE
// entra in programmazione
  if (Serial.available() > 0) {
 ser=Serial.read();    
 switch (ser){    //digito sul monitor seriale la lettera a per entrare nella memorizzazione dei codici 
   case 'a':
  delay(1500); 
  programma =1; 
   progchiave();
  break;
}  
} 

}

// VOID PER LA PROGRAMMAZIONE E LA MEMORIZZAZIONE DELLE CHIAVI
void progchiave(){

  // lettura codice card ----------------------------------------
 String uid_s = "";

      if ( ! mfrc522.PICC_IsNewCardPresent()) {
        return;
    }
     // Select one of the cards
    if ( ! mfrc522.PICC_ReadCardSerial()) {
        return;
    }
  if (!mfrc522.PICC_IsNewCardPresent() && !mfrc522.PICC_ReadCardSerial()) {

      for (byte i = 0; i < mfrc522.uid.size; i++) {   
          String uid_a = String(mfrc522.uid.uidByte[i] < 0x10 ? "0" : "");
          String uid_b = String(mfrc522.uid.uidByte[i], HEX);           
          uid_s = uid_s+uid_a+uid_b;
      }
      
      Serial.print("RFID UID rivelato1 --> ");
  Serial.println(uid_s);
  delay(500);
  Serial.println("");
  

  // in uid_s la stringa con il codice della card letta ---------
  boolean controllo = false;  
     for (int i = 0; i < puntatore; i++){   
       if(uidRFID[i] == uid_s){       
            Serial.println("TAG GIA PRESENTE");
            controllo = true;
            break;
         }
       }     
      if(!controllo){    
         if (programma==1) {
           programma=2;
            uid_s1 = uid_s;
          //  Serial.println( "Card da registrare -> INVIARE d SU SERIALE PER USCIRE" );
          uidRFID[puntatore]=uid_s1;
             // scrivi in EEPROM
             EEPROM.write (1,puntatore+1);
             for (int p=0;p<8;p++) {
               EEPROM.write(puntatore*8+2+p,byte(uid_s1.charAt(p)));
             }
             puntatore++;
             delay(1000);
             programma=0;
             Serial.println("Codice aggiunto");
             delay(1000);
            // break;  
            
            delay(1000);
         }
      }
   Serial.println();
   Serial.println("AVVICINARE NUOVO TAG");
  delay(500);
//} 
 }
}

Carichiamo lo skecth sulla scheda ed il gioco è fatto!!!

Buon lavoro!

Christian Acqua
Massimo Pinto

lunedì 4 luglio 2016

Tutorial: Luce temporizzata con comando locale, usando millis.

Difficoltà Media

Come temporizzare un'uscita di arduino?
Come utilizzare l'istruzione millis?

Spesso il miglior modo per apprendere è fissarsi un obiettivo, un progetto.

In questo tutorial realizzeremo un temporizzatore. Cosa possiamo fare ?
Per esempio comandare un relè che attiva una luce a tempo oppure un sistema di irrigazione.

Cosa occorre oltre la buona volontà, vediamo:

Elenco del materiale occorrente utilizzando ARDUINO:

n°1 Scheda ARDUINO 2009 / UNO (acquistabile qui)
n°1 Breadbord bella capiente (acquistabile qui)
n°1 Relè a 5Vdc di tensione bobina tipo OMRON G5LA-14 (acquistabile qui)
n°1 Pulsanti tattili switch (acquistabili qui)
n°1 Resistenze da 1.5K
n°2 Resistenze da 1K
n°1 Transistor BC337
n°1 Diodi 1N4148
Cavi vari colori per breadboard
n°1 Cavo USB

Elenco del materiale occorrente utilizzando ETABETA EDI:

n°1 Scheda EtaBeta IDEA
n°1 Cavo USB

Come prima cosa realizziamo i collegamenti elettrici come da figura 1 per chi usa Arduino.

Figura 1

Per ETA BETA EDI non occorre far nulla se non abilitare 1 switch button (BTN1) ed 1 relè (REL1) configurando i dip switch DS1 e DS2 come in figura 2:

Figura 2

Fatto?

Perfetto! Ora possiamo dedicarci alla scrittura del nostro sketch.

Una precisazione, perché usare l'istruzione "millis" e non un bel mitico "delay" per ritardare il comando del relè?

Il comando "delay" è un vero e proprio blocco dove il codice si ferma in quel punto senza che accada nulla , il micro durante il delay non fa nulla se non aspettare. Questo è un male perchè nella condizione d'attesa tutto quello che succede fuori al micro non interessa.

Faccio un esempio per rendere l'idea: Supponiamo di usare il nostro micro per creare un sistema di fotocellule dove la durata d'apertura del cancello è data da un delay da 10000 (10"). Con questo delay tutto ciò che passa davanti alle fotocellule non viene considerato ed è un rischio enorme da evitare. Mentre con il comando millis ciò non avviene il codice gira bello veloce con un loop da gran premio. Basta solo scandire i secondi e con qualche if possiamo creare le condizioni d'attesa che vogliamo in tutta tranquillità.

Passiamo ad analizzare il codice completo leggendo i commenti.

/* Tutorial Luce Temporizzata con comando locale e remoto via web
 *  
 *  http://etabetastudio.blogger.com
 *  
 *  Pinto Massimo - Chistian Acqua
 */

const int buttonPin = 5;     // pin dello switch button
const int ledPin =  13;      // pin del led di segnalazione
const int relPin =  13;      // pin del rele

int buttonState = 0;         // stato switch
int ledrelon = 0;               //stato led e rele 
unsigned long conteggio = 120000;  // durata temorizzazioni in millisecondi
unsigned long previsioneMillis=0;  // variabili di inizio e fine conteggio
unsigned long correntiMillis=0;   // variabili di inizio e fine conteggio


void setup(){
  Serial.begin(9600); // inizializziamo la seriale
  pinMode(ledPin, OUTPUT); //inizializziamo i pin 
  pinMode(relPin, OUTPUT); //inizializziamo i pin 
  pinMode(buttonPin, INPUT);//inizializziamo i pin
  digitalWrite(ledPin, LOW);//inizializziamo i pin
}
void loop(){
unsigned long correntiMillis = millis();   // memorizziamo il valore di millis 
buttonState = digitalRead(buttonPin);  catturiamo lo stato dello switch button

// Se lo Switch button è alto
if (buttonState == HIGH) {
    Serial.println("bottone giu"); // facciamo un po di stampe per capire cosa succede
    ledrelon = 1; // abilitiamo l'ingresso alla condizione successiva
    previsioneMillis = correntiMillis + conteggio;  // creiamo il valore di off sommando i millis catturati prima + il tempo impostato di off
            Serial.print("correntiMillis: "); // facciamo un po di stampe per capire cosa succede
        Serial.println(correntiMillis); // facciamo un po di stampe per capire cosa succede
    Serial.print("previsioneMillis: "); // facciamo un po di stampe per capire cosa succede
    Serial.println(previsioneMillis); // facciamo un po di stampe per capire cosa succede
    }
if(ledrelon == 1){
    digitalWrite(ledPin, HIGH); // accendiamo il led
    digitalWrite(relPin, HIGH); // eccitiamo il rele
    delay(500); // questo delay non è fondamentale serve a leggere le stampe sul serial monitor
        Serial.print("correntiMillis: ");
        Serial.println(correntiMillis);
   if (correntiMillis >= previsioneMillis) {
        delay(10);
        digitalWrite(ledPin, LOW); // raggiunto il tempo di spegnimento tutto va giù
        digitalWrite(relPin, LOW);
        ledrelon = 0; // reimpostiamo ledrelon per iniziare nuvamente un ciclo
        }
}
}

Buon test a tutti.

Pagine

giovedì 7 luglio 2016

Google DRIVE comodo, sicuro e collaborativo.

mercoledì 6 luglio 2016

Tutorial: Termostato remoto via web con Arduino o EDI

Come aprire le porte della Vodafone Station

martedì 5 luglio 2016

Tutorial: Lettore RFID - RC522 Arduino - EDI

lunedì 4 luglio 2016

Tutorial: Luce temporizzata con comando locale, usando millis.

Translate