Aiuto compilazione codice pilotare Luci tramite WEB

International Italiano Software
1

Buona sera a tutti!

Era da un po di tempo che desideravo finire questo progetto, e grazie al tempo a disposizione dell'ultimo periodo sono riuscito nell'intento!

Il mio scopo era quello di pilotare attraverso il mio arduino UNO rev3 una serie di luci e l'apertura di una serratura sia tramite web che tramite pulsanti, in modo che ovviamente quando utilizzo i pulsanti automaticamente sulla pagina web mi risulta lo stato di accensione delle luci!

Grazie al materiale trovato in rete sono riuscito a compilare il codice, funzionante al 100%.

Inizialmente caricavo lo sketch con l'IDE 1.0.5, ed il tutto era fluidissimo.
Ho riscontrato il problema però che la ethernet shield freezava dopo circa 2 giorni.

Così smanettando per il web ho letto che qualcuno è riuscito a risolvere il freeze semplicemente aggiornanedo l'IDE. Così ho scaricato l'ultimo IDE 1.8.2, aggiornato e caricato il codice.
Da quando l'ho fatto, il funzionamento via web è diventato molto macchinoso e poco fluido, e l'impulso non arriva più in maniera immediata, ma ci mette un po (in maniera piùttosto random) all'elaborazione.
Se invece utilizzo i pulsanti, il tutto è immediato ed anche l'aggiornamento sul server è ricettivo e piuttosto veloce.

Dato che non sono un campione di scrittura ho elaborato (soprattutto grazie al materiale trovato qui sul forum) un codice molto macchionso, che secondo me anderbbe di molto snellito a favore probabilmente della fluidità e della stabilità dell'impianto!

Nei commenti a seguire posto il codice.

Questo è molto lungo a causa delle ripetizioni utilizzate.
Ho pensato anche ad un array, ma non saprei come utilizzarlo nei vari void scritti all'inizio per la gestione web.

Il pin 8 inoltre gestisce una ventola puntata sopra l'hardware in modo da raffrescare i controllori. Lo so che è poco elegante utilizzare un timer piuttosto che un sensore di temperatura, ma già così il codice è pesante (78% dello spazio totale e 86% della memoria dinamica utilizzati). Snellendolo potrei pensare anche di utilizzare il sensore.

Temo di essere stato troppo prolisso.

Intanto ringrazio per le risorse messe a disposizione dal forum e di tutti i professionisti preparati che puntualmente ci aiutano nei nostri piccoli passi in questo affascinante mondo dei microcontrollori =) !

Buona notte a tutti!

Ferdinando

2 
#include <pins_arduino.h>
#include <SPI.h>
#include <Ethernet.h>
#include <Flash.h>
#include <SD.h>
#include <TinyWebServer.h>

int statoventola = LOW;             // stato ventola raffrescamento Arduino

unsigned long citofono = 1000;      //tempo in cui deve stare premuto il citofono in millisecondi
unsigned long zero;
unsigned long zeroventola = 0;      // will store last time LED was updated
const long tempoventola = 10000;     // interval at which to blink (milliseconds)

const int Bi1 = 2;
const int Bi2 = 3;
const int Bi3 = 5;
const int Bi4 = 6;

const int ventola =  8;   // the number of the LED pin

byte val1;
byte val2;
byte val3;
byte val4;

byte valold1;
byte valold2;
byte valold3;
byte valold4;

// The LED attached to PIN X on an Arduino board.

const int Li1 = A0;
const int Li2 = A1;
const int Li3 = A2;
const int Li4 = A3;
const int Li5 = A4;
const int Li6 = A5;

// pin 4 is the SPI select pin for the SDcard
const int SD_CS = 4;

// pin 10 is the SPI select pin for the Ethernet
const int ETHER_CS = 10;

// Don't forget to modify the IP to an available one on your home network
byte ip[] = { 192, 168, 0, 2 };
/*********************************************/

static uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

// The initial state of the LED

byte statoLed1;
byte statoLed2;
byte statoLed3;
byte statoLed4;
byte statoLed5;
byte statoLed6;

void setLedEnabled(boolean state) {
  statoLed1 = state;
  digitalWrite(Li1, state);
}

void setLed2Enabled(boolean state2) {
  statoLed2 = state2;
  digitalWrite(Li2, state2);
}
void setLed3Enabled(boolean state3) {
  statoLed3 = state3;
  digitalWrite(Li3, state3);
}
void setLed4Enabled(boolean state4) {
  statoLed4 = state4;
  digitalWrite(Li4, state4);
}
void setLed5Enabled(boolean state5) {
  statoLed5 = state5;
  digitalWrite(Li5, state5);
}

void setLed6Enabled(boolean state6) {
  statoLed6 = state6;
  digitalWrite(Li6, state6);
}

inline boolean getLedState() { return statoLed1; }
inline boolean getLedState2() { return statoLed2; }
inline boolean getLedState3() { return statoLed3; }
inline boolean getLedState4() { return statoLed4; }
inline boolean getLedState5() { return statoLed5; }
inline boolean getLedState6() { return statoLed6; }

boolean file_handler(TinyWebServer& web_server);
boolean blink_led_handler(TinyWebServer& web_server);
boolean blink_led2_handler(TinyWebServer& web_server);
boolean blink_led3_handler(TinyWebServer& web_server);
boolean blink_led4_handler(TinyWebServer& web_server);
boolean blink_led5_handler(TinyWebServer& web_server);
boolean blink_led6_handler(TinyWebServer& web_server);
boolean led_status_handler(TinyWebServer& web_server);
boolean led2_status_handler(TinyWebServer& web_server);
boolean led3_status_handler(TinyWebServer& web_server);
boolean led4_status_handler(TinyWebServer& web_server);
boolean led5_status_handler(TinyWebServer& web_server);
boolean led6_status_handler(TinyWebServer& web_server);
boolean index_handler(TinyWebServer& web_server);

TinyWebServer::PathHandler handlers[] = {
  // Work around Arduino's IDE preprocessor bug in handling /* inside
  // strings.
  //
  // `put_handler' is defined in TinyWebServer
  {"/", TinyWebServer::GET, &index_handler },
  {"/upload/" "*", TinyWebServer::PUT, &TinyWebPutHandler::put_handler },
  {"/blinkled6", TinyWebServer::POST, &blink_led6_handler },
  {"/blinkled5", TinyWebServer::POST, &blink_led5_handler },  
  {"/blinkled4", TinyWebServer::POST, &blink_led4_handler },
  {"/blinkled3", TinyWebServer::POST, &blink_led3_handler },
  {"/blinkled2", TinyWebServer::POST, &blink_led2_handler },
  {"/blinkled", TinyWebServer::POST, &blink_led_handler },
  {"/ledstatus6" "*", TinyWebServer::GET, &led6_status_handler },
  {"/ledstatus5" "*", TinyWebServer::GET, &led5_status_handler },
  {"/ledstatus4" "*", TinyWebServer::GET, &led4_status_handler },
  {"/ledstatus3" "*", TinyWebServer::GET, &led3_status_handler },
  {"/ledstatus2" "*", TinyWebServer::GET, &led2_status_handler },
  {"/ledstatus" "*", TinyWebServer::GET, &led_status_handler },
  {"/" "*", TinyWebServer::GET, &file_handler },
  {NULL},
};

const char* headers[] = {
  "Content-Length",
  NULL
};

TinyWebServer web = TinyWebServer(handlers, headers);

boolean has_filesystem = true;
Sd2Card card;
SdVolume volume;
SdFile root;
SdFile file;

void send_file_name(TinyWebServer& web_server, const char* filename) {
  if (!filename) {
    web_server.send_error_code(404);
    web_server << F("Could not parse URL");
  } else {
    TinyWebServer::MimeType mime_type
      = TinyWebServer::get_mime_type_from_filename(filename);
    web_server.send_error_code(200);
    web_server.send_content_type(mime_type);
    web_server.end_headers();
    if (file.open(&root, filename, O_READ)) {
      Serial << F("Read file "); Serial.println(filename);
      web_server.send_file(file);
      file.close();
    } else {
      web_server << ("Could not find file: ") << filename << "\n";
    }
  }
}

boolean file_handler(TinyWebServer& web_server) {
  char* filename = TinyWebServer::get_file_from_path(web_server.get_path());
  send_file_name(web_server, filename);
  free(filename);
  return true;
}

boolean blink_led_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  // Reverse the state of the LED.
  setLedEnabled(!getLedState());
  Client& client = web_server.get_client();
  if (client.available()) {
    char ch = (char)client.read();
    if (ch == '0') {
      setLedEnabled(false);
    } else if (ch == '1') {
      setLedEnabled(true);
    }
  }
  return true;
}

boolean blink_led2_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  // Reverse the state of the LED.
  setLed2Enabled(!getLedState2());
  Client& client = web_server.get_client();
  if (client.available()) {
    char ch = (char)client.read();
    if (ch == '0') {
      setLed2Enabled(false);
    } else if (ch == '1') {
      setLed2Enabled(true);
    }
  }
  return true;
}

boolean blink_led3_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  // Reverse the state of the LED.
  setLed3Enabled(!getLedState3());
  Client& client = web_server.get_client();
  if (client.available()) {
    char ch = (char)client.read();
    if (ch == '0') {
      setLed3Enabled(false);
    } else if (ch == '1') {
      setLed3Enabled(true);
    }
  }
  return true;
}

boolean blink_led4_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  // Reverse the state of the LED.
  setLed4Enabled(!getLedState4());
  Client& client = web_server.get_client();
  if (client.available()) {
    char ch = (char)client.read();
    if (ch == '0') {
      setLed4Enabled(false);
    } else if (ch == '1') {
      setLed4Enabled(true);
    }
  }
  return true;
}

boolean blink_led5_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  // Reverse the state of the LED.
  setLed5Enabled(!getLedState5());
  Client& client = web_server.get_client();
  if (client.available()) {
    char ch = (char)client.read();
    if (ch == '0') {
      setLed5Enabled(false);
    } else if (ch == '1') {
      setLed5Enabled(true);
    }
  }
  return true;
}

boolean blink_led6_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  // Reverse the state of the LED.
  setLed6Enabled(!getLedState6());
  Client& client = web_server.get_client();
  if (client.available()) {
    char ch = (char)client.read();
    if (ch == '0') {
      setLed6Enabled(false);
    } else if (ch == '1') {
      setLed6Enabled(true);
      zero = millis();
    }
  }
  return true;
}
3 
boolean led_status_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  Client& client = web_server.get_client();
  client.println(getLedState(), DEC);
  return true;
}

boolean led2_status_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  Client& client = web_server.get_client();
  client.println(getLedState2(), DEC);
  return true;
}

boolean led3_status_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  Client& client = web_server.get_client();
  client.println(getLedState3(), DEC);
  return true;
}

boolean led4_status_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  Client& client = web_server.get_client();
  client.println(getLedState4(), DEC);
  return true;
}

boolean led5_status_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  Client& client = web_server.get_client();
  client.println(getLedState5(), DEC);
  return true;
}

boolean led6_status_handler(TinyWebServer& web_server) {
  web_server.send_error_code(200);
  web_server.send_content_type("text/plain");
  web_server.end_headers();
  Client& client = web_server.get_client();
  client.println(getLedState6(), DEC);
  return true;
}

boolean index_handler(TinyWebServer& web_server) {
  send_file_name(web_server, "INDEX.HTM");
  return true;
}

void file_uploader_handler(TinyWebServer& web_server,
   TinyWebPutHandler::PutAction action,
   char* buffer, int size) {
  static uint32_t start_time;
  static uint32_t total_size;

  switch (action) {
  case TinyWebPutHandler::START:
    start_time = millis();
    total_size = 0;
    if (!file.isOpen()) {
      // File is not opened, create it. First obtain the desired name
      // from the request path.
      char* fname = web_server.get_file_from_path(web_server.get_path());
      if (fname) {
 Serial << F("Creating ") << fname << "\n";
 file.open(&root, fname, O_CREAT | O_WRITE | O_TRUNC);
 free(fname);
      }
    }
    break;

  case TinyWebPutHandler::WRITE:
    if (file.isOpen()) {
      file.write(buffer, size);
      total_size += size;
    }
    break;

  case TinyWebPutHandler::END:
    file.sync();
    Serial << F("Wrote ") << file.fileSize() << F(" bytes in ")
   << millis() - start_time << F(" millis (received ")
           << total_size << F(" bytes)\n");
    file.close();
  }
}

void setup() {
 
  Serial.begin(115200);
  Serial << F("Free RAM: ") << FreeRam() << "\n";

  pinMode(Li1, OUTPUT);
  pinMode(Li2, OUTPUT);
  pinMode(Li3, OUTPUT);
  pinMode(Li4, OUTPUT);
  pinMode(Li5, OUTPUT);
  pinMode(Li6, OUTPUT);
  pinMode(Bi1, INPUT);
  pinMode(Bi2, INPUT);
  pinMode(Bi3, INPUT);
  pinMode(Bi4, INPUT);
  pinMode(ventola, OUTPUT);
  
  setLedEnabled(false);
  setLed2Enabled(false);
  setLed3Enabled(false);
  setLed4Enabled(false);
  setLed5Enabled(false);
  setLed6Enabled(false);

  pinMode(SS_PIN, OUTPUT); // set the SS pin as an output
                                // (necessary to keep the board as
                                // master and not SPI slave)
  digitalWrite(SS_PIN, HIGH); // and ensure SS is high

  // Ensure we are in a consistent state after power-up or a reset
  // button These pins are standard for the Arduino w5100 Rev 3
  // ethernet board They may need to be re-jigged for different boards
  pinMode(ETHER_CS, OUTPUT); // Set the CS pin as an output
  digitalWrite(ETHER_CS, HIGH); // Turn off the W5100 chip! (wait for
                                // configuration)
  pinMode(SD_CS, OUTPUT);       // Set the SDcard CS pin as an output
  digitalWrite(SD_CS, HIGH); // Turn off the SD card! (wait for
                                // configuration)

  // initialize the SD card.
  Serial << F("Setting up SD card...\n");
  // Pass over the speed and Chip select for the SD card
  if (!card.init(SPI_FULL_SPEED, SD_CS)) {
    Serial << F("card failed\n");
    has_filesystem = false;
  }
  // initialize a FAT volume.
  if (!volume.init(&card)) {
    Serial << F("vol.init failed!\n");
    has_filesystem = false;
  }
  if (!root.openRoot(&volume)) {
    Serial << F("openRoot failed");
    has_filesystem = false;
  }

  if (has_filesystem) {
    // Assign our function to `upload_handler_fn'.
    TinyWebPutHandler::put_handler_fn = file_uploader_handler;
  }

  // Initialize the Ethernet.
  Serial << F("Setting up the Ethernet card...\n");
  Ethernet.begin(mac, ip);

  // Start the web server.
  Serial << F("Web server starting...\n");
  web.begin();

  Serial << F("Ready to accept HTTP requests.\n");
}

void loop() { 
  
  unsigned long nuovotempo = millis();
  if (nuovotempo - zeroventola >= tempoventola) {
    zeroventola = nuovotempo;
    
    if ( statoventola == LOW) {
      statoventola = HIGH;    
    }    else {
    statoventola = LOW;
  }
digitalWrite (ventola, statoventola);
  }
  if (digitalRead(Li6 == HIGH )) {
      if(millis() - zero > citofono)
        setLed6Enabled(false);}
  
  if (has_filesystem) {
    web.process();
  }
  
  val1 = digitalRead(Bi1);
  val2 = digitalRead(Bi2);
  val3 = digitalRead(Bi3);
  val4 = digitalRead(Bi4);
  
  if (val1 == HIGH && (valold1 == LOW)) {
    statoLed1 = 1 - statoLed1;
    delay(30);
  }
  if (val2 == HIGH && (valold2 == LOW)) {
    statoLed2 = 1 - statoLed2;
    delay(30);
  }
  if (val3 == HIGH && (valold3 == LOW)) {
    statoLed3 = 1 - statoLed3;
    delay(30);
  }
  if (val4 == HIGH && (valold4 == LOW)) {
    statoLed4 = 1 - statoLed4;

    delay(30);
  }
  
  valold1 = val1;
  valold2 = val2;
  valold3 = val3;
  valold4 = val4;
  
  if (statoLed1 == 1) {
    digitalWrite(Li1, HIGH);
  } else {
    digitalWrite(Li1, LOW);
  } 
  
  if (statoLed2 == 1) {
    digitalWrite(Li2, HIGH);
  } else {
    digitalWrite(Li2, LOW);
  } 
  
  if (statoLed3 == 1) {
    digitalWrite(Li3, HIGH);
  } else {
    digitalWrite(Li3, LOW);
  } 
  
  if (statoLed4 == 1) {
    digitalWrite(Li4, HIGH);
  } else {
    digitalWrite(Li4, LOW);
  }  
}

--- ti rammento che da regolamento è permesso fare "up" solo DOPO almeno 48 ore dall'ultimo post, Grazie. - gpb01

4

C'è qualcuno che puo aiutarmi ? :frowning: