hulp bij domotica webserver nodig. (bijna klaar)

[-zuur- Profiel Privébericht]

hallo,

ik heb een probleempje.
er is zat te vinden op internet over web servers en domotica van KAKU schakelaars.

nu heb ik de web pagina zover klaar en de arduino code bijna!

alles werkt TOT ik een 2e mySwitch.send(""); er in zet.

ik kan dus een if mySwitch.send("010100000000000000010101"); en een els mySwitch.send("010100000000000000010101"); werkend krijgen.

maar zodra ik dit doe met een 2e button start de web pagina al niet meer op.

ik heb het idee dat dit komt omdat er in het begin via boolean de ledstate op 0 wordt gezet.
dus dan verzend hij in 1 keer alle OFF codes (denk ik)

iemand enig idee hoe dit op te lossen??

web pagina gebaseerd op ajax.

Code: Alles selecteren

 

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

#define CODE_D1_ON 010100000000000000010101   
#define CODE_D1_OFF 010100000000000000010100 
#define CODE_D2_ON 010100000100000000010101
#define CODE_D2_OFF 010100000100000000010100
#define CODE_D3_ON 010100000001000000010101
#define CODE_D3_OFF 010100000001000000010100
#define CODE_D4_ON 010100000101000000010101
#define CODE_D4_OFF 010100000101000000010100

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


byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };  // MAC address from Ethernet shield sticker under board
IPAddress ip(192, 168, 1, 30);                      // IP address, may need to change depending on network
EthernetServer server(80);                            // create a server at port 80
File webFile;                                         // the web page file on the SD card
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 LED_state[4] = {0};                           // stores the states of the LEDs
RCSwitch mySwitch = RCSwitch();

void setup()
{
    // disable Ethernet chip
    pinMode(10, OUTPUT);
    digitalWrite(10, HIGH);
    pinMode(6, OUTPUT);
   
    mySwitch.enableTransmit(6);// Transmitter is connected to Arduino Pin #6
   
    Serial.begin(9600);       // for debugging
   
    // initialize SD card
    delay(1);
    Serial.println("Initializing SD card...");
    if (!SD.begin(4)) {
      delay(1);
        Serial.println("ERROR - SD card initialization failed!");
        return;    // init failed
    }
    delay(1);
    Serial.println("SUCCESS - SD card initialized.");
    // check for index.htm file
    if (!SD.exists("index.htm")) {
      delay(1);
        Serial.println("ERROR - Can't find index.htm file!");
        return;  // can't find index file
    }
    delay(1);
    Serial.println("SUCCESS - Found index.htm file.");
    // switches on pins 2, 3 and 5
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    pinMode(5, INPUT);
    // LEDs
   
   
    Ethernet.begin(mac, ip);  // initialize Ethernet device
    server.begin();           // start to listen for clients
}

