Zu wenig dynamischen Speicher

Mutscheid1 · May 9, 2019, 2:31pm

Hi,

hab ein Programm zur Rolladensteuerung geschrieben bzw. abgeschrieben. Problem ist jetzt aber, dass der Speicher nicht ausreicht auf meinem NANO.
Könnte vielleicht mal jemand drübergucken, ob man den noch irgendwie Speichertechnisch optimieren kann.

/*
  Datum: März 2019
  Dieser Code soll für Wandsender sein.
  Arduino soll einschlafen, durch die Wippe des Lichtschalters aufgeweckt werden,
  und über Näherungstaster, welche von hinten an die Abdeckung des Schalters geklebt
  sind, gesteuert werden.

  Transmit sketch - RF Calibration
     Written by ScottC 17 July 2014
     Arduino IDE version 1.0.5
     Website: http://arduinobasics.blogspot.com
     Transmitter: FS1000A/XY-FST
     Description: A simple sketch used to calibrate RF transmission.
  ------------------------------------------------------------- */
/*
  Generating signals to emulate a Fernotron 2411
  From the original code of ScottC (see link above), transmitCode()
  has been adapted to pass a signal sequence, and it uses calibrated
  signal lengths instead of calling the method repeatedly with
  increasing signal lengths.
  Instead of toggling two states in the receiver, three buttons
  (corresponding to up/stop/down) can be controlled within the sketch.
  Moreover, a method has been added for the calibration of the lengths
  of the generated signals.
  BR March 2015
  ------------------------------------------------------------- */
#include <avr/sleep.h>
#define rfTransmitPin 4  //RF Transmitter pin = digital pin 4
#define ledPin 13        //Onboard LED = digital pin 13
#define interruptPin 2



#define butDownWohnzimmer 5
//#define buttonStop 6
#define butUpWohnzimmer 6
#define butDownKamin 7
#define butUpKamin 8
#define butDownEssen 9
#define butUpEssen 10

const int codeSize = 133;
unsigned long previousMillis = 0;
unsigned long interval = 20000;
boolean downstateWohnzimmer = false;
boolean upstateWohnzimmer = false;
boolean downstateKamin = false;
boolean upstateKamin = false;
boolean downstateEssen = false;
boolean upstateEssen = false;


//unsigned long verzoegerung=500;

// in case that a different number of LOW-HIGH sequences is used, codeSize has to be adapted

int StopWohnzimmer[] = {
  // example for a signal code
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  5,
  4, 3, 1, 4, 1, 2, 2, 4, 1, 2,
  5,
  4, 3, 1, 4, 1, 2, 2, 2, 4, 1,
  5,
  2, 4, 3, 1, 4, 3, 3, 3, 1, 2,
  5,
  2, 4, 3, 1, 4, 3, 3, 1, 4, 1,
  5,
  2, 4, 1, 4, 3, 1, 4, 3, 3, 1,
  5,
  2, 4, 1, 4, 3, 1, 4, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1,
  6,
};
int UpWohnzimmer[] = {
  // paste signal code here
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  5,
  4, 3, 1, 2, 4, 3, 3, 3, 1, 2,
  5,
  4, 3, 1, 2, 4, 3, 3, 1, 4, 1,
  6,
  3, 1, 4, 1, 4, 3, 3, 3, 3, 1,
  6,
  3, 1, 4, 1, 4, 3, 3, 1, 2, 2,
  6,
  3, 1, 2, 2, 2, 2, 4, 3, 1, 2,
  6,
  3, 1, 2, 2, 2, 2, 4, 1, 4, 1, 2, 1, 1, 1, 1, 1, 1,
  6,
};
int DownWohnzimmer[] = {
  // paste signal code here
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, -1, 1,
  5,
  4, 3, 1, 4, 3, 1, 2, 4, 3, 1,
  5,
  4, 3, 1, 4, 3, 1, 2, 2, 2, 2,
  5,
  4, 1, 4, 1, 4, 3, 3, 3, 1, 2,
  5,
  4, 1, 4, 1, 4, 3, 3, 1, -1, 1,
  5,
  4, 1, 2, 4, 1, 4, 3, 3, 3, 1,
  5,
  4, 1, 2, 4, 1, -1, 3, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1,
  6,
};

int StopKamin[] = {
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  6,
  3, 3, 1, 2, 4, 1, 4, 3, 1, 2,
  6,
  3, 3, 1, 2, 4, 1, 4, 1, 4, 1,
  5,
  2, 4, 3, 1, 4, 3, 3, 3, 1, 2,
  5,
  2, 4, 3, 1, 4, 3, 3, 1, 4, 1,
  6,
  1, 4, 1, 2, 2, 4, 1, 4, 1, 2,
  6,
  1, 4, 1, 2, 2, 4, 1, 2, 4, 1, 2, 1, 1, 1, 1, 1, 1,
  6,
};
int DownKamin[] = {
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  6,
  3, 3, 1, 4, 3, 3, 1, 4, 3, 1,
  6,
  3, 3, 1, 4, 3, 3, 1, 2, 2, 2,
  5,
  4, 1, 4, 1, 4, 3, 3, 3, 1, 2,
  5,
  4, 1, 4, 1, -1, 3, 3, 1, 4, 1,
  6,
  3, 1, 2, 4, 1, 2, 2, 4, 1, 2,
  6,
  3, 1, 2, 4, 1, 2, 2, 2, 4, 1, 2, 1, 1, 1, 1, 1, 1,
  6,
};
int UpKamin[] = {
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  6,
  3, 3, 1, 4, 1, 4, 1, 4, 1, 2,
  6,
  3, 3, 1, 4, 1, 4, 1, 2, 4, 1,
  6,
  -1, 1, 4, 1, 4, 3, 3, 3, 3, 1, -1, 3, 1, 4, 1, 4, -1, 3, 1, 2, 2,
  5,
};

int UpEssen[] = {
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  6,
  1, 4, 1, 4, 1, 2, 4, 3, 3, 1,
  6,
  1, 4, 1, 4, 1, 2, 4, 1, 2, 2,
  6,
  3, 1, 4, 1, 4, 3, 3, 3, 3, 1,
  6,
  3, 1, 4, 1, 4, 3, 3, 1, 2, 2,
  5,
  4, 1, 2, 4, 3, 1, 2, 4, 1, 2,
  5,
  4, 1, 2, 4, 3, 1, 2, 2, 4, 1, 2, 1, 1, 1, 1, 1, 1,
  6,
};
int StopEssen[] = {
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  6,
  1, 4, 1, 4, 1, 4, 1, 4, 3, 1,
  6,
  1, 4, 1, 4, 1, 4, 1, 2, 2, 2,
  5,
  2, 4, 3, 1, 4, 3, 3, 3, 1, 2,
  5,
  2, 4, 3, 1, 4, 3, 3, 1, 4, 1,
  6,
  3, 1, 2, 4, 3, 3, 3, -1, 3, 1,
  6,
  3, 1, 2, 4, 3, 3, -1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1,
  6,
};
int DownEssen[] = {
  6,
  3, 3, 3, 3, 3, 3, 1, 4, 1, 2,
  6,
  3, 3, 3, 3, 3, 3, 1, 2, 4, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 3, 3, 1,
  5,
  2, 2, 2, 2, 4, 1, 4, 1, 2, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 3, 1, 2,
  6,
  3, 3, 3, 1, 2, 2, 4, 1, 4, 1,
  6,
  1, 4, 1, 4, 3, 1, 4, 3, 1, 2,
  6,
  1, 4, 1, 4, 3, 1, 4, 1, 4, 1,
  5,
  4, 1, 4, 1, 4, 3, 3, 3, 1, 2,
  5,
  4, 1, 4, 1, 4, 3, 3, 1, -1, 1,
  6,
  1, 2, 2, 4, 1, 4, 1, 4, 1, 2,
  6,
  1, 2, 2, 4, 1, -1, 1, 2, 4, 1, 2, 1, 1, 1, 1, 1, 1,
  6,
};

HotSystems · May 9, 2019, 2:35pm

Wenn du für den Sketch Code-Tags anstatt von Quote-Tags verwendest, dann kan man den auch lesen.

Mutscheid1 · May 9, 2019, 2:38pm

Hier gehts weiter:

int timeIntervalsLow[] = {230, 345, 440, 570, 670, 780, 880, 990, 1105, 1210, 3030, 57}; // corresponds to lenghts of 1..10 and 27. The last value corresponds to about 500, but should be used with delay() instead of delayMicroseconds()
int timeIntervalsHigh[] = {220, 345, 450, 540, 675, 780, 890, 1010, 1120, 1230}; // corresponds to lenghts of 1..10



void setup() {
  Serial.begin(9600);
  pinMode(rfTransmitPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(butDownWohnzimmer, INPUT_PULLUP);
  //pinMode(buttonStop, INPUT);
  pinMode(butUpWohnzimmer, INPUT_PULLUP);
  pinMode(butDownKamin, INPUT_PULLUP);
  pinMode(butUpKamin, INPUT_PULLUP);
  pinMode(butDownEssen, INPUT_PULLUP);
  pinMode(butUpEssen, INPUT_PULLUP);
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), wakeUp, CHANGE);

}



void loop() {
  Going_To_Sleep();

  //Wohnzimmer#################################################
  if (digitalRead(butDownWohnzimmer) == HIGH) {
    Tasterabfrage(DownWohnzimmer, downstateWohnzimmer);
  }

  if (digitalRead(butUpWohnzimmer) == HIGH) {
    Tasterabfrage(UpWohnzimmer, upstateWohnzimmer);
  }
  //Wohnzimmer#################################################


  //Kamin#################################################
  if (digitalRead(butDownKamin) == HIGH) {
    Tasterabfrage(DownKamin, downstateKamin);
  }

  if (digitalRead(butUpKamin) == HIGH) {
    Tasterabfrage(UpKamin, upstateKamin);
  }
  //Kamin#################################################

  //Essen#################################################
  if (digitalRead(butDownEssen) == HIGH) {
    Tasterabfrage(DownEssen, downstateEssen);
  }

  if (digitalRead(butUpEssen) == HIGH) {
    Tasterabfrage(UpEssen, upstateEssen);
  }
  //Kamin#################################################

}

void Going_To_Sleep() {

  if (millis() - previousMillis > interval) {
    previousMillis = millis();
    Serial.println("SChlafen gehen");
    sleep_enable();

    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    delay(1000);
    sleep_cpu();
    Serial.println("just woke up");
  }

}

void wakeUp() {
  Serial.println("Interrupt Fired");
  sleep_disable();
  //detachInterrupt(0);
}

void Tasterabfrage(int Tastertyp, boolean &Status) {

int Stoptyp;

if ((Tastertyp==DownWohnzimmer) || (Tastertyp==UpWohnzimmer)){
  Stoptyp=StopWohnzimmer;
}
  else if ((Tastertyp==DownKamin) || (Tastertyp==UpKamin)){
  Stoptyp=StopKamin;
  }
    else if ((Tastertyp==DownEssen) || (Tastertyp==UpEssen)){
  Stoptyp=StopEssen;
  }

  if (Status == false) {
    Status = true;
    transmitCode(Tastertyp);
    Serial.println(Tastertyp);
  
  }
  else if (Status == true) {
    Status = false;
    transmitCode(Stoptyp);
    Serial.println("Stoptyp");

    
  }
  delay(400);
}


void transmitCode(int signalSequence[]) {
  int highLength = 0;
  int lowLength = 0;

  for (int i = 0; i < codeSize; i++) {
    switch (signalSequence[i]) {
      case 1: // LS+HS
        lowLength = timeIntervalsLow[1];
        highLength = timeIntervalsHigh[2];
        break;
      case 2: // LL + HS
        lowLength = timeIntervalsLow[5];
        highLength = timeIntervalsHigh[2];
        break;
      case 3: // LS+HL
        lowLength = timeIntervalsLow[1];
        highLength = timeIntervalsHigh[6];
        break;
      case 4: // LL+HL
        lowLength = timeIntervalsLow[5];
        highLength = timeIntervalsHigh[6];
        break;
      case 5: // LXL+HS
        lowLength = timeIntervalsLow[10];
        highLength = timeIntervalsHigh[2];
        break;
      case 6: // LXL+HL
        lowLength = timeIntervalsLow[10];
        highLength = timeIntervalsHigh[6];
        break;
      case 7: // LXXL+HXS
        lowLength = timeIntervalsLow[11];
        highLength = timeIntervalsHigh[1];
        break;
    }
    if (lowLength == timeIntervalsLow[11]) {
      digitalWrite(rfTransmitPin, LOW);
      delay(lowLength);
      digitalWrite(rfTransmitPin, HIGH);
      delayMicroseconds(345);
    }
    else {
      digitalWrite(rfTransmitPin, LOW);
      delayMicroseconds(lowLength);
      digitalWrite(rfTransmitPin, HIGH);
      delayMicroseconds(highLength);
    }
  }

  digitalWrite(rfTransmitPin, LOW);
}


void sendTestSignal() {
  int highLength = 0;
  int lowLength = 0;

  // First, the interval lengths of 1..10 will be transmitted (LOW and HIGH)
  for (int k = 1; k <= 13; k++) {
    for (int j = 0; j < 10; j++) {
      switch (k) {
        case 1:
          lowLength = 230;
          highLength = 220;
          break;
        case 2:
          lowLength = 345;
          highLength = 345;
          break;
        case 3:
          lowLength = 440;
          highLength = 450;
          break;
        case 4:
          lowLength = 570;
          highLength = 540;
          break;
        case 5:
          lowLength = 670;
          highLength = 675;
          break;
        case 6:
          lowLength = 780;
          highLength = 780;
          break;
        case 7:
          lowLength = 880;
          highLength = 890;
          break;
        case 8:
          lowLength = 990;
          highLength = 1010;
          break;
        case 9:
          lowLength = 1105;
          highLength = 1120;
          break;
        case 10:
          lowLength = 1210;
          highLength = 1230;
          break;

        // These are the extra long signals (combined with their short counterpart)
        case 11: // LXL+HS 5
          lowLength = 3030;
          highLength = 450;
          break;
        case 12: // LXL+HL 6
          lowLength = 3030;
          highLength = 780;
          break;
      }

      if (k == 13) {
        // the 500 length Signal does not work properly with delayMicroseconds(). Use --> delay()
        digitalWrite(rfTransmitPin, LOW);
        delay(57);
        digitalWrite(rfTransmitPin, HIGH);
        delayMicroseconds(345);
      }
      else {
        digitalWrite(rfTransmitPin, LOW);
        delayMicroseconds(lowLength);
        digitalWrite(rfTransmitPin, HIGH);
        delayMicroseconds(highLength);
      }
    }
  }
  digitalWrite(rfTransmitPin, LOW); // finally turn off transmitter
}

combie · May 9, 2019, 2:41pm

ob man den noch irgendwie Speichertechnisch optimieren kann.

Du könntest die Arrays ins Flash verlagern.
Stichwort: PROGMEM

Tommy56 · May 9, 2019, 2:42pm

Alle int überprüfen (besonders die Arrays) ob da wirklich int notwendig ist oder ob byte (0...255) oder char (-128...127) ausreicht. Sind die Arrays konstant? Dann ins PROGMEM.

Gruß Tommy

Mutscheid1 · May 9, 2019, 2:47pm

Von PROGMEM hatte ich schon was gelesen. War mir aber viel zu hoch. Byte wäre eine Möglichkeit.

combie · May 9, 2019, 2:50pm

War mir aber viel zu hoch.

Dann liest du dich jetzt ein!

agmue · May 9, 2019, 4:47pm

Mutscheid1:
Von PROGMEM hatte ich schon was gelesen. War mir aber viel zu hoch. Byte wäre eine Möglichkeit.

Mit int8_t auf 72%.

Topic		Replies	Views
NRF24L01 funktioniert nicht Deutsch	11	2710	May 6, 2021
433MHz Funksteuerung Arduino - Intertechno CMR 1000 Deutsch	2	2101	May 6, 2021
NRF2401 - Kurzsketch eigenartiges Verhalten Deutsch	16	481	August 13, 2021
Ersatz einer RF Fernbedienung Deutsch	11	1805	May 6, 2021
RC-Sender & Empfänger Deutsch	10	2174	May 6, 2021

Zu wenig dynamischen Speicher

Related topics