INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Schaltuhr mit anlernbarem IR Sender für Klima
27.10.2019, 09:59 (Dieser Beitrag wurde zuletzt bearbeitet: 27.10.2019 10:40 von volvodidi.)
Beitrag #1
Schaltuhr mit anlernbarem IR Sender für Klima
Hi,
nachdem ich den Wecker am laufen habe (Dank an Tommy56), hab ich den Sketch umgebaut zur Schaltuhr mit Ein/Aus Funktion. Hab mir erst einmal ein Relais bestellt, mit Ansteuerung für den Arduino (an Pin 13 der einzig übriggebliebene).
Die erste Version wird wohl mit Relais, mit dem ich meine Universalfernbedienung Ein/Aus schalte (Ein/Aus Tasterkontakt hab ich rausgeführt aus der FB). Zur Zeit steht da noch der Buzzer im Sketch (Edit Buzzer durch Relais Ansteuerung ersetzt).
Als Endziel möchte ich die Schaltuhr erweitern, mit einer Anlernfunktion für jeweils On und Off des Fernbedienungssignal. Was dann jeweils zum Zeitpunkt On bzw. Off gesendet wird. Dadurch hätte ich die Möglichkeit, Änderungen in der Klima Einstellung vorzunehmen, indem ich in den Anlernmodus gehe, und mit der original FB das Signal einlese. Ansonsten müsste ich immer seperat die Daten auslesen, und dann die RAW Daten in den jeweiligen Bereich kopieren.
Ist eine LG Singel Split, es wird also ein Paket mit allen Einstellwerten von der FB gesendet.
2 Tasten auf dem Keypad wären dafür noch übrig.
Da der Uno schon gut belegt ist, mit dem DS1302 RTC, Ic2 LCD, und dem 4x4 Keypad, hab ich digital nur noch Pin 13 frei. Auch Speichermäßig wird das wohl eng.

Frage:
Wäre ich mit einem Mega nicht besser bedient, da der mehr Digital Pins und Speicher hat?

Den hätte ich noch hier liegen.

Dieter

So sieht der Sketch jetzt aus:
Code:
//This code is to use with DS1302 RTC module + 4*4 Keypad + LCD i2c + Arduino + Relais
//After wiring the modules, the LCD will show the default date and time or the one set before
//The objective of this project is that you can set the RTC module from the keypad, and sure it will stay stored
//Then show it on the screen and after you can set your alarm.
//Refer to Surtrtech.com or SurtrTech youtube channel for more information

#include <Keypad.h> //Libraries needed
#include <Wire.h>
#include <virtuabotixRTC.h>
#include <LiquidCrystal_I2C.h>

#define I2C_ADDR 0x27 //LCD i2c stuff
#define BACKLIGHT_PIN 3
#define En_pin 2
#define Rw_pin 1
#define Rs_pin 0
#define D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7

LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);


virtuabotixRTC myRTC(2, 3, 4); //Wiring of the RTC (CLK,DAT,RST)
                               //If you change the wiring change the pins here also


const byte numRows= 4; //number of rows on the keypad
const byte numCols= 4; //number of columns on the keypad

//keymap defines the key pressed according to the row and columns just as appears on the keypad
char keymap[numRows][numCols]=
{
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};


byte rowPins[numRows] = {12,11,10,9}; //Rows 0 to 3 //if you modify your pins you should modify this too
byte colPins[numCols]= {8,7,6,5}; //Columns 0 to 3

int i1,i2,i3,i4;
char c1,c2,c3,c4;
char keypressed,keypressedx;

int A_hour=NULL;
int A_minute=NULL;
int B_hour=NULL;
int B_minute=NULL;
int AlarmIsActive=NULL;

int RELAIS = 13;                 // Pin 13 am Arduino festlegen


Keypad myKeypad= Keypad(makeKeymap(keymap), rowPins, colPins, numRows, numCols);


void setup() {
  Serial.begin(9600);
  lcd.begin (16,2); //Initialize the LCD
  lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
  lcd.setBacklight(HIGH);
  lcd.home ();
                                                  
}

void loop() {
  
  while(keypressed == NO_KEY){ //As long as no key is pressed we keep showing the date and time, I'm obliged to clear the screen everytime so the numbers don't get confused
                               //And I should add that little delay so the screen shows correctly otherwise it didn't work for me
  keypressed = myKeypad.getKey();
  lcd.clear(); //Here after clearing the LCD we take the time from the module and print it on the screen with usual LCD functions
  myRTC.updateTime();

  if(myRTC.hours==A_hour && myRTC.minutes==A_minute && AlarmIsActive==1 && myRTC.seconds >= 0 && myRTC.seconds <= 2){
     digitalWrite(RELAIS, HIGH);  // Schaltet ein
     delay(1000);
     digitalWrite(RELAIS, LOW);   // Schaltet aus
     lcd.clear();
     lcd.print("Einschalten"); //Message to show when the alarm is ringing
     delay(500);
     lcd.clear();
  }  
   if(myRTC.hours==B_hour && myRTC.minutes==B_minute && AlarmIsActive==1 && myRTC.seconds >= 0 && myRTC.seconds <= 2){
     digitalWrite(RELAIS, HIGH);  // Schaltet ein
     delay(1000);
     digitalWrite(RELAIS, LOW);   // Schaltet aus
     lcd.clear();
     lcd.print("Ausschalten"); //Message to show when the alarm is ringing
     delay(500);
     lcd.clear();
  }
  keypressedx = NO_KEY;
  lcd.setCursor(0,0);
  lcd.print(myRTC.hours);
  lcd.print(":");
  lcd.print(myRTC.minutes);
  lcd.print(":");
  lcd.print(myRTC.seconds);
  lcd.setCursor(9,0);
  lcd.print("Timer ");
  lcd.print(AlarmIsActive);
  lcd.setCursor(0,1);
  lcd.print("1 ");
  lcd.print(A_hour);
  lcd.print(":");
  lcd.print(A_minute);
  lcd.setCursor(8,1);
  lcd.print(" 0 ");
  lcd.print(B_hour);
  lcd.print(":");
  lcd.print(B_minute);
  delay(100);
  }


         if (keypressed == '*') //As we everytime check the key pressed we only proceed to setup if we press "*"
             {
              lcd.clear();
              lcd.print("Setup");
             delay(1000);
              lcd.clear();
              lcd.print("Jahr");
              //So you can understand how this works, first it shows us "setup" then it prints "setup year" and now you can write your year normally (2-0-1-8)
              //It automatically passes to setting up the month...until it's finished
              //The keys from keypad are all considered chars (c) so we should convert them to int that's what I did then we store them (i)
              //We do some math and we get the year, month... as int so we can inject them to the RTC otherwise it will not be compiled
              //Months like April you should write 04, 03 for March... otherwise it will not pass to the next parameter
              //The RTC virtuabotix library is already set to not accept strange time and dates (45/17/1990) (58:90:70), and yes old dates are considered as errors
             char keypressed2 = myKeypad.waitForKey();  
                    if (keypressed2 != NO_KEY && keypressed2 !='*' && keypressed2 !='#' && keypressed2 !='A' && keypressed2 !='B' && keypressed2 !='C' && keypressed2 !='D' )
                      {
                       c1 = keypressed2;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                 char      keypressed3 = myKeypad.waitForKey();
                    if (keypressed3 != NO_KEY && keypressed3 !='*' && keypressed3 !='#' && keypressed3 !='A' && keypressed3 !='B' && keypressed3 !='C' && keypressed3 !='D' )
                      {
                       c2 = keypressed3;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }
                   char  keypressed4 = myKeypad.waitForKey();
                   if (keypressed4 != NO_KEY && keypressed4 !='*' && keypressed4 !='#' && keypressed4 !='A' && keypressed4 !='B' && keypressed4 !='C' && keypressed4 !='D' )
                      {
                       c3 = keypressed4;
                       lcd.setCursor(2, 1);
                       lcd.print(c3);
                       }
                   char   keypressed5 = myKeypad.waitForKey();
                   if (keypressed5 != NO_KEY && keypressed5 !='*' && keypressed5 !='#' && keypressed5 !='A' && keypressed5 !='B' && keypressed5 !='C' && keypressed5 !='D' )
                      {
                       c4 = keypressed5;
                       lcd.setCursor(3, 1);
                       lcd.print(c4);
                       }

                     i1=(c1-48)*1000;        //the keys pressed are stored into chars I convert them to int then i did some multiplication to get the code as an int of xxxx
                     i2=(c2-48)*100;
                     i3=(c3-48)*10;
                     i4=c4-48;
                     int N_year=i1+i2+i3+i4;
                   delay(500);
                     lcd.clear();
                     lcd.print("Monat");

////////////////////////////////////////////////////////////////
                     char keypressed6 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed6 != NO_KEY && keypressed6 !='*' && keypressed6 !='#' && keypressed6 !='A' && keypressed6 !='B' && keypressed6 !='C' && keypressed6 !='D' )
                      {
                       c1 = keypressed6;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                    char   keypressed7 = myKeypad.waitForKey();
                    if (keypressed7 != NO_KEY && keypressed7 !='*' && keypressed7 !='#' && keypressed7 !='A' && keypressed7 !='B' && keypressed7 !='C' && keypressed7 !='D' )
                      {
                       c2 = keypressed7;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                    int N_month=i1+i2;
                     delay(500);

                     lcd.clear();
                     lcd.print("Tag");
                    
////////////////////////////////////////////////////////////////                    
                      char keypressed8 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed8 != NO_KEY && keypressed8 !='*' && keypressed8 !='#' && keypressed8 !='A' && keypressed8 !='B' && keypressed8 !='C' && keypressed8 !='D' )
                      {
                        c1 = keypressed8;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                      char keypressed9 = myKeypad.waitForKey();
                    if (keypressed9 != NO_KEY && keypressed9 !='*' && keypressed9 !='#' && keypressed9 !='A' && keypressed9 !='B' && keypressed9 !='C' && keypressed9 !='D' )
                      {
                        c2 = keypressed9;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                    int N_day=i1+i2;
                    delay(500);
                     lcd.clear();
                     lcd.print("Stunde");
////////////////////////////////////////////////////////////////////////////////////:                    
                     char keypressed10 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed10 != NO_KEY && keypressed10 !='*' && keypressed10 !='#' && keypressed10 !='A' && keypressed10 !='B' && keypressed10 !='C' && keypressed10 !='D' )
                      {
                       c1 = keypressed10;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                    char   keypressed11 = myKeypad.waitForKey();
                    if (keypressed11 != NO_KEY && keypressed11 !='*' && keypressed11 !='#' && keypressed11 !='A' && keypressed11 !='B' && keypressed11 !='C' && keypressed11 !='D' )
                      {
                        c2 = keypressed11;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                    int N_hour=i1+i2;
                    delay(500);
                     lcd.clear();
                     lcd.print("Minuten");
////////////////////////////////////////////////////////////////////////////////////:
                    char keypressed12 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed12 != NO_KEY && keypressed12 !='*' && keypressed12 !='#' && keypressed12 !='A' && keypressed12 !='B' && keypressed12 !='C' && keypressed12 !='D' )
                      {
                        c1 = keypressed12;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                   char    keypressed13 = myKeypad.waitForKey();
                    if (keypressed13 != NO_KEY && keypressed13 !='*' && keypressed13 !='#' && keypressed13 !='A' && keypressed13 !='B' && keypressed13 !='C' && keypressed13 !='D' )
                      {
                        c2 = keypressed13;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                    int N_minutes=i1+i2;
                    delay(500);
                     lcd.clear();

                    myRTC.setDS1302Time(22, N_minutes, N_hour, 1, N_day, N_month, N_year); //once we're done setting the date and time we transfer to values to the RTC module
                                                                                           //the 22 stands for seconds you can add a setup for it too if you want
                                                                                           //the 1 stands for day of the week, as long I don't show it on the screen I don't change it
                    keypressed=NO_KEY; //the "*" key is stored in "keypressed" so I remove that value from it otherwise it will get me in the setup again
              }
/////////////////////////////////////////Alarme setup/////////////////////////////////
              
             if (keypressed == 'A'){
              lcd.clear();
              lcd.print("  On Off setup  ");
              delay(1000);
              lcd.clear();
              lcd.print("  Set On hour   ");
              
               char keypressed14 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed14 != NO_KEY && keypressed14 !='*' && keypressed14 !='#' && keypressed14 !='A' && keypressed14 !='B' && keypressed14 !='C' && keypressed14 !='D' )
                      {
                       c1 = keypressed14;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                    char   keypressed15 = myKeypad.waitForKey();
                    if (keypressed15 != NO_KEY && keypressed15 !='*' && keypressed15 !='#' && keypressed15 !='A' && keypressed15 !='B' && keypressed15 !='C' && keypressed15 !='D' )
                      {
                        c2 = keypressed15;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                     A_hour=i1+i2;
                    delay(1000);
                     lcd.clear();
                     lcd.print("Set On minutes");
                      char keypressed16 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed16 != NO_KEY && keypressed16 !='*' && keypressed16 !='#' && keypressed16 !='A' && keypressed16 !='B' && keypressed16 !='C' && keypressed16 !='D' )
                      {
                       c1 = keypressed16;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                    char   keypressed17 = myKeypad.waitForKey();
                    if (keypressed17 != NO_KEY && keypressed17 !='*' && keypressed17 !='#' && keypressed17 !='A' && keypressed17 !='B' && keypressed17 !='C' && keypressed17 !='D' )
                      {
                        c2 = keypressed17;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                     A_minute=i1+i2;
                    delay(500);
                    lcd.clear();
                    lcd.print("Set Off hour");
              
                    char keypressed18 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed18 != NO_KEY && keypressed18 !='*' && keypressed18 !='#' && keypressed18 !='A' && keypressed18 !='B' && keypressed18 !='C' && keypressed18 !='D' )
                      {
                       c1 = keypressed18;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                    char   keypressed19 = myKeypad.waitForKey();
                    if (keypressed19 != NO_KEY && keypressed19 !='*' && keypressed19 !='#' && keypressed19 !='A' && keypressed19 !='B' && keypressed19 !='C' && keypressed19 !='D' )
                      {
                        c2 = keypressed19;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                     B_hour=i1+i2;
                    delay(1000);
                     lcd.clear();
                     lcd.print("Set Off minutes");
                      char keypressed20 = myKeypad.waitForKey();  // here all programs are stopped until you enter the four digits then it gets compared to the code above
                    if (keypressed20 != NO_KEY && keypressed20 !='*' && keypressed20 !='#' && keypressed20 !='A' && keypressed20 !='B' && keypressed20 !='C' && keypressed20 !='D' )
                      {
                       c1 = keypressed20;
                       lcd.setCursor(0, 1);
                       lcd.print(c1);
                       }
                    char   keypressed21 = myKeypad.waitForKey();
                    if (keypressed21 != NO_KEY && keypressed21 !='*' && keypressed21 !='#' && keypressed21 !='A' && keypressed21 !='B' && keypressed21 !='C' && keypressed21 !='D' )
                      {
                        c2 = keypressed21;
                       lcd.setCursor(1, 1);
                       lcd.print(c2);
                       }


                     i1=(c1-48)*10;
                     i2=c2-48;
                     B_minute=i1+i2;
                    delay(500);
                     lcd.clear();
                      AlarmIsActive=1;
                      keypressed=NO_KEY;
             }
             if (keypressed == 'B')
             {
              lcd.clear();
              lcd.print("ON Off Aus");
              AlarmIsActive=0;
              A_hour=NULL;
              A_minute=NULL;
              B_hour=NULL;
              B_minute=NULL;
              keypressed=NO_KEY;
              delay(1000);
             }
             else {
              myRTC.updateTime();
              keypressed=NO_KEY;
             }
            

}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2019, 10:44
Beitrag #2
RE: Schaltuhr mit anlernbarem IR Sender für Klima
Mehr Speicher und mehr Pins am MEGA sind natürlich praktischer.

Du könntest aber auch anstelle der DS1302 die wesentlich genauere DS3231 mit I2C nehmen und die Tastaturmatrix über einen PCF 8874 auch an I2C anschließen, dann würdest Du für alle 3 Sachen (incl. Display) nur die beiden I2C-Pins brauchen.

Konstante Ausgabezeichenketten solltest Du ins F-Macro stecken, das spart RAM.
Das laufende clear am LCDS führt zu Flackern. Nur das neu schreiben, was sich geändert hat.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2019, 11:04
Beitrag #3
RE: Schaltuhr mit anlernbarem IR Sender für Klima
Hi Tommy,
ja, das Flackern ist mir auch schon aufgefallen. Aber ich bin absoluter Dummi im Programmieren. Das Sketch hab ich durch try and error und paste and copy zusammengebaut (ich weiß wird hier nicht gerne gesehen).
Und hoffe so auch weiter zu kommen. Um mich hier in die Programmierung einzuarbeiten, habe ich einfach keine Zeit.
Ich weiß, die IR Geschichte ist nicht ohne.
Ich brauch die Zeitschaltuhr, da meine neue LG Klima zwar einen Timer hat, der aber jeden Tag aufs neue gesetzt werden muss. Die Steuerung brauche ich, um ab 22:00 die Klima ein und um 6:00 aus zu schalten (als Nachtabsenkung), da Tagsüber ein Pelletofen die Heizung übernimmt. Und das wird auch nur für ca. 2-3 Wochen Weihnachten, und evtl. mal 1-2 Wochen im je nach Witterung im Herbst genutzt.
Meine erste Lösung war eine Steckdosenzeitschaltuhr mit Multifunktionsrelais, und daran angeschlossen der On/Off Taster der Universal FB.
Da ist jetzt die Arduino Lösung etwas komfortabler, und wenn das Ganze in einem Gehäuse verbaut ist auch optisch schöner wie der Drahtverhau vorher.
Gruß
Dieter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2019, 11:14
Beitrag #4
RE: Schaltuhr mit anlernbarem IR Sender für Klima
(27.10.2019 11:04)volvodidi schrieb:  Ich weiß wird hier nicht gerne gesehen

Das ist quatsch.
Warum sollte das hier nicht gerne gesehen sein ?

Die meisten Anfänger starten so und denen wird auch geholfen.
Nur mitarbeiten und lernen muss man selber, sowie das von uns geschriebene auch verstehen.
Wenn das nicht gegeben ist, hat der Fragesteller ein Problem.

Also lernen und mitarbeiten, dann ist alles gut.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2019, 11:14
Beitrag #5
RE: Schaltuhr mit anlernbarem IR Sender für Klima
(27.10.2019 11:04)volvodidi schrieb:  Das Sketch hab ich durch try and error und paste and copy zusammengebaut (ich weiß wird hier nicht gerne gesehen).
Wenn Dabei etwas funktionierendes raus kommt, ist es ok.
An irgendeinem Punkt musst Du Dich aber entscheiden: Lernen oder auf Funktionalität verzichten oder einen Dienstleister bezahlen.
Beim Lernen helfen wir gern.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2019, 11:51
Beitrag #6
RE: Schaltuhr mit anlernbarem IR Sender für Klima
Ich schau mal wie weit ich komme.
Das Flackern hab ich auch beruhigt, hab den delay bei der Zeitanzeige auf 1000ms gesetzt und die Sec. Anzeige rausgenommen, brauch ich nicht.
Das LCD hab ich auch gedimmt mit einem Poti anstelle des Jumpers (Backlight) auf dem I2c Controller.

Was hat eigentlich die (Serial.begin(9600)Wink die 9600 zu sagen?
Hat was mit Datendurchsatz 9600 baud zu tun. Aber warum 9600 und nicht mehr?
Hängt das vielleicht mit der RTC, dem Uno, oder dem I2c LCD zusammen?

Dieter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2019, 12:03
Beitrag #7
RE: Schaltuhr mit anlernbarem IR Sender für Klima
(27.10.2019 11:51)volvodidi schrieb:  Ich schau mal wie weit ich komme.
Das Flackern hab ich auch beruhigt, hab den delay bei der Zeitanzeige auf 1000ms gesetzt und die Sec. Anzeige rausgenommen, brauch ich nicht.
Das LCD hab ich auch gedimmt mit einem Poti anstelle des Jumpers (Backlight) auf dem I2c Controller.

Was hat eigentlich die (Serial.begin(9600)Wink die 9600 zu sagen?
Hat was mit Datendurchsatz 9600 baud zu tun. Aber warum 9600 und nicht mehr?
Hängt das vielleicht mit der RTC, dem Uno, oder dem I2c LCD zusammen?

Dieter

Das Flackern durch ein Delay verhindern ist grob gesagt "Dumm".
Du solltest generell Delays im Sketch verhindern. Dadurch blockierst du deinen Sketch und verhinderst ein zügiges Arbeiten.
Mit dem Poti auf dem Adapter dimmst du nicht das Display, sondern änderst den Kontrast. Ein Dimmen gelingt bei dem Display über das Ändern der Hintergrundbeleuchtung.

Und die Geschwindigkeit der seriellen Übertragung kannst du gern höher setzen.
Du musst auch den seriellen Monitor daran anpassen.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2019, 13:21 (Dieser Beitrag wurde zuletzt bearbeitet: 27.10.2019 13:22 von volvodidi.)
Beitrag #8
RE: Schaltuhr mit anlernbarem IR Sender für Klima
Hi Dieter,
da hast du mich falsch verstanden.
Auf dem I2c Controller für das LCD sitzt ein Poti für den Kontrast, und es gibt einen Jumper mit dem das Backlight an/aus geschaltet wird ( wofür der auch immer gut ist).
Anstelle des Jumpers hab ich ein 5k Poti gesetzt, mit dem ich die Helligkeit des Backlight einstellen kann, unabhängig vom Kontrast.
Für meine Anwendung ist es nicht besonders wichtig auf die Sekunde zu schalten.
Die 9600 hat mich deshalb interessiert, da ich wahrscheinlich eine höhere Baudrate zum auslesen und senden der Fernbedienungsdaten benötige, da wird ja ein größerer String gesendet (mit allen Einstellungen der Klima). Falls ich das hinbekomme.

Gruß
Dieter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 2 Gast/Gäste