Ritorna a Playground Italiano

Articoli di Arduino su Wired Italia

  • Come costruire un Joystick per PC/Mac con una Leonardo per giocare a SuperTuxKart
  • Cosm: un database a cui collegare Arduino e controllare l'andamento dei sensori dal web
  • Twitting Plant La pianta che twitta quando ha sete. [Internet of Things]
  • Lampada twitter: una lampada che cambia colore seguendo un certo hashtag o un account.
  • OpenEnergyMonitor: usiamo Arduino per monitorare i nostri consumi e non solo.
  • Stufetta controllata da SMS Tramite il GSM shield controlliamo l'accensione e lo spegnimento della stufetta della casa in montagna
  • Costruiamo un semplice robot! Come addentrarsi nel meraviglioso mondo della robotica
  • Telecomando ad infrarossi vs VLC! Controlla il tuo pc con un qualsiasi telecomando ad infrarossi (Parte 1)
  • Slide-Lamps(e), la lampada dello Startupper! Tieni sempre d'occhio la Slide-Lamps(e) e fai attenzione che il tuo tempo a disposizione non scada!
  • Cat Feeder comandato da un cellulare Sei in giro, lontano da casa, ed hai dimenticato di dar da mangiare al tuo tenero gatto? Chiedi aiuto al Cat Feeder!
  • Intercom-to-phone Parla al citofono via cellulare ovunque tu sia!
  • Catamarano WiFi Costruisci un catamarano con due bottiglie di plastica e una ventola da pc. Comandalo tramite WiFi.
  • Mostriciattolo Parlante Dai la voce ad un mostriciattolo! Con un piccolo microfono controlleremo attraverso la nostra voce una bocca che parlerà al posto nostro.
  • Attaccapanni Meteorologo Stanchi di dover perdere tempo controllando il meteo per scegliere come meglio vestirvi? Ci pensa la Yun! costruiamo il mitico Attaccapanni Meteorologo
  • Etilometro Dopo una serata all’insegna dell’alcool con gli amici vuoi scoprire chi è il meno ubriaco per riportare gli altri a casa?
  • Bilancia Cloud Hackeriamo una bilancia per personalizzare le letture e salvarle su internet con l'aiuto dell'Arduino Yún.
  • TextMatrix Invia un messaggio tramite una interfaccia web e visualizzalo con su un display controllato dalla tua Yún.
  • Bagaglio a mano Tramite un sensore di pressione tessile e un'arduino lilypad, che possono essere cuciti su uno zaino è possibile pesare il propprio bagaglio a mano ogni volta che lo si appoggia per terra.
  • Domotica fatta in casa La domotica è cosa per pochi, difficile e pericolosa se fatta in casa, oltre che molto costosa. Assolutamente sbagliato!
  • Il Tabellone Segnapunti Anche a te capita di non contare i goal quando giochi con il calcetto balilla? Impara a costruire un semplice e utilissimo tabellone segnapunti!
  • Telecamera Nascosta Vuoi sentirti un pò 007? Il progetto di questo mese prevede l'utilizzo di una webcam da cammuffare all'interno di un oggetto per trasformarlo in un sistema di sorveglianza remoto!



Come costruire un Joystick per PC/Mac con una Leonardo per giocare a SuperTuxKart

Collegamenti


Rappresentazione Fritzing dei collegamenti con una breadboard



Schema elettico dei collegamenti


Sketch

#define KeysNum 9  // Numero di tasti necessari per usare tutti
                   // i comandi di tuxkart per ogni giocatore

//Soglia massima e minima per interpretare il joystick come input digitale
#define joy_leftThreshold 600
#define joy_rightThreshold 300
#define joy_upThreshold 600
#define joy_downThreshold 300

// serve per creare una lista, in pratica sostituisce i numeri con dei nomi
// molto figo, non strettamente necessario. Dopo frena non li ho piu' usati
enum playerPin {
  sinistra, destra, accelera, frena, fuoco, nitro, curvaStretta, guardaDietro, riposiziona };

/* Player 1 controls */
// questo array contiene i pin da assengare ai controlli
// seguendo la convenzione in "enum playerPin"
const int p1_pins[KeysNum] = {
  A0, A1, 0, 1, 2, 3, 4 };  //<-nota che posso prendere anche 0 e 1 perche' sulla leonardo
                            //la seriale hw e' non viene usata per comunicare col PC

// array che contiene i corripondenti tasti che la leonardo
// preme simulando di essere una tastiera
char p1_keyboardKeys[9] = {
  KEY_LEFT_ARROW, KEY_RIGHT_ARROW, KEY_UP_ARROW, KEY_DOWN_ARROW, ' ', 'n', 'v', 'b', KEY_BACKSPACE };

/* Player 2 controls */
//valgono gli stessi commenti del player 1
const int p2_pins[KeysNum] = {
  A2, A3, 5, 6, 7, 8, 9 };

char p2_keyboardKeys[9] = {
  'a', 'd', 'w', 's', 'q', 'e', '1', '2', '3' };

void setup()
{
  //inizializzo i pin come INPUT
  inizializzaPlayer(p1_pins);
  inizializzaPlayer(p2_pins);

  Serial.begin(9600);
}

void loop()
{
  leggiController(p1_pins, p1_keyboardKeys);
  leggiController(p2_pins, p2_keyboardKeys);
}

// funzione per inizializzare i pin come INPUT.
// usando l'array per contenere i pin posso fare tutto con un ciclo for
// e posso usare la stessa funzione per piu' giocatori
void inizializzaPlayer (const int *pins) //<- se il puntatore confonde lo togliamo
{
  for(int i=0; i<KeysNum; i++)
    pinMode(pins[i], INPUT);
}

// questa funzione riceve come parametri:
// [*pins]    - i piedini assegnati al controller del giocatore X
// [*keylist] - l'elenco dei tasti dalla tastiera da emulare per contollare il gioco
//
// Scandisce in sequenza ogni input di arduino e se attivo associa il
// corrispondente tasto della tastiera.
void leggiController (const int *pins, char *keyList)
{
  int direzione, throttle;
 
  // ciclo for per scandire tutti i tasti della tastiera
  for(int i=0; i<KeysNum; i++)
  {
    // sinistra e' un elemento della enum...vale 1
    if(i == sinistra){
      // leggo l'asse X del joystick
      direzione = analogRead( pins[0] );
      // se supero la soglia devo mandare il comando corrispondente
      if( direzione > joy_leftThreshold )
        Keyboard.press(keyList[sinistra]);
      else
        // devo rilasciare anche il tasto della tastiera
        // quando sul controller il rispettivo comando non viene premuto
        Keyboard.release(keyList[sinistra]);
    }

    else if(i == destra) {
      // ho già letto il pin dell'asse X prima, non c'e' bisogno di rifarlo
      if( direzione < joy_rightThreshold )
        Keyboard.press(keyList[destra]);
      else
        Keyboard.release(keyList[destra]);
    }

    // uguale all'asse X ma per l'asse Y che controlla freno ed acceleratore
    else if(i == accelera) {
      throttle = analogRead( pins[1] );
      if( throttle > joy_upThreshold )
        Keyboard.press(keyList[frena]);
      else
        Keyboard.release(keyList[frena]);
    }

    else if(i == frena) {
      if( throttle < joy_downThreshold )
        Keyboard.press(keyList[accelera]);
      else
        Keyboard.release(keyList[accelera]);
    }

   // ho finito di leggere i piedini analogici
   //
   // posso passare a leggere quelli digitali che, non dovendo comparare
   // delle soglie posso leggere molto più facilmente e in sequenza.
   // Sfruttando la comodita' di aver usato un array
    else {
      if( digitalRead( pins[i] ) == HIGH )
        Keyboard.press(keyList[i]);
      else
        Keyboard.release(keyList[i]);
    }
  }
}


Cosm

Cosm.com è un servizio online che tramite le API che mette a disposizione consente ad un Arduino di inviare i dati che legge dai senori che avete deciso di collegargli. Cosm si preoccuperà di salvare i dati in un database e di mostrarli nella pagina dello stream che avete appositamente creato, i grafici relativi all'andamento temporale delle letture dei vostri sensori.

Per creare il vostro stream di dati personalizzato per prima cosa dovete creare un account su Cosm.com. Una volta che avete accesso alla console, cliccate sul pulsante "+ Device/Feed" per creare una pagina (il feed) dedicato all'Arduino che tra poco programmeremo per inviare i dati. Tra le quattro opzioni selezionate quella chiamata "Something Else" e seguite la procedura, specificando che sarete voi ad inviare i dati a Cosm ( Opzione: No, I will push data to Cosm ).

Al termine della procedura segnatevi il titolo che avete dato al feed e anche il numero che vi da Cosm alla fine.

Manca ancora una cosa affichè il vostro arduino si possa collegare in modo sicuro al vostro account, una chiave di protezione che, dovete generare selezionando il menu "Keys" dal vostro pannello utente. Cosm vi da varie possibilità per cui possa essere valida quella chiave, ad esempio: la potete associare ad un solo feed oppure, decidere di averne una sola per tutti, ecc. Una volta generata scrivetevetela da qualche parte.

Alle Officine Arduino abbiamo deciso di usare dei moduli TinkerKit per collegare un termistore ed una fotoresistenza rispettivamente agli ingressi analogici 0 e 1.

Nel codice è contenuto l'algoritmo di conversione che trasforma il valore di tensione letto dal termistore in una temperatura in gradi centrigradi. Mentre la lettura della luminosità ambientale è rapportata in percentuale del valore analogico letto.

Il codice:

/*
  Officine Arduino Temperature and Light sensors connected to:
  Cosm client with Strings
 
 This sketch connects an analog sensor to Cosm (http://www.cosm.com)
 using a Wiznet Ethernet shield. You can use the Arduino Ethernet shield, or
 the Adafruit Ethernet shield, either one will work, as long as it's got
 a Wiznet Ethernet module on board.
 
 
 This example uses the String library, which is part of the Arduino core from
 version 0019.  
 
 Circuit:
 * Thermistor attached to analog in 0
 * LDR sensor attached to analog in 1
 * Ethernet shield attached to pins 10, 11, 12, 13
 
 Based on the CosmClientString created:
 by Tom Igoe with input from Usman Haque and Joe Saavedra
 customized by Federico Vanzati
 
 http://arduino.cc/en/Tutorial/PachubeClientString
 This code is in the public domain.
 
 */


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

                                                                     
#define APIKEY         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" // replace your Cosm api key here
#define FEEDID         67409 // replace your feed ID
#define USERAGENT      "Officine Arduino Temperature and Light" // user agent is the project name

const static int Beta = 3950;        // Beta parameter
const static float Kelvin = 273.15;  // 0°C = 273.15 K
const static int Rb = 10000;         // 10 kOhm
const static float Ginf = 120.6685;  // Ginf = 1/Rinf
//The formula to compute the Rinf is:
// Rinf = R0*e^(-Beta/T0) = 4700*e^(-3950/298.15)


// assign a MAC address for the ethernet controller.
// fill in your address here:
byte mac[] = {
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
// fill in an available IP address on your network here,
// for manual configuration:
IPAddress ip(192,168,1,100);

// initialize the library instance:
EthernetClient client;

// if you don't want to use DNS (and reduce your sketch size)
// use the numeric IP instead of the name for the server:
//IPAddress server(216,52,233,121);      // numeric IP for api.cosm.com
char server[] = "api.cosm.com";   // name address for Cosm API

unsigned long lastConnectionTime = 0;  // last time you connected to the server, in milliseconds
boolean lastConnected = false;  // state of the connection last time through the main loop
const unsigned long postingInterval = 10*1000;  //delay between updates to Pachube.com

void setup() {
  // start serial port:
  Serial.begin(9600);
  // give the ethernet module time to boot up:
  delay(1000);
  // start the Ethernet connection:
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // DHCP failed, so use a fixed IP address:
    Ethernet.begin(mac, ip);
  }
  else {
    Serial.print("My IP address is: ");
    for (byte thisByte = 0; thisByte < 4; thisByte++) {
      // print the value of each byte of the IP address:
      Serial.print(Ethernet.localIP()[thisByte], DEC);
      Serial.print(".");
    }
    Serial.println();
  }
}

void loop() {
  // read the analog sensor:
  int sensorReading = analogRead(A0);
  float Rthermistor = Rb * (1023.0 / sensorReading - 1);
  float temperatureC = Beta / (log( Rthermistor * Ginf )) ;
  temperatureC -=  Kelvin;

  int decimal = (int)temperatureC;
  int fraction = (temperatureC - decimal) * 10;

  String dataString = "Temperatura_Ufficio,";
  dataString += decimal;
  dataString += '.';
  dataString += fraction;

  //Reading the LDR and transform in percentage of light
  int ldrReading = map(analogRead(A1), 0, 1023, 0, 100);
 
  dataString += "\nIlluminazione,";
  dataString += ldrReading;

  // if there's incoming data from the net connection.
  // send it out the serial port.  This is for debugging
  // purposes only:
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  // if there's no net connection, but there was one last time
  // through the loop, then stop the client:
  if (!client.connected() && lastConnected) {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();
  }

  // if you're not connected, and ten seconds have passed since
  // your last connection, then connect again and send data:
  if(!client.connected() && (millis() - lastConnectionTime > postingInterval)) {
//    Serial.print(decimal);
//    Serial.print(".");
//    Serial.println(fraction);
//    Serial.println();
    Serial.println(dataString);
    Serial.println();
    sendData(dataString);
  }
  // store the state of the connection for next time through
  // the loop:
  lastConnected = client.connected();
}

