Arduino - Speicheroptimierung?

von Wolfram F. (mega-hz)

26.01.2017 10:04

Lesenswert?

•

Hallo,

für meine Haussteuerung habe ich einen Arduino Uno mit 32 Ein- und 32 
Ausgängen (74HC165 & 74HC595), Ethernet für die Webseite und CAN-Bus mit 
MCP2515 aufgebaut.
Manche haben den IO-Webserver schon aufgerufen,
   http://mega-hz.dnshome.de:85
die IOs funktionieren ja schon, aber ich habe nicht mehr genug Speicher 
frei um die Can-Bus routinen einzubauen.
Da ich eher der Hardworker bin, bitte ich Euch um Hilfe, den Code zu 
optimieren!

hier das Listing:

/*--------------------------------------------------------------
Arduino HOME-SYS
--------------------------------------------------------------*/
#include <SPI.h>
#include <Ethernet.h>
#include <SD.h>
#include <mcp_can.h>
#define REQ_BUF_SZ   60
unsigned char len = 0;
unsigned char rxBuf[8];
#define CAN0_INT 2                              // Set INT to pin 2
MCP_CAN CAN0(9);                               // Set CS to pin 9
// Pin- und Variablen-Definierung des 32 Kanal SHIFT-IN-SHIELDs 
uint8_t IN_loadPin = 5;         // per Jumper wählbar D2 - D11
uint8_t IN_dataPin = 6;         // per Jumper wählbar D2 - D11
uint8_t IN_clockPin = 3;         // per Jumper wählbar D2 - D11
uint8_t Input[32] = {};
uint32_t Inputs = 0;
// Pin- und Variablen-Definierung des 32 Kanal SHIFT-OUT-SHIELDs 
uint8_t OUT_latchPin = 8;         // per Jumper wählbar D2 - D11
uint8_t OUT_dataPin = 7;          // per Jumper wählbar D2 - D11
uint8_t OUT_clockPin = 3;         // per Jumper wählbar D2 - D11
uint32_t Outputs = 0;
// Ethernet Shield benutzt 10,11,12,13! SD-Card CS = 4 !
// MAC address from Ethernet shield sticker under board
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 2, 231); // IP address, may need to change depending on network
EthernetServer server(85);  // 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
unsigned char LED_state[4] = {0}; // stores the states of the LEDs
void setup()
delay(2000);                        // gib dem Controller Zeit für den Upload
pinMode(IN_dataPin, INPUT);
pinMode(IN_loadPin, OUTPUT);
pinMode(IN_clockPin, OUTPUT);
pinMode(OUT_latchPin, OUTPUT);
pinMode(OUT_clockPin, OUTPUT);
pinMode(OUT_dataPin, OUTPUT);
digitalWrite(IN_dataPin, LOW);      // Pullups abschalten
digitalWrite(OUT_clockPin, LOW);
digitalWrite(IN_clockPin, LOW);
digitalWrite(IN_loadPin, LOW);
digitalWrite(OUT_latchPin, LOW);
digitalWrite(OUT_dataPin, LOW);
pinMode(A0,OUTPUT);
digitalWrite(A0,LOW);
pinMode(A1,OUTPUT);
digitalWrite(A1,LOW);
    int i;
    // disable Ethernet chip
    pinMode(10, OUTPUT);
    digitalWrite(10, HIGH);
   // initialize SD card
    if (!SD.begin(4)) {
        digitalWrite(A1,HIGH);
    // check for web-io.htm file
    if (!SD.exists("/WEB-IO.HTM")) {
        digitalWrite(A1,HIGH);
        digitalWrite(A1,LOW);
    Ethernet.begin(mac, ip);  // initialize Ethernet device
    server.begin();           // start to listen for clients
// ---------------------------------------------------------------------
// ZU WENIG SPEICHER für die CAN-BUS Routinen!
// ---------------------------------------------------------------------
//    CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_16MHZ);                                
//    CAN0.setMode(MCP_NORMAL);   // Change to normal mode to allow messages to be transmitted
    pinMode(CAN0_INT, INPUT);                            // Configuring pin for /INT input
// ---------------------------------------------------------------------
clr_Outputs();
void loop()
//    canbus();
EthernetClient client = server.available();  // try to get client
    if (client) {  // got client?
        boolean currentLineIsBlank = true;
        while (client.connected()) 
            digitalWrite(A0,HIGH);
            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);
                    {  // 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("/WEB-IO.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
                    // reset buffer index and all buffer elements to 0
                    req_index = 0;
                    StrClear(HTTP_req, REQ_BUF_SZ);
                // 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(2);      // give the web browser time to receive the data
        client.stop(); // close the connection
        digitalWrite(A0,LOW);
    } // end if (client)
// checks if received HTTP request is switching on/off LEDs
// also saves the state of the LEDs
void SetLEDs(void)
    char str_on[12] = {0};
    char str_off[12] = {0};
    unsigned char i;
    unsigned int  j;
    int LED_num = 0;
    for (i = 0; i < 4; i++) 
        for (j = 1; j <= 0x80; j <<= 1) 
            sprintf(str_on,  "LED%d=%d", LED_num, 1);
            sprintf(str_off, "LED%d=%d", LED_num, 0);
            if (StrContains(HTTP_req, str_on)) 
                LED_state[i] |= (unsigned char)j;  // save LED state
                bitSet(Outputs,LED_num);
            else if (StrContains(HTTP_req, str_off)) 
                LED_state[i] &= (unsigned char)(~j);  // save LED state
                bitClear(Outputs,LED_num);
            LED_num++;
                shiftOut32(Outputs);
// send the XML file with analog values, switch status
//  and LED status
void XML_response(EthernetClient cl)
    unsigned char i;
    unsigned int  j;
    cl.print("<?xml version = \"1.0\" ?>");
    cl.print("<inputs>");
    for (i = 0; i < 4; i++) 
        for (j = 1; j <= 0x80; j <<= 1) 
            cl.print("<LED>");
            if ((unsigned char)LED_state[i] & j) 
                cl.print("checked");
            else {
                cl.print("unchecked");
            cl.println("</LED>");
 shiftIn32();  
  for( uint8_t i = 0; i<32; i++ )
            cl.print("<switch>");
            if (Input[i])
                cl.print("checked");
            else {
                cl.print("unchecked");
            cl.println("</switch>");
    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;
//-----------------------------------------------------------------------------------------------------------------
void clr_Outputs() // - Bitmuster Übergabe an Shift-Routine
//-----------------------------------------------------------------------------------------------------------------
  Outputs = 0x00000000; // alle Ausgänge aus              
  shiftOut32(Outputs);  
//-----------------------------------------------------------------------------------------------------------------
// 32 Bit ShiftOut Routine für 4x 74HTC595 - Hauptroutine SHIFT-OUT Shield, kopiere diese in dein Listing!
//-----------------------------------------------------------------------------------------------------------------
void shiftOut32(uint32_t val)
  byte i;
  byte i1;
  byte Sbyte;
  byte shiftNo;       
  digitalWrite(OUT_latchPin, LOW);    // Latch-Output disablen, während übertragen wird
        Sbyte = val;
        for (i1 = 0; i1 < 4; i1++) 
          for (i = 0; i < 8; i++)  
            digitalWrite(OUT_dataPin, !!(Sbyte & (1 << i)));
            digitalWrite(OUT_clockPin, HIGH);
            digitalWrite(OUT_clockPin, LOW);
          shiftNo += 8;
          Sbyte = val >> shiftNo;
  digitalWrite(OUT_latchPin, HIGH);    // Latch-Output enablen, nach der Übertragung
  digitalWrite(OUT_clockPin, LOW);
//-----------------------------------------------------------------------------------------------------------------
// 32 Bit ShiftIn Routine für 4x 74HC165 - Hauptroutine SHIFT-IN Shield, kopiere diese in dein Listing!
//-----------------------------------------------------------------------------------------------------------------
uint32_t shiftIn32( void )
  digitalWrite(IN_loadPin, LOW);
  digitalWrite(IN_loadPin, HIGH);
  for( uint8_t i = 0; i<32; i++ )
    Inputs >>= 1;
    if( digitalRead(IN_dataPin))
        Inputs |= 0x80000000;
        Input[i] = 1;
     else
        Input[i] = 0;
    digitalWrite(IN_clockPin, HIGH);
    digitalWrite(IN_clockPin, LOW);
return Inputs;
//-----------------------------------------------------------------------------------------------------------------
void canbus()                               // erstmal nur zum testen...
long unsigned int rxId;
        digitalWrite(A1,HIGH);
  // send data:  ID = 0x100, Standard CAN Frame, Data length = 8 bytes, 'data' = array of data bytes to send
  int pwm_count = random(255);
  byte data[8] = {0x10, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
  byte data2[8] = {0x81, pwm_count, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  byte sndStat1 = CAN0.sendMsgBuf(0x101, 0, 8, data);
  byte sndStat2 = CAN0.sendMsgBuf(0x777, 0, 8, data2);
  byte sndStat3 = CAN0.sendMsgBuf(0x100, 0, 8, data2);
  if(!digitalRead(CAN0_INT))                         // If CAN0_INT pin is low, read receive buffer
      CAN0.readMsgBuf(&rxId, &len, rxBuf); // Read data: len = data length, buf = data byte(s)
        digitalWrite(A1,LOW);
//------------------------------------------------ EOF -----------------------------------------------------------------


Ohne die CAN-BUS Routine habe ich diese Meldung: