Speicherplatz aktualisieren/löschen



  • Hallo zusammen,

    ich benutzen einen Arduino Microcontroller um einen Scrollenden Text anzuzeigen.

    die loop() funktion ist die Hauptfunktion, die ausgeführt wird.

    Wenn ich die Funktion scroll(.......) benutze, dann wird der eingegebene Text gescrollt.

    Ich habe folgendes Problem in meinem Code:

    wenn ich folgendes mache:
    char timearray[7] = "";
    // Wertzuweisungen
    scroll(timearray, .....);

    dann speichert er die Eingaben des Arrays bei jedem Durchlauf und jedesmal, wenn ich scroll mit einem Array neu aufrufe,

    char datearray[16] = "";
    // Wertzuweisungen
    scroll(datearray, ......);

    dann zeigt es mir den inhalt vom timearray und vom datearray an, obwohl ich nur den inhalt vom datearray anzeigen wollte.

    hingegen wenn ich

    scroll("Text", ....)

    schreibe, dann zeigt er mir wie gewünscht nur den eingegeben Text an.

    Wie kann ich das machen, dass die Arrays sich nicht addieren?
    Muss ich den Speicherplatz freigeben, oder löschen?

    Vielen Dank für eure Hilfe.

    Gruss.

    // RTC
    #include "Wire.h"
    #define DS1307_ADDRESS 0x68
    
    // Define SPI Pins
    #define DATAOUT     11//MOSI MasterOutputSlaveInput (connect to --> MISO of device)
    #define DATAIN      12//MISO MasterInputSlaveOutput (connect to --> MOSI of device)
    #define SPICLOCK    13//sck
    #define SLAVESELECT 10//ss
    
    // RGB MATRIX definitions
    int NUM_BOARDS = 1;
    #define NUM_ROWS	8
    #define NUM_COLUMNS	8
    #define NUM_PIXELS	64
    #define BUFFER	        4 // for 8 Matrixes = 10
    
    // Screen Buffer
    typedef struct{
      char pixel[NUM_PIXELS];
    }
    screen;
    screen screenBuffer[BUFFER];  // Array of screens that represents the entire frame of matrices (if using a multi-board system)
    screen myScreen[BUFFER];      // Array of screens used for scrolling text.
    
    // Define the "Normal" 8 bit colors
    #define BLACK	0
    #define RED	0xE0
    #define GREEN	0x1C
    #define BLUE	0x03
    #define ORANGE	RED|GREEN
    #define MAGENTA	RED|BLUE
    #define TEAL	BLUE|GREEN
    #define WHITE	(RED|GREEN|BLUE)-0x60
    
    // 8x8 font. 
    const char letters[] = {
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //32/ --> ' '
      0x00,0x00,0x00,0x4F,0x00,0x00,0x00,0x00, //33/ --> !
      0x00,0x00,0x07,0x00,0x07,0x00,0x00,0x00, //34/ --> "
      0x00,0x14,0x7F,0x14,0x7F,0x14,0x00,0x00, //35/ --> #
      0x00,0x24,0x2A,0x7F,0x2A,0x12,0x00,0x00, //36/ --> $
      0x00,0x23,0x13,0x08,0x64,0x62,0x00,0x00, //37/ --> %
      0x00,0x36,0x49,0x55,0x22,0x50,0x00,0x00, //38/ --> &
      0x00,0x00,0x05,0x03,0x00,0x00,0x00,0x00, //39/ --> '
      0x00,0x00,0x1C,0x22,0x41,0x00,0x00,0x00, //40/ --> (
      0x00,0x00,0x41,0x22,0x1C,0x00,0x00,0x00, //41/ --> )
      0x00,0x14,0x08,0x3E,0x08,0x14,0x00,0x00, //42/ --> *
      0x00,0x08,0x08,0x3E,0x08,0x08,0x00,0x00, //43/ --> +
      0x00,0x00,0x50,0x30,0x00,0x00,0x00,0x00, //44/ --> ,
      0x08,0x08,0x08,0x08,0x08,0x08,0x00,0x00, //45/ --> -
      0x00,0x00,0x60,0x60,0x00,0x00,0x00,0x00, //46/ --> .
      0x00,0x20,0x10,0x08,0x04,0x02,0x00,0x00, //47/ --> /
      0x00,0x3E,0x51,0x49,0x45,0x3E,0x00,0x00, //48/ --> 0
      0x00,0x00,0x42,0x7F,0x40,0x00,0x00,0x00, //49/ --> 1
      0x00,0x42,0x61,0x51,0x49,0x46,0x00,0x00, //50/ --> 2
      0x00,0x21,0x41,0x45,0x4B,0x31,0x00,0x00, //51/ --> 3
      0x00,0x18,0x14,0x12,0x7F,0x10,0x00,0x00, //52/ --> 4
      0x00,0x27,0x45,0x45,0x45,0x39,0x00,0x00, //53/ --> 5
      0x00,0x3C,0x4A,0x49,0x49,0x30,0x00,0x00, //54/ --> 6
      0x00,0x01,0x71,0x09,0x05,0x03,0x00,0x00, //55/ --> 7
      0x00,0x36,0x49,0x49,0x49,0x36,0x00,0x00, //56/ --> 8
      0x00,0x06,0x49,0x49,0x29,0x1E,0x00,0x00, //57/ --> 9
      0x00,0x00,0x36,0x00,0x00,0x00,0x00,0x00, //58/ --> :
      0x00,0x00,0x56,0x36,0x00,0x00,0x00,0x00,  //59/ --> ;
      0x00,0x08,0x14,0x22,0x41,0x00,0x00,0x00, //60/ --> <
      0x00,0x14,0x14,0x14,0x14,0x14,0x00,0x00, //61/ --> =
      0x00,0x00,0x41,0x22,0x14,0x08,0x00,0x00, //62/ --> >
      0x00,0x02,0x01,0x51,0x09,0x06,0x00,0x00, //63/ --> ?
      0x00,0x32,0x49,0x79,0x41,0x3E,0x00,0x00, //64/ --> @
      0x00,0x7E,0x11,0x11,0x11,0x7E,0x00,0x00, //65/ --> A
      0x00,0x7F,0x49,0x49,0x49,0x36,0x00,0x00, //66/ --> B
      0x00,0x3E,0x41,0x41,0x41,0x22,0x00,0x00, //67/ --> C
      0x00,0x7F,0x41,0x41,0x22,0x1C,0x00,0x00, //68/ --> D
      0x00,0x7F,0x49,0x49,0x49,0x41,0x00,0x00, //69/ --> E
      0x00,0x7F,0x09,0x09,0x09,0x01,0x00,0x00, //70/ --> F
      0x00,0x3E,0x41,0x49,0x49,0x3A,0x00,0x00, //71/ --> G
      0x00,0x7F,0x08,0x08,0x08,0x7F,0x00,0x00, //72/ --> H
      0x00,0x00,0x41,0x7F,0x41,0x00,0x00,0x00, //73/ --> I
      0x00,0x20,0x40,0x41,0x3F,0x01,0x00,0x00, //74/ --> J
      0x00,0x7F,0x08,0x14,0x22,0x41,0x00,0x00, //75/ --> K
      0x00,0x7F,0x40,0x40,0x40,0x40,0x00,0x00, //76/ --> L
      0x00,0x7F,0x02,0x0C,0x02,0x7F,0x00,0x00, //77/ --> M
      0x00,0x7F,0x04,0x08,0x10,0x7F,0x00,0x00, //78/ --> N
      0x00,0x3E,0x41,0x41,0x41,0x3E,0x00,0x00, //79/ --> O
      0x00,0x7F,0x09,0x09,0x09,0x06,0x00,0x00, //80/ --> P
      0x3E,0x41,0x51,0x21,0x5E,0x00,0x00,0x00, //81/ --> Q
      0x00,0x7F,0x09,0x19,0x29,0x46,0x00,0x00, //82/ --> R
      0x00,0x46,0x49,0x49,0x49,0x31,0x00,0x00, //83/ --> S
      0x00,0x01,0x01,0x7F,0x01,0x01,0x00,0x00, //84/ --> T
      0x00,0x3F,0x40,0x40,0x40,0x3F,0x00,0x00, //85/ --> U
      0x00,0x1F,0x20,0x40,0x20,0x1F,0x00,0x00, //86/ --> V
      0x00,0x3F,0x40,0x70,0x40,0x3F,0x00,0x00, //87/ --> W
      0x00,0x63,0x14,0x08,0x14,0x63,0x00,0x00, //88/ --> X
      0x00,0x07,0x08,0x70,0x08,0x07,0x00,0x00, //89/ --> Y
      0x00,0x61,0x51,0x49,0x45,0x43,0x00,0x00, //90/ --> Z
    };
    
    void setup()
    {
      pinMode(DATAOUT, OUTPUT);
      pinMode(DATAIN, INPUT);
      pinMode(SPICLOCK, OUTPUT);
      pinMode(SLAVESELECT, OUTPUT);
      delay(10);
      digitalWrite(SLAVESELECT, HIGH); // disable RGB MATRIX
      delay(10);
      SPCR = 0b01010011;
      delay(5000);
      digitalWrite(SLAVESELECT, LOW);
      delay(10);
      spiTransfer('%');
      delay(10);
      digitalWrite(SLAVESELECT, HIGH);
    
      //Configure the correct number of boards
      digitalWrite(SLAVESELECT, LOW);
      delay(10);
      spiTransfer(NUM_BOARDS);
      delay(10);	
      digitalWrite(SLAVESELECT, HIGH);
      delay(10);
      Wire.begin();
      delay(5000);
    
    }
    
    void loop()
    {
      String timestring = getTime();
      char timearray[7] = "";
      timearray[0]=' ';
      timearray[6]=' ';
      for(int i=1; i<6; i++){
        timearray[i]=timestring[i-1];
      }
      scroll(timearray, MAGENTA, 50);
      clear();
      scroll(timearray, MAGENTA, 50);
      clear();
      scroll(timearray, MAGENTA, 50);
      clear();
      scroll(timearray, MAGENTA, 50);
      clear();
      free(timearray);
    
      String datestring = getDate();
      char datearray[16] = "";
      datearray[0]=' ';
      datearray[15]=' ';
      for(int i=1; i<15; i++){
        datearray[i]=datestring[i-1];
      }
      scroll(datearray, MAGENTA, 50);
      clear();
      free(datearray);
    
    }
    
    char spiTransfer(char value)
    {
      SPDR = value;                   // Start the transmission
      while (!(SPSR & (1<<SPIF)))     // Wait for the end of the transmission
      {
      };
      return SPDR;                    // return the received byte
    }
    
    char fillPixel(int screen, int row, int column, char color)
    {
      if((screen > NUM_BOARDS) || (screen < 0))return 0;
      if((column < 0) || column > NUM_COLUMNS)return 0;
      if((row < 0) || row > NUM_ROWS)return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      screenBuffer[screen].pixel[row*8+column]=color;
    }
    
    char fillColumn(int screen, int column, char color)
    {
      if((screen > NUM_BOARDS) || (screen < 0))return 0;
      if((column < 0) || column > NUM_COLUMNS)return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      for(int row=0; row<NUM_ROWS; row++)
      {
        screenBuffer[screen].pixel[column+(row*NUM_ROWS)]=color;
      }
      return 1;
    }
    
    char fillRow(int screen, int row, char color)
    {
      if((screen > NUM_BOARDS) || (screen < 0))return 0;
      if((row < 0) || row > NUM_ROWS)return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      for(int column=0; column<NUM_COLUMNS; column++)
      {
        screenBuffer[screen].pixel[row*NUM_ROWS+column]=color;
      }
      return 1;	
    }
    
    char fillScreen(int screen, char color)
    {
      if((screen < 0) || (screen > NUM_BOARDS))return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      for(int row=0; row<NUM_ROWS; row++)
      {
        for(int column=0; column<NUM_COLUMNS; column++)
        {
          screenBuffer[screen].pixel[row*NUM_ROWS+column]=color;
        }
      }
      return 1;
    }
    
    char fillChar(int screen, char letter, char color)
    {
      int letter_offset=0;	//The position of the letter in the letters[] array.
    
      if((screen < 0) || (screen > NUM_BOARDS))return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      if(isalpha(letter))letter = toupper(letter);	//Convert to uppercase
      letter_offset = letter - 32;	//Find the offset in the letters[] array
      letter_offset *=8;
      if(letter == ' ')letter_offset=0;	//If we get a space or invalid character, display a space
      if(!isalpha(letter)&&(letter>123||letter<33))letter_offset=0;
      //Fill the screen with data from the letters[] array
      for(int column=0; column<NUM_COLUMNS; column++)
      {
        for(int row=0; row<NUM_ROWS; row++)
        {
          //Strange looking algorithm converts rows to columns and vice versa.
          if(letters[letter_offset+(7-column)] & (1<<row))screenBuffer[screen].pixel[row*8+column]=color;
          else screenBuffer[screen].pixel[row*8+column]=BLACK;
        }
      }
    
      return 1;
    }
    
    void display(void)
    {
      digitalWrite(SLAVESELECT, LOW);	//Select the LED matrices
      spiTransfer(0x26);				//SEnd the Start of frame character
      //Use the _num_boards parameter to determine how many frames to send
      for(int screen=0; screen<NUM_BOARDS; screen++)
      {
        sendScreen(screenBuffer[screen].pixel);	//Send frame data over SPI.
      }
      digitalWrite(SLAVESELECT, HIGH);	//Unselect the LED matrices
    }
    
    void sendScreen(char * screen)
    {
      for(int row=0; row<NUM_ROWS; row++)
      {
        for(int column=0; column<NUM_COLUMNS; column++)
        {
          spiTransfer(screen[(row*8)+column]);
        }
      }
    }
    
    void scrollBuffer(int speed)
    {
      //This huge loop scrolls a character one column to the left each time through.
      for(int scroll = 7; scroll >=0; scroll--)
      {
        for(int board = NUM_BOARDS+1; board >=0; board--)
        {
          for(int row=0; row<NUM_ROWS; row++)
          {
            for(int column=0; column<NUM_COLUMNS; column++)
            {
              myScreen[board].pixel[row*NUM_ROWS+column]=screenBuffer[(column+scroll)/8+board].pixel[(row*NUM_ROWS)+(column+scroll)%8];
            }
          }
        }
    
        digitalWrite(SLAVESELECT, LOW);
        spiTransfer(0x26);
        //We start from the second index so that a character can be scrolled all the way off the frame.
        for(int i=0; i<NUM_BOARDS; i++)sendScreen(myScreen[i].pixel);
        digitalWrite(SLAVESELECT, HIGH);
        delay(speed);
      }
    }
    //char
    void scroll(char * message, char color, int speed)
    {
      int messageLength=0;
      char disp[58]="";
    
      if(color == 0x25 || color == 0x26);
      else{
    
        //Precede the message with spaces so the message starts off of the frame.
        for(int i=0; i<NUM_BOARDS; i++)disp[i]=' ';
    
        strcat(disp, message);
        //Find the length of the screen (including the spaces we added).
    
        messageLength=strlen(disp);
    
        //Scroll each character onto and off of the frame.
        for(int messageIndex=0; messageIndex<messageLength; messageIndex++)
        {
          for(int screen=NUM_BOARDS+1; screen>=0; screen--)
          {
            fillChar(NUM_BOARDS+1-screen, disp[messageIndex+screen], color);
          }
          scrollBuffer(speed);
        }	
      }
    }
    
    void clear(void)
    {
      for(int board=0; board<NUM_BOARDS; board++)
      {
        fillScreen(board, BLACK);
        //free(screenBuffer[board].pixel);
        //memset(&screenBuffer[board].pixel, 0, sizeof (screen));
      }
      display();
    }
    
    //************ CLOCK FUNCTIONS *****************************************************************************************
    // CONVERTERS ##########################################################################################################
    byte decToBcd(byte val){
      // Convert normal decimal numbers to binary coded decimal
      return ( (val/10*16) + (val%10) );
    }
    byte bcdToDec(byte val)  {
      // Convert binary coded decimal to normal decimal numbers
      return ( (val/16*10) + (val%16) );
    }
    // END: CONVERTERS #####################################################################################################
    // TIME GETTERS ########################################################################################################
    // GET TIME ------------------------------------------------------------------------------------------------------------
    String getTime(){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      String h = hour;
      if(hour<10) h = "0"+h;
      String m = minute;
      if(minute<10) m = "0"+m; 
      String all = h+":"+m;
      return all;
    }
    // END: GET TIME -------------------------------------------------------------------------------------------------------
    // GET DATE ------------------------------------------------------------------------------------------------------------
    String getDate(){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      String date;
      switch(weekDay){ // Weekdays in German
      case 1:
        date = "MO";
        break;
      case 2:
        date = "DI";
        break;
      case 3:
        date = "MI";
        break;
      case 4:
        date = "DO";
        break;
      case 5:
        date = "FR";
        break;
      case 6:
        date = "SA";
        break;
      case 7:
        date = "SO";
        break;
      default: 
        break;
      }
    
      String monthDayString = monthDay;
      String monthString = month;
    
      if(monthDay<10) monthDayString = "0"+monthDayString;
      if(month<10) monthString = "0"+monthString;
    
      date = date+", "+monthDayString+"."+monthString+".20"+year;
      return date;
    }
    // END: GET DATE -------------------------------------------------------------------------------------------------------
    // END: TIME GETTERS ###################################################################################################
    // TIME SETTERS ########################################################################################################
    // CHANGE HOUR (DESIGNED FOR +-1) --------------------------------------------------------------------------------------
    void changeHour(int h){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      if(hour==23) hour = 0;
      else hour = hour + h;
    
      setDateTime(second, minute, hour, weekDay, monthDay, month, year);  
    }
    // END: CHANGE HOUR ----------------------------------------------------------------------------------------------------
    // CHANGE MINUTE (DESIGNED FOR +-1) ------------------------------------------------------------------------------------
    void changeMinute(int m){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      if(minute==59) minute = 0;
      else minute = minute + m;
    
      setDateTime(second, minute, hour, weekDay, monthDay, month, year);  
    }
    // END: CHANGE MINUTE --------------------------------------------------------------------------------------------------
    // SET TIME ------------------------------------------------------------------------------------------------------------
    void setDateTime(int second, int minute, int hour, int weekDay, int day, int month, int year){
    
      byte s = (byte) second; //0-59
      byte m = (byte) minute; //0-59
      byte h = (byte) hour; //0-23
      byte w = (byte) weekDay; //1-7
      byte d = (byte) day; //1-31
      byte m2 = (byte) month; //1-12
      byte y  = (byte) year; //0-99
    
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0); //stop Oscillator
    
      Wire.send(decToBcd(s));
      Wire.send(decToBcd(m));
      Wire.send(decToBcd(h));
      Wire.send(decToBcd(w));
      Wire.send(decToBcd(d));
      Wire.send(decToBcd(m2));
      Wire.send(decToBcd(y));
    
      Wire.send(0); //start 
    
      Wire.endTransmission();
    }
    // END: SET TIME -------------------------------------------------------------------------------------------------------
    // END: TIME SETTERS ###################################################################################################
    // END: ******* CLOCK FUNCTIONS ****************************************************************************************
    


  • Bitte reduziere den Code auf ein Minimalbeispiel. Wir haben keine Lust deine Funktionen zu suchen.



  • Ich hab's jetzt nur überflogen, aber sowas sieht schonmal unsinnig aus:

    char timearray[7] = "";
      ...
      free(timearray);
    

    free() wird verwendet für die Freigabe von dynamischem Speicher (d.h. per malloc() angefordert), nicht für Arrays, die du auf dem Stack angefordert hast.

    PS: Soweit ich das überblicke, ist das im C Forum besser aufgehoben.



  • Du wirst irgendwo den Sonderfall nicht behandeln, dass bereits das erste Zeichen \0 ist. Zum Suchen sind mir 500 Zeilen aber auch zu viel.



  • CStoll schrieb:

    PS: Soweit ich das überblicke, ist das im C++ Forum besser aufgehoben.

    Meinst du das C-Unterforum?



  • Michael E. schrieb:

    Meinst du das C-Unterforum?

    Ja, aber ganz sicher bin ich mir da nicht - der Code ist ein grauenhaft geschriebener Hybrid, der irgendwo zwischen C und C++ liegt.



  • CStoll schrieb:

    Michael E. schrieb:

    Meinst du das C-Unterforum?

    Ja, aber ganz sicher bin ich mir da nicht - der Code ist ein grauenhaft geschriebener Hybrid, der irgendwo zwischen C und C++ liegt.

    Haben Mikrocontroller das nicht an sich? 😉



  • Keine Ahnung, so nahe bin ich noch keinem Mikrocontroller gekommen, um das beurteilen zu können (auch wenn ich mal an einem Programm gearbeitet habe, das mit einem kommuniziert hat).



  • Hallo zusammen,

    hier der reduzierte code.
    ev. findet ihr etwas.

    es muss entweder mit dem struct, den Buffer oder den Arrays deklariert in loop zu tun haben.
    Irgendwie werden Chars angezeigt, die nebeneinander im Speicherort sind.

    Danke für eure Hilfe

    Gruss.

    // RGB MATRIX definitions
    int NUM_BOARDS = 1;
    #define NUM_ROWS    8
    #define NUM_COLUMNS    8
    #define NUM_PIXELS    64
    #define BUFFER            4 // for 8 Matrixes = 10
    
    // Screen Buffer
    typedef struct{
      char pixel[NUM_PIXELS];
    }
    screen;
    screen screenBuffer[BUFFER];  // Array of screens that represents the entire frame of matrices (if using a multi-board system)
    screen myScreen[BUFFER];      // Array of screens used for scrolling text.
    
    // Define the "Normal" 8 bit colors
    #define BLACK    0
    #define RED    0xE0
    #define BLUE    0x03
    #define MAGENTA    RED|BLUE
    
    // 8x8 font.
    const char letters[] = {
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //32/ --> ' '
      0x00,0x00,0x00,0x4F,0x00,0x00,0x00,0x00, //33/ --> !
      // usw.
      0x00,0x61,0x51,0x49,0x45,0x43,0x00,0x00, //90/ --> Z
    };
    
    void loop()
    {
      String timestring = getTime();
      char timearray[7] = "";
      timearray[0]=' ';
      timearray[6]=' ';
      for(int i=1; i<6; i++){
        timearray[i]=timestring[i-1];
      }
      scroll(timearray, MAGENTA, 50);
      clear();
      scroll(timearray, MAGENTA, 50);
      clear();
      scroll(timearray, MAGENTA, 50);
      clear();
      scroll(timearray, MAGENTA, 50);
      clear();
    
      String datestring = getDate();
      char datearray[16] = "";
      datearray[0]=' ';
      datearray[15]=' ';
      for(int i=1; i<15; i++){
        datearray[i]=datestring[i-1];
      }
      scroll(datearray, MAGENTA, 50);  // Problem: Beim zweiten Durchlauf der loop() Funktion (Undendiche Schleife)
                                        // Zeigt die Matrix den Inhalt von timearray und datearray an, obwohl ich nur den datearray anzeigen wollte.
                                         // Kann mir da jemand helfen?
      clear();
    }
    
    // Funktion muss für Problem nicht angeschaut werden
    char spiTransfer(char value)
    {
      SPDR = value;                   // Start the transmission
      while (!(SPSR & (1<<SPIF)))     // Wait for the end of the transmission
      {
      };
      return SPDR;                    // return the received byte
    }
    
    void sendScreen(char * screen)
    {
      for(int row=0; row<NUM_ROWS; row++)
      {
        for(int column=0; column<NUM_COLUMNS; column++)
        {
          spiTransfer(screen[(row*8)+column]);
        }
      }
    }
    
    void scrollBuffer(int speed)
    {
      //This huge loop scrolls a character one column to the left each time through.
      for(int scroll = 7; scroll >=0; scroll--)
      {
        for(int board = NUM_BOARDS+1; board >=0; board--)
        {
          for(int row=0; row<NUM_ROWS; row++)
          {
            for(int column=0; column<NUM_COLUMNS; column++)
            {
              myScreen[board].pixel[row*NUM_ROWS+column]=screenBuffer[(column+scroll)/8+board].pixel[(row*NUM_ROWS)+(column+scroll)%8];
            }
          }
        }
    
        digitalWrite(SLAVESELECT, LOW);
        spiTransfer(0x26);
        //We start from the second index so that a character can be scrolled all the way off the frame.
        for(int i=0; i<NUM_BOARDS; i++)sendScreen(myScreen[i].pixel);
        digitalWrite(SLAVESELECT, HIGH);
        delay(speed);
      }
    }
    //char
    void scroll(char * message, char color, int speed)
    {
      int messageLength=0;
      char disp[58]="";
    
      if(color == 0x25 || color == 0x26);
      else{
    
        //Precede the message with spaces so the message starts off of the frame.
        for(int i=0; i<NUM_BOARDS; i++)disp[i]=' ';
    
        strcat(disp, message);
        //Find the length of the screen (including the spaces we added).
    
        messageLength=strlen(disp);
    
        //Scroll each character onto and off of the frame.
        for(int messageIndex=0; messageIndex<messageLength; messageIndex++)
        {
          for(int screen=NUM_BOARDS+1; screen>=0; screen--)
          {
            fillChar(NUM_BOARDS+1-screen, disp[messageIndex+screen], color);
          }
          scrollBuffer(speed);
        }   
      }
    }
    
    void clear(void)
    {
      for(int board=0; board<NUM_BOARDS; board++)
      {
        fillScreen(board, BLACK);
        //free(screenBuffer[board].pixel);
        //memset(&screenBuffer[board].pixel, 0, sizeof (screen));
      }
      display(); // Funktion weggelassen
    }
    


  • CStoll schrieb:

    Ich hab's jetzt nur überflogen, aber sowas sieht schonmal unsinnig aus:

    char timearray[7] = "";
      ...
      free(timearray);
    

    free() wird verwendet für die Freigabe von dynamischem Speicher (d.h. per malloc() angefordert), nicht für Arrays, die du auf dem Stack angefordert hast.

    PS: Soweit ich das überblicke, ist das im C Forum besser aufgehoben.

    Ja, der Versuch "free" war nur ein verzweifelter Test.:) Habs jetzt rausgenommen. Danke



  • Hab das Problem behoben.

    Hab einfach die Arrays in Funktionen Abgekapselt.
    Danach gab es das Problem nicht mehr.

    Vielen Dank für euere Hilfe.

    Gruss

    Hier noch der Code:

    // RTC
    #include "Wire.h"
    #define DS1307_ADDRESS 0x68
    
    // Define SPI Pins
    #define DATAOUT     11//MOSI MasterOutputSlaveInput (connect to --> MISO of device)
    #define DATAIN      12//MISO MasterInputSlaveOutput (connect to --> MOSI of device)
    #define SPICLOCK    13//sck
    #define SLAVESELECT 10//ss
    
    // RGB MATRIX definitions
    int NUM_BOARDS = 1;
    #define NUM_ROWS	8
    #define NUM_COLUMNS	8
    #define NUM_PIXELS	64
    #define BUFFER	        4 // for 8 Matrixes = 10
    
    // Screen Buffer
    typedef struct{
      char pixel[NUM_PIXELS];
    }
    screen;
    screen screenBuffer[BUFFER];  // Array of screens that represents the entire frame of matrices (if using a multi-board system)
    screen myScreen[BUFFER];      // Array of screens used for scrolling text.
    
    // Define the "Normal" 8 bit colors
    #define BLACK	0
    #define RED	0xE0
    #define GREEN	0x1C
    #define BLUE	0x03
    #define ORANGE	RED|GREEN
    #define MAGENTA	RED|BLUE
    #define TEAL	BLUE|GREEN
    #define WHITE	(RED|GREEN|BLUE)-0x60
    
    // 8x8 font. 
    const char letters[] = {
      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //32/ --> ' '
      0x00,0x00,0x00,0x4F,0x00,0x00,0x00,0x00, //33/ --> !
      0x00,0x00,0x07,0x00,0x07,0x00,0x00,0x00, //34/ --> "
      0x00,0x14,0x7F,0x14,0x7F,0x14,0x00,0x00, //35/ --> #
      0x00,0x24,0x2A,0x7F,0x2A,0x12,0x00,0x00, //36/ --> $
      0x00,0x23,0x13,0x08,0x64,0x62,0x00,0x00, //37/ --> %
      0x00,0x36,0x49,0x55,0x22,0x50,0x00,0x00, //38/ --> &
      0x00,0x00,0x05,0x03,0x00,0x00,0x00,0x00, //39/ --> '
      0x00,0x00,0x1C,0x22,0x41,0x00,0x00,0x00, //40/ --> (
      0x00,0x00,0x41,0x22,0x1C,0x00,0x00,0x00, //41/ --> )
      0x00,0x14,0x08,0x3E,0x08,0x14,0x00,0x00, //42/ --> *
      0x00,0x08,0x08,0x3E,0x08,0x08,0x00,0x00, //43/ --> +
      0x00,0x00,0x50,0x30,0x00,0x00,0x00,0x00, //44/ --> ,
      0x08,0x08,0x08,0x08,0x08,0x08,0x00,0x00, //45/ --> -
      0x00,0x00,0x60,0x60,0x00,0x00,0x00,0x00, //46/ --> .
      0x00,0x20,0x10,0x08,0x04,0x02,0x00,0x00, //47/ --> /
      0x00,0x3E,0x51,0x49,0x45,0x3E,0x00,0x00, //48/ --> 0
      0x00,0x00,0x42,0x7F,0x40,0x00,0x00,0x00, //49/ --> 1
      0x00,0x42,0x61,0x51,0x49,0x46,0x00,0x00, //50/ --> 2
      0x00,0x21,0x41,0x45,0x4B,0x31,0x00,0x00, //51/ --> 3
      0x00,0x18,0x14,0x12,0x7F,0x10,0x00,0x00, //52/ --> 4
      0x00,0x27,0x45,0x45,0x45,0x39,0x00,0x00, //53/ --> 5
      0x00,0x3C,0x4A,0x49,0x49,0x30,0x00,0x00, //54/ --> 6
      0x00,0x01,0x71,0x09,0x05,0x03,0x00,0x00, //55/ --> 7
      0x00,0x36,0x49,0x49,0x49,0x36,0x00,0x00, //56/ --> 8
      0x00,0x06,0x49,0x49,0x29,0x1E,0x00,0x00, //57/ --> 9
      0x00,0x00,0x36,0x00,0x00,0x00,0x00,0x00, //58/ --> :
      0x00,0x00,0x56,0x36,0x00,0x00,0x00,0x00,  //59/ --> ;
      0x00,0x08,0x14,0x22,0x41,0x00,0x00,0x00, //60/ --> <
      0x00,0x14,0x14,0x14,0x14,0x14,0x00,0x00, //61/ --> =
      0x00,0x00,0x41,0x22,0x14,0x08,0x00,0x00, //62/ --> >
      0x00,0x02,0x01,0x51,0x09,0x06,0x00,0x00, //63/ --> ?
      0x00,0x32,0x49,0x79,0x41,0x3E,0x00,0x00, //64/ --> @
      0x00,0x7E,0x11,0x11,0x11,0x7E,0x00,0x00, //65/ --> A
      0x00,0x7F,0x49,0x49,0x49,0x36,0x00,0x00, //66/ --> B
      0x00,0x3E,0x41,0x41,0x41,0x22,0x00,0x00, //67/ --> C
      0x00,0x7F,0x41,0x41,0x22,0x1C,0x00,0x00, //68/ --> D
      0x00,0x7F,0x49,0x49,0x49,0x41,0x00,0x00, //69/ --> E
      0x00,0x7F,0x09,0x09,0x09,0x01,0x00,0x00, //70/ --> F
      0x00,0x3E,0x41,0x49,0x49,0x3A,0x00,0x00, //71/ --> G
      0x00,0x7F,0x08,0x08,0x08,0x7F,0x00,0x00, //72/ --> H
      0x00,0x00,0x41,0x7F,0x41,0x00,0x00,0x00, //73/ --> I
      0x00,0x20,0x40,0x41,0x3F,0x01,0x00,0x00, //74/ --> J
      0x00,0x7F,0x08,0x14,0x22,0x41,0x00,0x00, //75/ --> K
      0x00,0x7F,0x40,0x40,0x40,0x40,0x00,0x00, //76/ --> L
      0x00,0x7F,0x02,0x0C,0x02,0x7F,0x00,0x00, //77/ --> M
      0x00,0x7F,0x04,0x08,0x10,0x7F,0x00,0x00, //78/ --> N
      0x00,0x3E,0x41,0x41,0x41,0x3E,0x00,0x00, //79/ --> O
      0x00,0x7F,0x09,0x09,0x09,0x06,0x00,0x00, //80/ --> P
      0x3E,0x41,0x51,0x21,0x5E,0x00,0x00,0x00, //81/ --> Q
      0x00,0x7F,0x09,0x19,0x29,0x46,0x00,0x00, //82/ --> R
      0x00,0x46,0x49,0x49,0x49,0x31,0x00,0x00, //83/ --> S
      0x00,0x01,0x01,0x7F,0x01,0x01,0x00,0x00, //84/ --> T
      0x00,0x3F,0x40,0x40,0x40,0x3F,0x00,0x00, //85/ --> U
      0x00,0x1F,0x20,0x40,0x20,0x1F,0x00,0x00, //86/ --> V
      0x00,0x3F,0x40,0x70,0x40,0x3F,0x00,0x00, //87/ --> W
      0x00,0x63,0x14,0x08,0x14,0x63,0x00,0x00, //88/ --> X
      0x00,0x07,0x08,0x70,0x08,0x07,0x00,0x00, //89/ --> Y
      0x00,0x61,0x51,0x49,0x45,0x43,0x00,0x00, //90/ --> Z
    };
    
    void setup()
    {
      pinMode(DATAOUT, OUTPUT);
      pinMode(DATAIN, INPUT);
      pinMode(SPICLOCK, OUTPUT);
      pinMode(SLAVESELECT, OUTPUT);
      delay(10);
      digitalWrite(SLAVESELECT, HIGH); // disable RGB MATRIX
      delay(10);
      SPCR = 0b01010011;
      delay(5000);
      digitalWrite(SLAVESELECT, LOW);
      delay(10);
      spiTransfer('%');
      delay(10);
      digitalWrite(SLAVESELECT, HIGH);
    
      //Configure the correct number of boards
      digitalWrite(SLAVESELECT, LOW);
      delay(10);
      spiTransfer(NUM_BOARDS);
      delay(10);	
      digitalWrite(SLAVESELECT, HIGH);
      delay(10);
      Wire.begin();
      delay(5000);
    
    }
    
    void loop()
    {
      for(int i=0; i<5; i++){
      displayTime();
      }
      displayDate();
    }
    
    void displayTime(){
      String timestring = getTime();
      char timearray[7] = "";
      timearray[0]=' ';
      timearray[6]=' ';
      for(int i=1; i<6; i++){
        timearray[i]=timestring[i-1];
      }
      scroll(timearray, MAGENTA, 50);
      clear();
    }
    
    void displayDate(){
      String datestring = getDate();
      char datearray[16] = "";
      datearray[0]=' ';
      datearray[15]=' ';
      for(int i=1; i<15; i++){
        datearray[i]=datestring[i-1];
      }
      scroll(datearray, MAGENTA, 50);
      clear();
    }
    
    char spiTransfer(char value)
    {
      SPDR = value;                   // Start the transmission
      while (!(SPSR & (1<<SPIF)))     // Wait for the end of the transmission
      {
      };
      return SPDR;                    // return the received byte
    }
    
    char fillPixel(int screen, int row, int column, char color)
    {
      if((screen > NUM_BOARDS) || (screen < 0))return 0;
      if((column < 0) || column > NUM_COLUMNS)return 0;
      if((row < 0) || row > NUM_ROWS)return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      screenBuffer[screen].pixel[row*8+column]=color;
    }
    
    char fillColumn(int screen, int column, char color)
    {
      if((screen > NUM_BOARDS) || (screen < 0))return 0;
      if((column < 0) || column > NUM_COLUMNS)return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      for(int row=0; row<NUM_ROWS; row++)
      {
        screenBuffer[screen].pixel[column+(row*NUM_ROWS)]=color;
      }
      return 1;
    }
    
    char fillRow(int screen, int row, char color)
    {
      if((screen > NUM_BOARDS) || (screen < 0))return 0;
      if((row < 0) || row > NUM_ROWS)return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      for(int column=0; column<NUM_COLUMNS; column++)
      {
        screenBuffer[screen].pixel[row*NUM_ROWS+column]=color;
      }
      return 1;	
    }
    
    char fillScreen(int screen, char color)
    {
      if((screen < 0) || (screen > NUM_BOARDS))return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      for(int row=0; row<NUM_ROWS; row++)
      {
        for(int column=0; column<NUM_COLUMNS; column++)
        {
          screenBuffer[screen].pixel[row*NUM_ROWS+column]=color;
        }
      }
      return 1;
    }
    
    char fillChar(int screen, char letter, char color)
    {
      int letter_offset=0;	//The position of the letter in the letters[] array.
    
      if((screen < 0) || (screen > NUM_BOARDS))return 0;
      if(color == 0x25 || color == 0x26)return 0;
    
      if(isalpha(letter))letter = toupper(letter);	//Convert to uppercase
      letter_offset = letter - 32;	//Find the offset in the letters[] array
      letter_offset *=8;
      if(letter == ' ')letter_offset=0;	//If we get a space or invalid character, display a space
      if(!isalpha(letter)&&(letter>123||letter<33))letter_offset=0;
      //Fill the screen with data from the letters[] array
      for(int column=0; column<NUM_COLUMNS; column++)
      {
        for(int row=0; row<NUM_ROWS; row++)
        {
          //Strange looking algorithm converts rows to columns and vice versa.
          if(letters[letter_offset+(7-column)] & (1<<row))screenBuffer[screen].pixel[row*8+column]=color;
          else screenBuffer[screen].pixel[row*8+column]=BLACK;
        }
      }
    
      return 1;
    }
    
    void display(void)
    {
      digitalWrite(SLAVESELECT, LOW);	//Select the LED matrices
      spiTransfer(0x26);				//SEnd the Start of frame character
      //Use the _num_boards parameter to determine how many frames to send
      for(int screen=0; screen<NUM_BOARDS; screen++)
      {
        sendScreen(screenBuffer[screen].pixel);	//Send frame data over SPI.
      }
      digitalWrite(SLAVESELECT, HIGH);	//Unselect the LED matrices
    }
    
    void sendScreen(char * screen)
    {
      for(int row=0; row<NUM_ROWS; row++)
      {
        for(int column=0; column<NUM_COLUMNS; column++)
        {
          spiTransfer(screen[(row*8)+column]);
        }
      }
    }
    
    void scrollBuffer(int speed)
    {
      //This huge loop scrolls a character one column to the left each time through.
      for(int scroll = 7; scroll >=0; scroll--)
      {
        for(int board = NUM_BOARDS+1; board >=0; board--)
        {
          for(int row=0; row<NUM_ROWS; row++)
          {
            for(int column=0; column<NUM_COLUMNS; column++)
            {
              myScreen[board].pixel[row*NUM_ROWS+column]=screenBuffer[(column+scroll)/8+board].pixel[(row*NUM_ROWS)+(column+scroll)%8];
            }
          }
        }
    
        digitalWrite(SLAVESELECT, LOW);
        spiTransfer(0x26);
        //We start from the second index so that a character can be scrolled all the way off the frame.
        for(int i=0; i<NUM_BOARDS; i++)sendScreen(myScreen[i].pixel);
        digitalWrite(SLAVESELECT, HIGH);
        delay(speed);
      }
    }
    //char
    void scroll(char * message, char color, int speed)
    {
      int messageLength=0;
      char disp[58]="";
    
      if(color == 0x25 || color == 0x26);
      else{
    
        //Precede the message with spaces so the message starts off of the frame.
        for(int i=0; i<NUM_BOARDS; i++)disp[i]=' ';
    
        strcat(disp, message);
        //Find the length of the screen (including the spaces we added).
    
        messageLength=strlen(disp);
    
        //Scroll each character onto and off of the frame.
        for(int messageIndex=0; messageIndex<messageLength; messageIndex++)
        {
          for(int screen=NUM_BOARDS+1; screen>=0; screen--)
          {
            fillChar(NUM_BOARDS+1-screen, disp[messageIndex+screen], color);
          }
          scrollBuffer(speed);
        }	
      }
    }
    
    void clear(void)
    {
      for(int board=0; board<NUM_BOARDS; board++)
      {
        fillScreen(board, BLACK);
        //free(screenBuffer[board].pixel);
        //memset(&screenBuffer[board].pixel, 0, sizeof (screen));
      }
      display();
    }
    
    //************ CLOCK FUNCTIONS *****************************************************************************************
    // CONVERTERS ##########################################################################################################
    byte decToBcd(byte val){
      // Convert normal decimal numbers to binary coded decimal
      return ( (val/10*16) + (val%10) );
    }
    byte bcdToDec(byte val)  {
      // Convert binary coded decimal to normal decimal numbers
      return ( (val/16*10) + (val%16) );
    }
    // END: CONVERTERS #####################################################################################################
    // TIME GETTERS ########################################################################################################
    // GET TIME ------------------------------------------------------------------------------------------------------------
    String getTime(){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      String h = hour;
      if(hour<10) h = "0"+h;
      String m = minute;
      if(minute<10) m = "0"+m; 
      String all = h+":"+m;
      return all;
    }
    // END: GET TIME -------------------------------------------------------------------------------------------------------
    // GET DATE ------------------------------------------------------------------------------------------------------------
    String getDate(){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      String date;
      switch(weekDay){ // Weekdays in German
      case 1:
        date = "MO";
        break;
      case 2:
        date = "DI";
        break;
      case 3:
        date = "MI";
        break;
      case 4:
        date = "DO";
        break;
      case 5:
        date = "FR";
        break;
      case 6:
        date = "SA";
        break;
      case 7:
        date = "SO";
        break;
      default: 
        break;
      }
    
      String monthDayString = monthDay;
      String monthString = month;
    
      if(monthDay<10) monthDayString = "0"+monthDayString;
      if(month<10) monthString = "0"+monthString;
    
      date = date+", "+monthDayString+"."+monthString+".20"+year;
      return date;
    }
    // END: GET DATE -------------------------------------------------------------------------------------------------------
    // END: TIME GETTERS ###################################################################################################
    // TIME SETTERS ########################################################################################################
    // CHANGE HOUR (DESIGNED FOR +-1) --------------------------------------------------------------------------------------
    void changeHour(int h){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      if(hour==23) hour = 0;
      else hour = hour + h;
    
      setDateTime(second, minute, hour, weekDay, monthDay, month, year);  
    }
    // END: CHANGE HOUR ----------------------------------------------------------------------------------------------------
    // CHANGE MINUTE (DESIGNED FOR +-1) ------------------------------------------------------------------------------------
    void changeMinute(int m){
      // Reset the register pointer
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0);
      Wire.endTransmission();
    
      Wire.requestFrom(DS1307_ADDRESS, 7);
    
      int second = bcdToDec(Wire.receive());
      int minute = bcdToDec(Wire.receive());
      int hour = bcdToDec(Wire.receive() & 0b111111); //24 hour time
      int weekDay = bcdToDec(Wire.receive()); //0-6 -> sunday - Saturday
      int monthDay = bcdToDec(Wire.receive());
      int month = bcdToDec(Wire.receive());
      int year = bcdToDec(Wire.receive());
    
      if(minute==59) minute = 0;
      else minute = minute + m;
    
      setDateTime(second, minute, hour, weekDay, monthDay, month, year);  
    }
    // END: CHANGE MINUTE --------------------------------------------------------------------------------------------------
    // SET TIME ------------------------------------------------------------------------------------------------------------
    void setDateTime(int second, int minute, int hour, int weekDay, int day, int month, int year){
    
      byte s = (byte) second; //0-59
      byte m = (byte) minute; //0-59
      byte h = (byte) hour; //0-23
      byte w = (byte) weekDay; //1-7
      byte d = (byte) day; //1-31
      byte m2 = (byte) month; //1-12
      byte y  = (byte) year; //0-99
    
      Wire.beginTransmission(DS1307_ADDRESS);
      Wire.send(0); //stop Oscillator
    
      Wire.send(decToBcd(s));
      Wire.send(decToBcd(m));
      Wire.send(decToBcd(h));
      Wire.send(decToBcd(w));
      Wire.send(decToBcd(d));
      Wire.send(decToBcd(m2));
      Wire.send(decToBcd(y));
    
      Wire.send(0); //start 
    
      Wire.endTransmission();
    }
    // END: SET TIME -------------------------------------------------------------------------------------------------------
    // END: TIME SETTERS ###################################################################################################
    // END: ******* CLOCK FUNCTIONS ****************************************************************************************
    

Anmelden zum Antworten