void loop()
{
    EthernetClient 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
                // limit the size of the stored received HTTP request
                // 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");
                    // remainder of header follows below, depending on if
                    // web page or XML page is requested
                    // Ajax request - send XML file
                    if (StrContains(HTTP_req, "ajax_inputs")) {
                        // send rest of HTTP header
                        client.println("Content-Type: text/xml");
                        client.println("Connection: keep-alive");
                        client.println();
                        SetLEDs();
                        // send XML file containing input states
                        XML_response(client);
                    }
                    else {  // web page request
                        // send rest of HTTP header
                        client.println("Content-Type: text/html");
                        client.println("Connection: keep-alive");
                        client.println();
                        // send web page
                        webFile = SD.open("index.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.print(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)
}

// checks if received HTTP request is switching on/off LEDs
// also saves the state of the LEDs
void SetLEDs(void)
{
    // LED 1 (pin 6)
    if (StrContains(HTTP_req, "LED1=1")) {
        LED_state[0] = 1;  // save LED state
        mySwitch.send("010100000000000000010101");
        delay(1);
            Serial.println("Led D1 On");
    }
    else if (StrContains(HTTP_req, "LED1=0")) {
        LED_state[0] = 0;  // save LED state
       mySwitch.send("010100000000000000010100");
       delay(10);
            Serial.println("Led D1 Off");
    }
    // LED 2 (pin 7)
    if (StrContains(HTTP_req, "LED2=1")) {
        LED_state[1] = 1;  // save LED state
        digitalWrite(7, HIGH);
        Serial.println("Led D2 On");
    }
    else if (StrContains(HTTP_req, "LED2=0")) {
        LED_state[1] = 0;  // save LED state
        digitalWrite(7, LOW);
        Serial.println("Led D2 Off");
    }
    // LED 3 (pin 8)
    if (StrContains(HTTP_req, "LED3=1")) {
        LED_state[2] = 1;  // save LED state
        digitalWrite(8, HIGH);
        Serial.println("Led D3 On");
    }
    else if (StrContains(HTTP_req, "LED3=0")) {
        LED_state[2] = 0;  // save LED state
        digitalWrite(8, LOW);
        Serial.println("Led D3 Off");
    }
    // LED 4 (pin 9)
    if (StrContains(HTTP_req, "LED4=1")) {
        LED_state[3] = 1;  // save LED state
        digitalWrite(9, HIGH);
        Serial.println("Led D4 On");
    }
    else if (StrContains(HTTP_req, "LED4=0")) {
        LED_state[3] = 0;  // save LED state
        digitalWrite(9, LOW);
        Serial.println("Led D4 Off");
    }
}

// send the XML file with analog values, switch status
//  and LED status
void XML_response(EthernetClient cl)
{
    int analog_val;            // stores value read from analog inputs
    int count;                 // used by 'for' loops
    int sw_arr[] = {2, 3, 5};  // pins interfaced to switches
   
    cl.print("<?xml version = \"1.0\" ?>");
    cl.print("<inputs>");
    // read analog inputs
    for (count = 2; count <= 5; count++) { // A2 to A5
        analog_val = analogRead(count);
        cl.print("<analog>");
        cl.print(analog_val);
        cl.println("</analog>");
    }
    // read switches
    for (count = 0; count < 3; count++) {
        cl.print("<switch>");
        if (digitalRead(sw_arr[count])) {
            cl.print("ON");
        }
        else {
            cl.print("OFF");
        }
        cl.println("</switch>");
    }
    // checkbox LED states
    // LED1
    cl.print("<LED>");
    if (LED_state[0]) {
        cl.print("checked");
    }
    else {
        cl.print("unchecked");
    }
    cl.println("</LED>");
    // LED2
    cl.print("<LED>");
    if (LED_state[1]) {
        cl.print("checked");
    }
    else {
        cl.print("unchecked");
    }
     cl.println("</LED>");
    // button LED states
    // LED3
    cl.print("<LED>");
    if (LED_state[2]) {
        cl.print("on");
    }
    else {
        cl.print("off");
    }
    cl.println("</LED>");
    // LED4
    cl.print("<LED>");
    if (LED_state[3]) {
        cl.print("on");
    }
    else {
        cl.print("off");
    }
    cl.println("</LED>");
   
    cl.print("</inputs>");
}

// 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 1;
            }
        }
        else {
            found = 0;
        }
        index++;
    }

    return 0;
}

[nicoverduin Profiel PrivéberichtWebsite]

Weet jij hoe groot je RAM geheugen is? M.a.w. ga je niet over je 2K heen?

@edit: ff je programma door Eclipse gehaald en het zou me niks verbazen dat je door de grens gaat.
Jouw programma door Eclipse gehaald:

Code: Alles selecteren

Program:   28566 bytes (87.2% Full)
(.text + .data + .bootloader)

Data:       1862 bytes (90.9% Full)
(.data + .bss + .noinit)


Hier moeten nog dynamisch gealloceerd geheugen af + buffertjes die nog hier en daar gebruikt worden. zou zo maar kunnen. Als je een Mega2560 hebt zou je kunnen proberen of hij het daar wel doet. Dan is het vrijwel zeker het RAM geheugen.

[-zuur- Profiel Privébericht]

Sketch uses 28.482 bytes (88%) of program storage space. Maximum is 32.256 bytes.
Global variables use 1.857 bytes (90%) of dynamic memory, leaving 191 bytes for local variables. Maximum is 2.048 bytes.
Weinig geheugen beschikbaar, er kunnen zich stabiliteitsproblemen voordoen



dus het moet nog prima te doen zijn. (1 button)

Sketch uses 28.672 bytes (88%) of program storage space. Maximum is 32.256 bytes.
Global variables use 2.011 bytes (98%) of dynamic memory, leaving 37 bytes for local variables. Maximum is 2.048 bytes.
Weinig geheugen beschikbaar, er kunnen zich stabiliteitsproblemen voordoen

dit is met 4 buttons dat is kantje boord.

maar zelfs met 2 buttons doet hij het niet.

en zijn er anders hints / methodes hoe het geheugen te besparen??

edit : helaas heb ik geen mega alleen een uno waar ik mee werk.
zijn er bijvoorbeeld delen die ik uit een libary kan halen om geheugen te besparen??

[nicoverduin Profiel PrivéberichtWebsite]

Je kan kijken of je nog een zooi constantes in het flash geheugen kan stoppen. zie: http://forum.arduino.cc/index.php/topic,37337.0.html
Daarnaast kun je kijken of je alle global variabelen ook echt global moet hebben. Als ze alleen in de functies worden gebruikt zou een local variabele een overweging kunnen zijn.
Maar de meeste besparingen zijn meestal te halen door constantes lekker in Flash te houden. Nu gaat de Arduino bij het opstarten elke constante kopieren naar het RAM geheugen en dat is feitelijk zonde.

[-zuur- Profiel Privébericht]

bedankt voor de link ik ga zeker nog even kijken naar die constantes.

ik heb het nu geprobeerd met zo min mogelijk serial prints en dan zit ik op 85% helaas draait hij dan ook nog niet met de 2e button.

ik verander gewoon van // LED 2 (pin 7)

de digital write naar een myswitch.send met binairy.

[lex Profiel Privébericht]

Het schijnt wel mogelijk te zijn om het geheugen uit te breiden. De Mega heeft zo n zo al 256 KB aan board.

Ik Vond.

http://hackaday.com/2011/09/05/upgrading-ram-in-an-arduino-mega/

http://andybrown.me.uk/wk/2011/08/28/512kb-sram-expansion-for-the-arduino-mega-design/

Voor de mega is het dus wel mogelijk het werk geheugen uit te bereiden naar 512KB

http://majolsurf.net/projects/documents/100927%20Arduino%20Amani%20SRAM%20Expansion%20v1d0.pdf

[nicoverduin Profiel PrivéberichtWebsite]

Nou ik zou eerst dat artikel ff goed doorlezen voordat je deze toch wel wat "te snelle" conclusie trekt...
Wat de chip kan is geheugen banken adresseren in stukken van (ik geloof 64K). Echter de compiler zelf weet/kan dat niet. Dus zul je als je dit geheugen wil benaderen dynamisch (dus in jouw programma) moeten besturen. Het iis dus niet zo dat als jij denkt ik knikker in mijn source een stuk tekst van iets van 32KB als constantes dat dit automatisch goed gaat.
Dit soort oplossingen zijn zinvol als je bijvoorbeeld met grote tabellen gaat werken in het geheugen en veel geheugen operaties moet doen.
In jouw geval zou ik eerder kijken of :
- constantes in Flash gooien (alhoewel dat ook beperkt begint te worden of
- grotere board gebruiken of
- web oagina's zelf op een SD kaart gooien en die laden als je ze nodig hebt

@edit:
Ik zou nog steeds voorlopig gaan voor het Flashgeheugen voor de constantes. Ze staan er in de gewone situatie toch al in. Immers als de processor opstart is het RAM geheugen willekeurig. Bij het opstarten (reset of power-up) gaat de processor eerst alle constantes kopiëren van het FLASH geheugen naar het RAM geheugen. Dan kun je beter de F macro gebruiken. dan wordt het opstarten ook iets sneller omdat hij niet meer die kopieerslag maakt.

[-zuur- Profiel Privébericht]

Bedankt voor de reacties weer.
ik ga eerst eens kijken of ik wat constants in het flash geheugen kan gaan zetten.
Kijken of dit helpt.

[-zuur- Profiel Privébericht]

Vanavond ben ik even snel bezig geweest met de constants (voor mij nog best nieuw)
en met het om zetten van RAM naar Flash

ik heb de laatste dagen weinig tijd gehad.

ik heb nu ook geleerd hoe ik mijn beschikbare memory kan uit lezen en dit zat echt super laag. (130 en lager)
na vanavond een klein beginnetje gemaakt te hebben heb ik nu al weer 387 met 2 switchen werkend!!!
het max licht bij de arduino uno dacht ik rond de 1850 maar dan is je sketch compleet leeg op 1 include, een serial start en een println na.

nu wordt het verder opbouwen en de rest in flash laten draaien.

het is dut toch hoogst waarschijnlijk een memory probleem.

nico verduin bedankt voor de duidelijke hulp!
ik heb er weer veel van geleerd!

[-zuur- Profiel Privébericht]

nu mijn sketch goed draaid heb ik het refresh probleem nog steeds.
als ik alles aan zet. (3 checkboxen) en ik refresh de pagina dan staan alle checkboxen automatische uit.....
er gebeurt nog niks TOT ik 1 checkbox aan klik.
dan gaat het script alle checkboxen weer na wat de status is en dan laat hij de aan geklikte checkbox aan en de andere 2 schakelt hij uit.

niet echt handig als je tv ook op zo'n checkbox zit.....

is er een mogelijkheid om bij een pagina verversing eerst de checkboxen te controleren op de laatst gedane actie?

ik denk dat dit met een log file moet maar ik heb geen idee hoe.