// this method makes a HTTP connection to the server:
void sendData(String thisData) {
  // if there's a successful connection:
  if (client.connect(server, 80)) {
    Serial.println("connecting...");
    // send the HTTP PUT request:
    client.print("PUT /v2/feeds/");
    client.print(FEEDID);
    client.println(".csv HTTP/1.1");
    client.println("Host: api.cosm.com");
    client.print("X-ApiKey: ");
    client.println(APIKEY);
    client.print("User-Agent: ");
    client.println(USERAGENT);
    client.print("Content-Length: ");
    client.println(thisData.length());

    // last pieces of the HTTP PUT request:
    client.println("Content-Type: text/csv");
    client.println("Connection: close");
    client.println();

    // here's the actual content of the PUT request:
    client.println(thisData);

    // note the time that the connection was made:
    lastConnectionTime = millis();
  }
  else {
    // if you couldn't make a connection:
    Serial.println("connection failed");
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();
  }
    lastConnectionTime = millis();
}

Come vi sarete già accorti, nelle prime tre costanti dovete scrivere i dati relativi al vostro feed, quelli che vi siete segnati prima.

Se volete avere un'idea del risultato date un occhio al feed di Officine Arduino.


TwittingPlant

La pianta che twitta quando ha sete


Stufetta controllata da SMS

Tramite il GSM shield controlliamo l'accensione e lo spegnimento della stufetta della nostra casa in montagna!

Questo sketch, ideato per la GSM shield, permette di comandare a distanza un qualsiasi dispositivo connesso al proprio Arduino. Inviando un SMS, attraverso determinate parole chiave, è possibile, in questo caso, accendere o spegnere una semplice stufetta.

Il modulo GSM, montato su una scheda Arduino, elabora il messaggio ed esegue un'azione di accensione o spegnimento. Successivamente invia un messaggio di notifica sullo stato del dispositivo. Se il messaggio non contiene keywords valide, l'Arduino non esegue alcun tipo di operazione ed il messaggio viene eliminato dalla sim. Lo sketch gestisce anche keywords con caratteri maiuscoli o minuscoli.

Keywords:

  • Accendi: per accendere il dispositivo
  • Spegni: per spegnere il dispositivo
  • "Dispositivo": questa keyword è variabile. Nel nostro caso: Stufetta



GSM Shield e Relay


Per sapere come connettere il vostro relay correttamente, date un'occhiata a questo link: Tutorial Relay. Nel nostro caso però, la scheda TinkerKit! è stata sostituita con quella GSM.

I tre pin collegati sono:

  • pin 5V (filo rosso)
  • pin GND (filo nero)
  • pin 12 (filo arancione)

Il codice:

/*
 SMS heather remote control
 
 This sketch, designed for the GSM shield, allows you to remotely control any
 device connected to your Arduino. By sending an SMS, through certain keywords,
 it's possible, as in this case, to turn on or off a simple heater.
 
 The GSM module, mounted on an Arduino board, processes the message and executes an action.
 Then, it sends a notification message containing the state of the device.
 If the message doesn't contain any valid keyword, the Arduino doesn't execute any
 operation and the message is deleted from the sim card.
 The sketch also manages keywords with uppercase or lowercase.
 
 Circuit:
 * GSM shield and an Arduino board
 * SIM card that can send/receive SMS
 * a relay connected to digital pin 12
 
 based on the ReceiveSMS example by Javier Zorzano / TD
 modified by Federico Vanzati & Alberto Cicchi (03/2013)
 
 */


// include the GSM library
#include <GSM.h>

const int heaterControlPin = 12;

// initialize the library instances
GSM gsmAccess;
GSM_SMS sms;

// Array to hold the number a SMS is retreived from
char senderNumber[20];  

// String to hold the incoming message
String message = "";

// String that will contain the parsed values from the message
String commandID, deviceID;

void setup()
{
  // set the pin connected to the relay that control the heater as output
  pinMode(heaterControlPin, OUTPUT);

  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  // connection state
  boolean notConnected = true;

  // Start GSM connection
  while(notConnected)
  {
    if(gsmAccess.begin()==GSM_READY)
      notConnected = false;
    else
    {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("GSM initialized");

}

void loop()
{
  char c;

  // If there are any SMS available  
  if (sms.available())
  {
    Serial.println("Message received from:");

    // Get remote number
    sms.remoteNumber(senderNumber, 20);
    Serial.println(senderNumber);

    // An example of message disposal    
    // Any messages starting with # should be discarded
    // usually anonymous messages starts with #
    if(sms.peek()=='#')
    {
      Serial.println("Discarded SMS");
      sms.flush();
    }

    // Read message bytes and print them
    while(c = sms.read())
      message += c;

    // cancella message ricevuto
    sms.flush();
    Serial.println("MESSAGE DELETED");
  }

  // if there is a new message start to parse the command and the device to control
  if(message != "") {

    // put the incoming characters that compose the message to lower case
    message.toLowerCase();

    int i=0;

    // deviceID and commandID are separated by a space
    // find it and store the position in two strings
    while(message.charAt(i) != ' ') i++;

    commandID = message.substring(0,i);
    deviceID = message.substring(i+1, message.length());

    // check the device to control
    if(deviceID == "stufetta")
    {
      //check the command to execute
      if(commandID == "accendi") {
        sendFeedbackSMS(senderNumber, deviceID, "ON");  // send the feedback to the sender
        digitalWrite(heaterControlPin, HIGH);
      }
      if(commandID == "spegni") {
        sendFeedbackSMS(senderNumber, deviceID, "OFF"); // send the feedback to the sender
        digitalWrite(heaterControlPin, LOW);
      }
    }

    // clear the message that has just been processed
    message = "";
  }

  delay(1000);
}

// this function, given a phone number and two strings representing the device and
// its state send a feedback text message to the phone number
void sendFeedbackSMS(char remoteNum[], String devString, String devState) {
  String txtMsg = devString + " " + devState;
  Serial.println(txtMsg);
  Serial.println(remoteNum);

  sms.beginSMS(remoteNum);
  sms.print(txtMsg);
  sms.endSMS();
}


Costruiamo un semplice robot!

Come addentrarsi nel meraviglioso mondo della robotica

Hai mai desiderato costruirti un semplice Robot? Questo è il primo passo per entrare nel mondo della robotica. Osserva quanto intelligente (o stupido) può essere questo piccolo robot che reagisce all’ambiente circostante con semplici reazioni.

Questo robot ha un'intelligenza artificiale generata da un Arduino Uno, un corpo solido formato da una scocca di compensato tagliata al laser (ma facilmente costruibile anche con del cartone) e delle potenti gambe mosse da due precisi servomotori. I suoi occhi sono due fotoresistenze che gli permettono di seguire ovunque una fonte di luce esterna ed il suo senso tattile è realizzato tramite un creativo interruttore che al contatto con un qualsiasi ostacolo, consente di fargli cambiare direzione ed evitare vicoli ciechi.



Sensori LDR



Servomotori


Il costo approssimativo dell'intero robot è circa 50 euro. Di seguito sono elencati tutti i componenti che sono stati utilizzati per realizzarlo.

Componenti:

  • Arduino Uno 22€ + IVA
  • 2 Servo a Rotazione continua 12.90€ + IVA
  • Un pezzo di camera d’aria di una bici (la gomma della ruota)
  • Una castor ball (si trova in ferramenta)
  • 4 Batterie 1.5V AA 3€ + IVA
  • 1 Porta batterie 0.50€ + IVA
  • 10mm LED
  • 2 LDR
  • Fili 0.20€ + IVA
  • Interruttore di fine corsa 0.50€ + IVA
  • Opzionali: interruttore, morsetti mammut

Il robot può essere ovviamente migliorato inserendo ulteriori sensori o attuatori o dotandolo di altri moduli, come il modulo bluetooth per il controllo tramite tablet o smartphone, il modulo Wi-Fi per controllarlo dal proprio pc o addirittura, aggiungendo l'innovativo modulo GSM, per attivarlo e controllarlo a distanza tramite un semplice sms.

Immaginazione e creatività non hanno limiti! Al robot si possono infatti applicare diverse intelaiature e decorazioni.



Decorazioni



Intelaiature e decorazioni


Funzionamento:

Questo robot si basa su un semplice modello di veicolo di Braitenberg ed è stato realizzato affinché possa muoversi autonomamente. Uno switch collegato al pin7 gestisce il suo comportamento nel caso di contatto con un ostacolo: il robot si ferma e cambia direzione effettuando un giro di 180 gradi su sé stesso.

Possono essere settati 3 diversi tipi di movimento generale:

  • Il robot va dritto fino ad incontrare un ostacolo. Al contatto, torna indietro e cambia direzione;
  • Il robot segue la luce. In base a quale delle due fotoresistenze percepisce una maggiore quantità di luce, il robot si muove a rispettivamente a destra o a sinistra;
  • Il robot evita la luce. In base a quale delle due fotoresistenze percepisce una minore quantità di luce, il robot si muove a rispettivamente a destra o a sinistra.

In questa configurazione del veicolo non è possibile controllare contemporaneamente tutti e 3 i diversi comportamenti. E' possibile implementare una versione migliorata del robot collegando ad esempio a diversi pin sull'Arduino e settando all'occorrenza il comportamento desiderato.



Sorgente di luce


Circuito su Fritzing:



Fritzing File


Il codice:

/*
 Simple braitenberg vehicle + Obstacle avoiding.
 
 Robot driven by 2 Continuous Rotation Servos.
 Servos controlled by LDRs in front of robot.
 
 The behaviour (light seeking/light avoiding) is determined by which LDR is controlling which servo.
 The analog read values from LDRs are mapped to control the continous rotation servos.
 A tactical switch on pin7 triggers the robot to turn around in case of an obstacle.
 
 The robot can have 3 different behaviours.
 */


#include <Servo.h>

Servo leftServo;
Servo rightServo;

int leftValue = 0;
int rightValue = 0;
int MAXspeed = 0.5; // Value from 0-1

void setup() {              

  // obstacle avoiding switch pin
  pinMode(7, INPUT_PULLUP);   // This line pulls the pin HIGH
  digitalWrite(7, HIGH);

  // LEDeye of robot
  pinMode(6, OUTPUT);
  digitalWrite(6, LOW);

  leftServo.attach(10);
  rightServo.attach(9);
}

void loop() {

  // robot hits an obstacle: turns around 180 degree
  if (digitalRead(7)==LOW){
    digitalWrite(6, HIGH);      //blink eye
    delay(100);
    leftServo.write(90);        //stop left servo
    delay(100);
    rightServo.write(90);       //stop left servo
    delay(100);
    digitalWrite(6, LOW);      

    //go back for half a second
    leftServo.write(90 - 10);
    rightServo.write(90 + 25);
    delay(500);

    //turn around right
    leftServo.write(90 + 30);
    rightServo.write(90 + 30);
    delay(700);
  }

  // read LDRs
  leftValue = analogRead(0);
  rightValue = analogRead(1);

  leftValue = map(leftValue, 0, 1023, 0, 89);       // scale it to use it with the servo (value between 0 and 180)
  rightValue = map(rightValue, 0, 1023, 0, 89);     // scale it to use it with the servo (value between 0 and 180)

  // First behaviour: calibrating servos for going straight
  // leftServo.write(90 + 18);
  // rightServo.write(90 - 15);  

  // Second behaviour: follow the light
  left.Servo(90 + rightValue);
  right.Servo(90 - leftValue);

  // Third behaviour: avoid the light
  // left.Servo(90 - rightValue);
  // right.Servo(90 + leftValue);

  delay(100);
}

Downloads:

Nella cartella Download sono presenti:

  • file .dxf per il taglio laser del compensato
  • file Fritzing


Telecomando ad infrarossi vs VLC!

Controlla il tuo pc con un qualsiasi telecomando ad infrarossi (Parte 1)

Talvolta sarebbe davvero comodo avere un telecomando che interagisca con il proprio pc, controllando a piacimento diversi software. Ascoltare la musica o vedere un film su VLC e gestirne la riproduzione a distanza ti sembra un'idea allettante? Ecco come fare!

Componenti:

  • Arduino Micro
  • Modulo ricevitore IR (nel nostro caso è stato usato un TSOP31238)
  • Condensatore ceramico da 100nF
  • Resistenza da 100 O
  • Un telecomando IR (va bene anche un vecchio modello in disuso)



Arduino Micro


Configurazione:

Prima di tutto, per far riconoscere un telecomando al proprio pc, è necessario che i due dispositivi “parlino la stessa lingua”. Per fare ciò, bisogna caricare sull'Arduino lo sketch “IRrecvDemo” presente nella libreria IRremote scritta da Ken Shirriff, scaricabile dal seguente repository di GitHub.

Per poter utilizzare questa libreria, cliccate sul simbolo ZIP e, una volta terminato il download, scompattate il file e spostatelo nella cartella libraries dell'ide di Arduino. Caricate poi lo sketch seguendo il percorso: Esempi ? Irremote ? IRrecvDemo.

Il semplice codice qui riportato, mostra come abilitare il pin 11 dell'Arduino a ricevere i segnali del telecomando. Il risultato di ogni ricezione (un click su un qualsiasi tasto del telecomando) è, se si aggiunge il prefisso 0x, un valore esadecimale che corrisponderà ad una determinata azione (o variabile) sul proprio sketch.

Aprendo la porta seriale dell'ide, si possono leggere tutti i risultati delle diverse acquisizioni. Salvate i codici esadecimali corrispondenti ai tasti che desiderate siano riconosciuti dal computer.

Funzionamento:

Una volta configurata la comunicazione tra telecomando e computer, caricate TelecomandoIR_VLC.ino sul vostro Arduino. Questo sketch sarà in grado di svolgere 6 funzioni di base sul famoso software di riproduzione di file multimediali VLC:

1) play: avvia la riproduzione

2) volumeUp: alza il volume

3) volumeDown: abbassa il volume

4) forward: manda avanti la riproduzione più velocemente

5) backward: manda indietro la riproduzione più velocemente

6) mute: silenzia la riproduzione

I valori esadecimali derivanti dal modello del telecomando usato nel nostro caso sono stati:

  • play: 0x800F046E
  • volumeUp: 0x800F0410
  • volumeDown: 0x800F8411
  • forward: 0x800F8414
  • backward: 0x800F0415
  • mute: 0x800F040E

Lo sketch gestisce queste azioni tramite la funzione switch(results.value) che riceve come parametro il risultato del click sul telecomando.

Circuito su Fritzing:

Il modulo IR va connesso o saldato correttamente sul proprio Arduino Micro, collegando la resistenza ed il condensatore ai pin giusti.



Fritzing File


Clicca qui per scaricare il file Fritzing di questo progetto.

Il codice:

/* VLC IR REMOTE CONTROLLER
 *
 * Control your computer while using VLC
 * with any IR remote controller you want.
 *
 * Created by
 * Angelo Scialabba
 * Arturo Guadalupi
 *
 * Based on IRremote library by Ken Shirriff  
 */


#include <IRremote.h>
int RECV_PIN = 11;  //IR receiver connected on pin 11

//Change these values to match data sent by your remote control

/*-----COMMANDS------*/
const long play = 0x800F046E;  
const long volumeUp= 0x800F0410;
const long volumeDown= 0x800F8411;
const long forward= 0x800F8414;
const long backward= 0x800F0415;
const long mute= 0x800F040E;
/*-----END COMMANDS------*/

IRrecv irrecv(RECV_PIN);  //initialize IR library on RECV_PIN
decode_results results;   //received data will be stored here

void setup()
{
  irrecv.enableIRIn();  // Start the receiver
  Keyboard.begin();  //Start arduino as keyboard
}

void loop() {
  if (irrecv.decode(&results)) {
    switch(results.value){  //fetch received data
    case play:
      Keyboard.press(' ');
      break;
    case volumeUp:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_UP_ARROW);
      break;
    case volumeDown:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_DOWN_ARROW);
      break;
    case forward:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_RIGHT_ARROW);
      break;
    case backward:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ARROW);
      break;
    case mute:
      Keyboard.press('m');
      break;
    }
    delay(100);
    Keyboard.releaseAll();

    irrecv.resume(); // Receive the next value
  }
}





Slide-Lamps(e), la lampada dello Startupper!

Tieni sempre d'occhio la Slide-Lampse e fai attenzione che il tuo tempo a disposizione non scada!



La febbre delle Startup è in giro e magari anche voi ne siete già contagiati! Sempre più spesso ci troviamo a presentare un'idea, un progetto, una geniale innovazione a grandi e piccole platee, a singoli ipotetici finanziatori negli ascensori o in grandi pecha-kucha collettivi, con un tempo prefissato (Pechakucha.org). Altre volte invece, avrete la sventura di dover organizzare a vostra volta uno di questi eventi. Il progetto di questo mese è un timer per notificare che il tempo a disposizione di chi espone è finito.

Funzionamento:

La Slide-Lampse (allegro gioco di parole che indica "la lampada delle slides" tanto quanto "le slides che scorrono [lapse: tempo che passa/che si esaurisce]) é un’allarme a tempo basata sulla tipica sirena dei vigili del fuoco. Opportunamente programmata può accendersi dopo un periodo definito dalla partenza della presentazione. Testata in diverse presentazioni presso Toolbox Coworking a Torino, abbiamo aggiunto la possibilità di controllarla da lontano con un telecomando domestico.

Definito un certo tempo di durata della presentazione, la si può attivare con un eventuale semplice bottone o, come nel nostro caso, tramite un telecomando. La Slide-Lampse inizierà a girare illuminando la stanza ed informando gli astanti della fine del tempo disponibile

E' possibile intervenire sul suo comportamento facendola illuminare per 1 o 3 secondi in base al tasto del telecomando premuto.

Componenti:



Configurazione e connessioni:

Il sistema complessivo ha una configurazione simile a quella nella figura sottostante.



Ora vedremo come collegare ogni singolo componente nella maniera corretta.

  • Ricevitore ad infrarossi: Create un modulo TinkerKit personalizzato per il sensore TSOP collegandolo correttamente alla resistenza, al condensatore e ai corretti cavi colorati.


  1. GND: cavo nero
  2. 5V: cavo rosso
  3. SEGNALE: cavo arancione



Il circuto Fritzing equivalente è:



  • Alimentatore: Se il vostro alimentatore ha una spina di questo tipo:



potete svitare la spina e dissaldare i collegamenti (cavo rosso: polo positivo, cavo nero: polo negativo) oppure rimuoverla direttamente tagliandola.



  • Relè: Questo modulo è fondamentalmente un interruttore che, nel nostro progetto, rimane di default sempre aperto, a meno che non lo si chiuda tramite la funzione OFF().

Connettete:

  1. un cavo della lampada al terminale COM
  2. l'altro cavo della lampada al cavo nero dell'alimentatore
  3. il cavo rosso dell'alimentatore al terminale NO (Normally Open)



  • Arduino Uno + TinkerKit Sensor Shield: Connettete il modulo TinkerKit sulla Uno e collegate i cavi TinkerKit del sensore ad infrarossi sul terminale I0 (Input 0) e quelli del relè sul terminale O0 (Output 0).



Il codice:

Il codice di seguito riportato, funziona esclusivamente con un nostro vecchio telecomando. Ogni dispositivo ad infrarossi infatti, nell'inviare o ricevere dati, funziona utilizzando diverse frequenze, esprimibili in codici esadecimali (HEX).

Nel nostro caso, i tasti 1, 2, 3 e 4, equivalgono a:

  • 1: 0x80A oppure 0xA
  • 2: 0x80B oppure 0xB
  • 3: 0x80C oppure 0xC
  • 4: 0x80D oppure 0xD

Assegnando questi valori in una condizione IF, è possibile far accendere la lampada (funzione ON()), farla spegnere (OFF()), farla lampeggiare per 1 secondo (FLASH(1)) o per 3 secondi (FLASH(3)). Usando telecomandi diversi, le frequenze sfruttate dagli infrarossi saranno diverse. Quindi, è bene eseguire sempre una prima prova di configurazione.

Caricate lo sketch sul vostro Arduino ed aprite il monitor seriale. Cliccate ripetutamente un qualsiasi tasto che volete associare ad una delle quattro funzioni e vedrete comparire sul monitor dei numeri e delle lettere all'apparenza casuali. Come usare questi codici?

Cliccando il tasto 1 sul vostro telecomando, potreste ottenere dei valori tipo 4E2DC928 o 5719DA54. Aggiungete il codice "0x" come prefisso fino ad ottenere 0x4E2DC928 e 0x5719DA54 e sostituite questi valori ad una delle condizioni usate nel codice:

  • if((results.value == 0x80B ) || (results.value == 0xB)){
      ON();}

dovrà ad esempio diventare:

  • if((results.value == 0x4E2DC928 ) || (results.value == 0x5719DA54)){
      ON();}

In questo modo, potrete accendere la lampada, con i valori di frequenze usate dal tasto 1 del vostro telecomando. Aggiungete altri numeri ed altre funzioni a vostro piacimento e buon divertimento con i vostri progetti!

/*
 * Based on IRremote Library
 * by Ken Shirriff
 * http://arcfn.com
 */


#include <IRremote.h>
#include <TinkerKit.h>
int RECV_PIN = A0;

IRrecv irrecv(RECV_PIN);
decode_results results;
TKRelay relay(O0);

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    if((results.value == 0x80A ) || (results.value == 0xA)){
      OFF();
    }
    else  if((results.value == 0x80B ) || (results.value == 0xB)){
      ON();
    }
    else  if((results.value == 0x80C ) || (results.value == 0xC)){
      FLASH(1);
    }
    else  if((results.value == 0x80D ) || (results.value == 0xD)){
      FLASH(3);
    }
    irrecv.resume(); // Receive the next value
  }
}

void FLASH(int seconds){
  int i;
  int loops;
  loops = (seconds*1000) / 250;
  for (i = 0; i < loops; i++)  //flashes for n seconds
  {
    relay.on();
    delay(80);
    relay.off();
    delay(170);
  }
}
void ON(){
  relay.on();
}

void OFF(){
  relay.off();
}





Cat Feeder comandato da un cellulare

Sei in giro, lontano da casa, ed hai dimenticato di dar da mangiare al tuo tenero gatto? Chiedi aiuto al Cat Feeder!



Costruire un Cat Feeder con Arduino è un gioco da ragazzi. Hai bisogno di pochi componenti e di un cellulare che non usi più.

Funzionamento:

Un piccolo sensore di luce (LDR: light dependant resistor) fissato sullo schermo di un cellulare, ne rileva il cambiamento di luminosità e permette, tramite un micro servomotore, di aprire un barattolo contenente del cibo per gatti. Basterà una chiamata per attivare il Cat Feeder e lasciar cadere i croccantini!



Sarebbe opportuno utilizzare un numero di telefono che conoscete solo voi (o in pochi altri) in modo tale da essere sicuri che il vostro Cat Feeder funzioni solo quando deve. Il sistema di accensione descritto è eventualmente in grado di comandare qualsiasi altro tipo di dispositivo in casa. Se dovesse trattarsi di un elettrodomestico che funziona a tensioni più elevate, basterebbe utilizzare un modulo relè TinkerKit come uscita al posto del servomotore.

Componenti:

Opzionale: TinkerKit Relay Module: 10.7 €

Montaggio:

Una volta trovato un barattolo, un vaso o un qualsiasi contenitore della forma desiderata, è necessario tagliare la parte inferiore e fissarla al servomotore in maniera da consentire a quest'ultimo di aprire e chiudere il Cat Feeder. Il micro servomotore utilizzato per questo progetto può garantire al massimo 180° di rotazione dell'albero. Bisognerà impostare l'esatto valore che permetta al coperchio di rimanere aperto durante la chiamata e chiudersi perfettamente una volta finita.



Nel nostro caso, dopo alcune prove, abbiamo sperimentato che il Cat Feeder è aperto con una rotazione dell'albero motore di 120° e chiuso con una di 45°. Questi valori cambieranno ovviamente in base alla forma del contenitore o al tipo di fissaggio fatto sul servomotore, tra il coperchio e la base del barattolo. Quest'ultimo dovrà essere posto a testa in giù, sopra un piattino apposito, grande abbastanza da contenere tutto il cibo necessario.

Circuito su Fritzing:



Il sensore LDR:



Il funzionamento di questo sensore è molto semplice. Un LDR è fondamentalmente una resistenza a valore variabile, che dipende dall'intensità della luce incidente. Solitamente è usato sfruttando delle acquisizioni analogiche dei valori di luce ma, per semplificare ulteriormente il codice, questa volta è stato utilizzato come input digitale per l'Arduino:

Luce dello schermo rilevata-> Valore 1 (Cat Feeder aperto)
Schermo spento-> Valore 0 (Cat Feeder chiuso)



Questa estrema semplificazione rende assolutamente necessario fissare il sensore in perfetto contatto piano con lo schermo, senza alcun tipo dispersione di luce ai bordi o altrove. É consigliato all'occorrenza, avvolgere lo schermo con nastro nero o inserire il cellulare all'interno di una scatola chiusa, per evitare che l'LDR rilevi stati erronei di luminosità o buio.



Il codice:

#include <Servo.h>

Servo myServo;            // viene creato un oggetto "servomotore"
int sensorValue, first = 0;

void setup() {
  myServo.attach(9);      // Il servomotore è controllato dal pin 9
  Serial.begin(9600);     // La porta seriale è abilitata per eventuale debug
  while(digitalRead(8)) { // Il barattolo è inizialmente chiuso fino
    myServo.write(45);    // alla ricezione della prima chiamata
    first = 1;
  }
}

void loop() {
  if(first){
    sensorValue = digitalRead(8);
    if(sensorValue)       // Se il sensore ldr rileva della luce
      myServo.write(45);  // il servomotore chiude il contenitore
    else                  // altrimenti
      myServo.write(120); // il servomotore apre il contenitore
  }
}





Intercom-to-phone, parla al citofono con il tuo cellulare!



Ogni volta che qualcuno suonerà al citofono di casa vostra, Arduino effettuerà una telefonata verso il vostro cellulare permettendovi di parlare con chi è al citofono tramite il telefono. Verrà utilizzato un piezo e un servo motore per rilevare e attivare il citofono e uno shield GSM per chiamare il cellulare.

Componenti:

  • GSM Shield 69 €
  • Servo Motor 12.90 €
  • 10 pF Capacitor 0.90 €
  • 3x 33 pF Capacitors 0.90 €
  • 22 uF Capacitor 0.90 €
  • 68 Ohm Resistor 0.90 €
  • 1 MOhm Resistor 0.90 €
  • 5.1 V Zener Diode 0.25 €
  • Electret Mic 1 € (facilmente reperibile)
  • Speaker 2 € (facilmente reperibile)
  • Piezo buzzer 1.5 €

Funzionamento:

Come rilevare il citofono che suona

Il progetto è pensato per non essere invasivo, quindi per evitare qualsiasi modifica al citofono useremo un buzzer piezo per rilevare la citofonata. Quando le vibrazioni vengono captate dal piezo, esso genera una tensione che può essere rilevata dall' Arduino, in questo modo è possibile captare il suono emesso dal campanello e far capire al nostro Arduino che qualcuno sta suonando al citofono. L'unica cosa da fare è collegare il piezo all'Arduino come indicato in figura e posizionarlo in modo da essere poggiato sul citofono ed essere vicino alla fonte di suono del campanello. L'uitilizzo di una soglia permette di evitare dei falsi allarmi causati da vibrazioni ambientali non volute.

	//someone is ringing?
              if(analogRead(PIEZOPIN) > THRESHOLD) {



Attivazione del citofono

Per attivare il citofono quando qualcuno suona utilizziamo un servo per mantenere premuto il tasto che rileva la presenza della cornetta per poi muovere il servo in modo simulare la cornetta sollevata una volta rilevato il suono.

Connessioni audio GSM shield

Lo shield GSM supporta nativamente l'utilizzo di uno speaker e di un microfono per effettuare chiamate vocali, trasmettendo e ricevendo la nostra voce. Bisogna collegare il microfono e l'altoparlante in questo modo:







Collegare il citofono al GSM shield

Per collegare lo shield al citofono basta posizionare il microfono dello shield all'altoparlante della cornetta e l'altoparlante dello shield al microfono del citofono. Utilizzando questa soluzione non avremo la migliore qualità audio, ma è necessaria se non vogliamo effettuare nessun “hack” sul nostro citofono.

Codice

Per avere un codice funzioante dobbiamo modificare alcune variabili dipendendi dalle scelte che abbiamo fatto durante la costruzione del nostro progetto:

  • SERVOPIN, PIEZOPIN: queste due variabili indicano il pin a cui abbiamo collegato il servo motore e il buzzer.
  • RemoteNumber, PINNUMBER: queste varibili servono per il corretto funzionamento dello shield e sono rispettivamente il numero da chiamare e il pin della nostra scheda sim.
  • STARTPOS, ENDPOS: questi valori indicano le posizioni del server negli stati di citofono attivato e citofono disattivato rispettivamente e variano in base alla posizione in cui montiamo il nostro servo.

#include <GSM.h>
#include <Servo.h>

// PIN Number
String PINNUMBER =  ""
const int SERVOPIN = 9
const int THRESHOLD = 100 //Adjust your own threshold
const int PIEZOPIN = A0
const int STARTPOS = 120
const int ENDPOS = 160
// initialize the library instance
GSM gsmAccess; // include a 'true' parameter for debug enabled
GSMVoiceCall vcs;
Servo replyServo;
String remoteNumber = "0123456789";  // the number you will call
char charbuffer[20];

void setup()
{
 //initialize the Servo
 replyServo.attach(SERVOPIN);
 // connection state
 boolean notConnected = true;
   
 // Start GSM shield
 // If your SIM has PIN, pass it as a parameter of begin() in quotes
 while(notConnected)
 {
    if(gsmAccess.begin(PINNUMBER)==GSM_READY)
     notConnected = false;
    else
    {
     delay(1000);
    }
 }
  //prepare the string containing the phone number
 remoteNumber.toCharArray(charbuffer, 20);
}

void loop()
{

      //someone is ringing?
      if(analogRead(PIEZOPIN) > THRESHOLD) {

       
       // Check if the receiving end has picked up the call
       if(vcs.voiceCall(charbuffer))
       {
         //activate the intercom
         replyServo.write(STARTPOS);
         
         // Wait for the calling end
         while(vcs.getvoiceCallStatus()==TALKING);          
         //deactivate the intercom
         replyServo.write(ENDPOS);
         // And hang up
         vcs.hangCall();          
         
       }
       
      }
}


Costruisci un catamarano con due bottiglie di plastica e una ventola da pc. Comandalo tramite WiFi.

La struttura di questo catamarano è realizzata con semplici componenti facilmente reperibili in casa, Arduino e il WiFi shield lo renderanno pilotabile da qualsiasi dispositivo collegato alla rete dotato di un browser. L'interfaccia è molto intuitiva, uno slider su una pagina web consentirà di controllare la direzione della ventola da pc che fa sia da propulsore che da sterzo.

Lista dei componenti

  • 2 bottiglie di plastica da 0.5L
  • compensato o altro materiale per la struttura
  • 1 microservo
  • 1 ventola da PC di recupero
  • 1 mosfer IRF520
  • 1 Arduino Uno
  • 1 WiFi shield
  • 1 micro SD card da 1GB
  • 1 batteria da 9V con portabatteria

La struttura del catamarano

La struttura è composta da una scocca in compensato tagliata a laser, ma facilmente costruibile anche a casa con materiali differenti. Alla base sono invece incastrate due bottigliette di plastica da mezzo litro che permettono il galleggiamento del catamarano in acqua. Il cervello elettronico è prottetto dagli schizzi d'acqua da un case in materiale plastico traslucido.

La parte di movimento

La movimentazione avviene grazie a una vecchia ventola da PC che spostando l'aria gli permette di avanzare velocemente sul pelo dell'acqua; mentre la direzionalità viene impostata grazie ad ad un piccolo servomotore. In fine i comandi vengono passati al nostro catamarano grazie ad una Arduino Uno ed un WiFi Shield che pilotandolo in remoto tramite Hotspot WiFi.

Collegamenti:

Il micro servo è collegato al pin digitale 9 di Arduino, solitamente dei tre fili quello giallo o bianco è quello di controllo, mentre rosso e nero sono da collegare rispettivamente a 5V e GND. Le ventole da PC solitamente sono alimentate a 12V, siccome Arduino lavora a 5V è necessario interfacciare la ventola con un transistor che funzionerà come interruttore pilotato da Arduino. Nel nostro caso abbiamo usato un mosfet IRF520. Per i collegamenti seguite lo schema qui sotto:

Sketch con webserver che lo rende pilotabile da browser

Il cuore dello sketch è la creazione di un web server per realizzare la logica e l'interfaccia di controllo. Sarà quindi compito del webserver quello di offrire anche l'interfaccia per il controllo, così basterà collegarsi con un semplice browser da un qualsiasi PC, smarthphone o tablet che sia sulla stessa rete. Il servo viene comandato semplicemente grazie alla libreria "'Servo.h'". La parte più complessa e articolata è il codice che realizza il webserver, questo codice deve essere in grado di reagire alla richiesta di un nuovo browser (il client) che si collega fornendogli la pagina web con l'interfaccia di controllo. Una vola che il client è collegato è in grado di poter controllare il catamarano. Nell'interfaccia di controllo sono presenti uno slider e un pulsante. Lo slider serve per comandare la posizione del servo mentre col pulsante si può controllare lo stato della ventola. Ogni volta che lo slider viene spostato o il pulsante viene clickato parte una richiesta dal client e raggiunge il server (Arduino) che sarà in grado se interpretarla come uno spostamento del servo o l'accensione o spegnimento della ventola. Questo grossomodo è la spiegazione della logica di funzionamento. Per semplicità la parte di codice che riguarda solo l'interfaccia web è in un file separato che va caricato sulla microSD e verrà richiamato dallo sketch solo all'occorrenza.

Passi per realizzare il software:

  • copiare il file control.htm sulla microSD da 1GB. control.htm
  • inserire la microSD nell'apposito slot dello shield WiFi
  • copiare e incollare lo sketch nell'IDE
  • modificare la parte riguardante l'autenticazione alla rete, inserendo le credenziali della rete a cui ci si vuole collegare.
  • uploadare lo sketch sull'Arduino
  • aprire il monitor seriale e una volta che si è collegato alla rete leggere quale indirizzo IP gli è stato assegnato
  • inserire l'indirizzo IP in un browser
  • buona navigazione

Noi lo abbiamo provato in un laghetto artificiale facendo fare ad uno smartphone da hot spot WiFi. Con lo stesso smartphone ci siamo collegati poi all'Arduino per comandarlo!

Il codice:

#include <SPI.h>
#include <WiFi.h>
#include <SD.h>
#include <Servo.h>

// size of buffer used to capture HTTP requests
#define REQ_BUF_SZ   40

const int fanPin = 5;
Servo servo;

char ssid[] = "SSID name";        // write here the name of your network
char pass[] = "secret password";  // write here the WPA password of your network

int status = WL_IDLE_STATUS;

WiFiServer server(80);  // create a server at port 80
File webFile;
char HTTP_req[REQ_BUF_SZ] = {0}; // buffered HTTP request stored as null terminated string
char req_index = 0;              // index into HTTP_req buffer

boolean fanState = false;

void setup()
{
  servo.attach(9);
  pinMode(fanPin, OUTPUT);

  Serial.begin(9600);       // for debugging

  // check for the presence of the shield:
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue:
    while(true);
  }

  // attempt to connect to Wifi network:
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network. Change this line if using open or WEP network:    
    status = WiFi.begin(ssid, pass);

    // wait 10 seconds for connection:
    delay(10000);
  }

  printWifiStatus();

  // initialize SD card
  Serial.println("Initializing SD card...");
  if (!SD.begin(4)) {
    Serial.println("ERROR - SD card initialization failed!");
    return;    // init failed
  }
  Serial.println("SUCCESS - SD card initialized.");
  // check for index.htm file
  if (!SD.exists("control.htm")) {
    Serial.println("ERROR - Can't find index.htm file!");
    return;  // can't find index file
  }
  Serial.println("SUCCESS - Found index.htm file.");
  pinMode(3, INPUT);        // switch is attached to Arduino pin 3

  server.begin();           // start to listen for clients

}

void loop()
{
  WiFiClient client = server.available();  // try to get client

  if (client) {  // got client?
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {   // client data available to read
        char c = client.read(); // read 1 byte (character) from client
        // buffer first part of HTTP request in HTTP_req array (string)
        // leave last element in array as 0 to null terminate string (REQ_BUF_SZ - 1)
        if (req_index < (REQ_BUF_SZ - 1)) {
          HTTP_req[req_index] = c;          // save HTTP request character
          req_index++;
        }
        // last line of client request is blank and ends with \n
        // respond to client only after last line received
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: keep-alive");
          client.println();
          // Ajax request
          if (StrContains(HTTP_req, "fan")) {
            // read switch state and send appropriate paragraph text
            GetSwitchState(client);
          }
          else if(StrContains(HTTP_req, "dir=")) //strstr(HTTP_req, "dir=") != NULL)
          {
            client.println("OK");
            char *pch;
            pch = strtok(HTTP_req, " =");
            while (strcmp(pch, "/dir")) {
              pch = strtok(NULL, " =");
            }
            pch = strtok(NULL, " =");
            Serial.print("dir val: ");
            int dir = atoi(pch);
            Serial.println(dir);
            analogWrite(fanPin,   dir);
            servo.write(dir);
          }
          else {  // web page request
            // send web page
            webFile = SD.open("control.htm");        // open web page file
            if (webFile) {
              while(webFile.available()) {
                client.write(webFile.read()); // send web page to client
              }
              webFile.close();
            }
          }
          // display received HTTP request on serial port
          //Serial.println(HTTP_req);
          // reset buffer index and all buffer elements to 0
          req_index = 0;
          StrClear(HTTP_req, REQ_BUF_SZ);
          break;
        }
        // every line of text received from the client ends with \r\n
        if (c == '\n') {
          // last character on line of received text
          // starting new line with next character read
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          // a text character was received from client
          currentLineIsBlank = false;
        }
      } // end if (client.available())
    } // end while (client.connected())
    delay(1);      // give the web browser time to receive the data
    client.stop(); // close the connection
  } // end if (client)
}

// send the state of the switch to the web browser
void GetSwitchState(WiFiClient cl)
{
  fanState = !fanState;

  digitalWrite(fanPin, fanState);

  if (fanState) {
    cl.println("FAN is ON");
  }
  else {
    cl.println("FAN is OFF");
  }
}

// sets every element of str to 0 (clears array)
void StrClear(char *str, char length)
{
  for (int i = 0; i < length; i++) {
    str[i] = 0;
  }
}

// searches for the string sfind in the string str
// returns 1 if string found
// returns 0 if string not found
char StrContains(char *str, char *sfind)
{
  char found = 0;
  char index = 0;
  char len;

  len = strlen(str);

  if (strlen(sfind) > len) {
    return 0;
  }
  while (index < len) {
    if (str[index] == sfind[found]) {
      found++;
      if (strlen(sfind) == found) {
        return index;
      }
    }
    else {
      found = 0;
    }
    index++;
  }

  return 0;
}


void printWifiStatus() {
  // print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your WiFi shield's IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}


Dai la voce ad un mostriciattolo! Con un piccolo microfono controlleremo attraverso la nostra voce una bocca che parlerà al posto nostro.

Segui il tutorial per creare il tuo mostriciattolo parlante!


Attaccapanni Meteorologo

Segui il tutorial per creare il tuo attaccapanni!


Etilometro

Segui il tutorial per creare il tuo etilometro!


Bilancia Cloud

Il tutorial si trova su scuola.arduino.cc. Link diretto


TextMatrix

Il tutorial si trova su scuola.arduino.cc. Link diretto


Bagaglio a mano

Tramite un sensore di pressione tessile e un'arduino lilypad, che possono essere cuciti su uno zaino è possibile pesare il propprio bagaglio a mano ogni volta che lo si appoggia per terra.

Il tutorial si trova su scuola.arduino.cc. http://scuola.arduino.cc/lesson/Qe3EaKJ/A_cool_scale


Domotica fatta in casa

La domotica è cosa per pochi, difficile e pericolosa se fatta in casa, oltre che molto costosa. Assolutamente sbagliato!

Il tutorial si trova su scuola.arduino.cc. http://scuola.arduino.cc/courses/lessons/cover/NVkb1QZ


Il Tabellone Segnapunti

Il tutorial si trova su scuola.arduino.cc. http://scuola.arduino.cc/courses/lessons/cover/l81bRbQ


Telecamera Nascosta

Il tutorial si trova su scuola.arduino.cc. http://scuola.arduino.cc/courses/lessons/cover/Pj4PgDg






Ritorna a Playground Italiano

Share