Ankündigung

Einklappen
Keine Ankündigung bisher.

KONNEKTING 16CH Binäreingang (potentialfrei) für Reed-Kontakte

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    So ich möchte euch mal einen kleinen Bausatz anbieten, damit etwas Wind in die Entwicklung kommt.

    Ihr müsst etwas selber Hand anlegen und die grünen Terminal Blöcke selber anlöten, das MicroMatch-Kabel und Stecker anbringen und die Platinen verschrauben.
    Sollte also schon machbar sein.

    Damit könnt Ihr 16 Reed-Kontakte einlesen, oder 3 der Eingänge für S0-Schnittstellen verwenden.
    Über eine Logik kann man die 16Ch so zusammenschalten, dass sobald ein Fenster einer Gruppe geöffnet wird, eine KO gesendet wird.
    Später kann auch noch zusätzlich eine Frontplatine nachgerüstet werden, dafür ist alle vorbereitet.

    Den Arduino-Code stelle ich zur Verfügung und bin für jede Optimierung dankbar :-)
    Geflasht kann über USB(Arduino-IDE) und auch über einen ATMEL-ICE Debugger.


    Bei Fragen einfach melden.

    Mini-BCU 15€
    Controller-Platine 20€
    Applikations-Platine 20€

    Achtung überarbeitet: (hatte das MicroMatch-Kabel und den Analog-SW noch gar nicht eingerechnet)


    Bausatz.PNG
    Zuletzt geändert von Masifi; 14.02.2017, 17:04.

    Kommentar


      Jetzt möchte ich euch mal noch einen kurzen Zwischenstand hierfür geben.

      HW Version 2.0 ist angekommen und erfolgreich in Betrieb genommen. (Bilder folgen). Ich finde das diese Version sehr gelungen ist und ich mir definitiv so in mein Haus (wenn ich mal eins habe ) einbaue.

      Zum Anderen bin ich gerade noch dabei, 10 OKW Gehäuse dafür zu bestellen, was gar nicht so einfach war, bis man die Info bekommen hat, dass es sehr Hilfreich ist, mit einem Bestellbetrag von >100€ und nicht 99,7€ zu bestellen
      Zuletzt geändert von Masifi; 16.03.2017, 17:03.

      Kommentar


        Hättest du mal gefragt... ;-) Hätte ich dir gleich sagen können.

        Kommentar




          20170323_201759.jpg

          20170323_201710.jpg

          Kommentar


            20170323_201837.jpg

            20170323_201926.jpg

            Kommentar


              Hier noch die versprochenen Bilder. :-)

              Kommentar


                Sehen hübsch aus die Platinchen :-)
                Viele Grüsse
                Jürgen

                Kommentar


                  Wie gesagt, bin selber etwas angetan davon

                  Kommentar


                    Durch den Umbau auf Optokoppler und einer anderen Ruhestrombeschaltung muss ich jetzt noch etwas an Code feilen, aber das Ende rückt immer näher ☺
                    Ich hoffe, das ich die nächten Tage dafür etwas Zeit finde.

                    Kommentar


                      So jetzt hatte ich noch etwas Zeit und habe weitergearbeitet. Die Zeit gerade leider etwas begrenzt.

                      Aber ich habe jetzt endlich hinbekommen Gehäuse bei OKW zu bestellen :-)

                      und

                      der Code ist jetzt auch an die neue Platine angepasst. Läuft soweit super, aber man könnte das ein oder andere daran sicher noch optimieren.


                      Ich bin jetzt nur über Ostern für 2 Wochen etwas beschäftigt und werde daher keine Zeit haben weiter zu machen.

                      ABER, danach sollte es dann langsam mal Richtung fertigem Produkt gehen :-)

                      Kommentar


                        Falls jemand sich mal den Code anschauen will :-)
                        Vergebt mir für meinen "Programmier-Style"


                        Code:
                        #include <KonnektingDevice.h>
                        #include "kdevice_KNX_Bineareingang_Multi.h"
                        #include "Timer.h"
                        #include "EEPROM.h"
                        #include "S0_Schnittstelle.h"
                        
                        
                        #include <Wire.h>
                        #include <PCF8575.h> // Required for PCF8575
                        
                        // ################################################
                        // ### DEBUG CONFIGURATION
                        // ################################################
                           // I2C-MODE
                        #define I2COFF // comment this line to disable I2C mode
                           // DEBUG-MODE
                        #define KDEBUG // comment this line to disable DEBUG mode
                           // Anzeige-Platine
                        //#define ANZEIGE_Platine
                        
                        #ifdef KDEBUG
                        #include <DebugUtil.h>
                        
                        // Get correct serial port for debugging
                        #ifdef __AVR_ATmega32U4__
                        // Leonardo/Micro/ProMicro use the USB serial port
                        #define DEBUGSERIAL Serial
                        #elif __SAMD21G18A__ 
                        // Zero use
                        #define DEBUGSERIAL SerialUSB
                        #elif ESP8266
                        // ESP8266 use the 2nd serial port with TX only
                        #define DEBUGSERIAL Serial1
                        #else
                        // All other, (ATmega328P f.i.) use software serial
                        #include <SoftwareSerial.h>
                        SoftwareSerial softserial(11, 10); // RX, TX
                        #define DEBUGSERIAL softserial
                        #endif
                        // end of debugging defs
                        #endif
                        
                        
                        // ################################################
                        // ### KONNEKTING Configuration
                        // ################################################
                        #ifdef __AVR_ATmega328P__
                        #define KNX_SERIAL Serial // Nano/ProMini etc. use Serial
                        #elif ESP8266
                        #define KNX_SERIAL Serial // ESP8266 use Serial
                        #else
                        #define KNX_SERIAL Serial1 // Leonardo/Micro/Zero etc. use Serial1
                        #endif
                        
                        // ################################################
                        // ### IO Configuration
                        // ################################################
                        #define PROG_LED_PIN    A2
                        #define PROG_BUTTON_PIN A1
                        #define LED_YELLOW      25     
                        #define SAVE_PIN        38
                        #define MAX_CH          15
                        
                        // ################################################
                        // ### define Parameter
                        // ################################################
                        boolean CH_invert[16];
                        boolean S0_aktiv[5];
                        boolean zimmerMaskierung_Sendvalue = false;
                        uint8_t  filter_count =  1;
                        uint8_t abfrage_Interval = 0;
                        uint8_t sende_Zyklus_Zaehler = 0;
                        uint16_t zaehler_Impulse[4]={5,5,5,5};            
                        uint16_t mask_Zimmer[5] = {0,0,0,0,0};    
                        
                        // ################################################
                        // ### define Variables
                        // ################################################
                        boolean run_save = false;
                        boolean set_pullup_aktiv = false;
                        boolean set_pullup_deaktiv = false;
                        boolean isDelay;
                        uint8_t ch_m[10][16];
                        uint8_t ch_v[16];
                        boolean ch[16];
                        boolean ch_old[16];
                        boolean set_S0_LED[4];
                        boolean S0_LED_ON[4];
                        int set_S0_LED_time[4];
                        int time_count = 0;
                        boolean state_Zimmer[5] = {false};
                        boolean state_Zimmer_old[5] = {false};
                        uint16_t PNS = 0;
                        uint16_t maske = 0;
                        uint16_t maske2 = 0;
                        int count = 0;
                        uint16_t zwischenstand = 0;
                        
                        
                        enum State
                        {
                          SetVCC = 1,
                          ReadIO = 2,
                          IsInvert = 3,
                          MaskIO = 4,
                          IsChange_CH_ONE = 5,
                          IsChange_CH_TWO = 6,
                          UnsetVCC = 7,
                          MaskRoom = 8,
                          Finish = 9,
                        }CHState;
                        uint8_t inputCH = 17; // muss >16 sein
                        
                        // ################################################
                        // ### define S0 PINS
                        // ################################################
                        #define S0_1_pin     11   //IO6
                        #define S0_2_pin     5    //IO7
                        #define S0_3_pin     6    //IO8
                        #define S0_4_pin     2    //IO9
                        uint16_t S0_Zaehler[4]= {1,1,1,1};
                        uint16_t S0_Zaehler_old[4]= {0,0,0,0};
                        uint16_t S0_impuls[4];
                        boolean sendZaehler_Cycle = false;
                        int sende_Zyklus = 0;
                        
                        
                        // ################################################
                        // ### define IO Expander
                        // ################################################
                        PCF8575 expander;
                        PCF8575 expander_VCC;
                        PCF8575 expander_LED;
                        
                        
                        // ################################################
                        // ### Funktion
                        // ################################################
                        
                        //****************** Save Paramter **************************************************
                        void SAVE_State(){
                         digitalWrite(LED_YELLOW, HIGH);
                         writeSAVE(S0_Zaehler,S0_impuls); 
                        }
                        
                        
                        //****************** IO CH Send-Function *******************************************
                        
                        void sendStatus(int i, boolean ch_old[]){
                          Knx.write(i*2,ch_old[i]);
                          Knx.task();
                            #ifdef ANZEIGE_Platine
                            expander_LED.digitalWrite(MAX_CH-i,!ch_old[i]);
                            #endif 
                            #ifdef KDEBUG
                            Debug.print("CH:");
                            Debug.print("%d",i); 
                            Debug.print(": "); 
                            Debug.println("%d", ch_old[i]); 
                            #endif 
                        }
                        
                        
                        //****************** isChange-Function *******************************************
                        
                        void isChange(int i, boolean ch[],boolean ch_old[]){
                          if(ch[i] != ch_old[i])
                             {Knx.write(i*2,ch[i]);
                              Knx.task();
                                #ifdef ANZEIGE_Platine
                                expander_LED.digitalWrite(MAX_CH-i,!ch[i]);
                                #endif 
                              ch_old[i] = ch[i];
                                #ifdef KDEBUG
                                Debug.print("CH");
                                Debug.print("%d",i+1); 
                                Debug.print(": "); 
                                Debug.println("%d", ch[i]);  
                                #endif
                             }
                        }
                        
                        //****************** Zimmer  Maskierung  ***********************************************
                        
                        void send_Zimmer_Status(int i, boolean state[]){
                          if(zimmerMaskierung_Sendvalue)
                          {
                            state[i] = !state[i];
                            Knx.write(i+44,state[i]);
                            Knx.task();
                              #ifdef KDEBUG
                              Debug.print("Zimmer:");
                              Debug.print("%d",i+1); 
                              Debug.print(": "); 
                              Debug.println("%d", state[i]); 
                              #endif 
                          }
                        }
                        
                        //****************** S0-Schnittstelle Zaehler  *****************************************
                        
                        void sendZaehlerStand(int i, uint16_t S0_Zaehler[],uint16_t S0_Zaehler_old[]){
                          if(S0_Zaehler[i] != S0_Zaehler_old[i])
                             {S0_Zaehler_old[i] = S0_Zaehler[i];
                              Knx.write(32+(i*3),S0_Zaehler[i]);
                              Knx.task();
                                #ifdef KDEBUG
                                Debug.print("Zaehler");
                                Debug.print("%d",i); 
                                Debug.print(": "); 
                                Debug.println("%d", S0_Zaehler[i]);  
                                #endif 
                              }
                        }
                        
                        void sendZaehlerStand_2(int i, uint16_t S0_Zaehler[]){
                             Knx.write(32+(i*3),S0_Zaehler[i]);
                             Knx.task();
                              S0_Zaehler_old[i] = S0_Zaehler[i];
                                #ifdef KDEBUG
                                Debug.print("Zaehler");
                                Debug.print("%d",i); 
                                Debug.print(": "); 
                                Debug.println("%d", S0_Zaehler[i]);  
                                #endif 
                        }
                        
                        void irq_S0_1(){
                          S0_impuls[0]++;
                          if(S0_impuls[0]>=zaehler_Impulse[0])
                            {S0_Zaehler[0]++;
                             S0_impuls[0] = 0;}
                          #ifdef KDEBUG
                          Debug.print("S0_1: ");
                          Debug.println("%d",S0_impuls[0]);
                          #endif   
                        }
                        
                        void irq_S0_2(){
                            S0_impuls[1]++;
                          if(S0_impuls[1]>=zaehler_Impulse[1])
                            {S0_Zaehler[1]++;
                             S0_impuls[1] = 0;}
                          #ifdef KDEBUG
                          Debug.println("S0_2"); 
                          #endif   
                        }
                        
                        void irq_S0_3(){
                            S0_impuls[2]++;
                          if(S0_impuls[2]>=zaehler_Impulse[2])
                            {S0_Zaehler[2]++;
                             S0_impuls[2] = 0;}
                          #ifdef KDEBUG
                          Debug.println("S0_3");  
                          #endif   
                        }
                        
                        void irq_S0_4(){
                            S0_impuls[3]++;
                          if(S0_impuls[3]>=zaehler_Impulse[3])
                            {S0_Zaehler[3]++;
                             S0_impuls[3] = 0;}
                          set_S0_LED[3] = true;    
                            #ifdef KDEBUG
                            Debug.println("S0_4");  
                            #endif
                        }
                        
                        
                        
                        
                        // #################################################################################
                        // ### SETUP 
                        // #################################################################################
                        
                        void setup(){
                        
                        
                        //****************** Init IO *******************************************************
                          pinMode(LED_YELLOW, OUTPUT);
                          digitalWrite(LED_YELLOW, HIGH);
                          pinMode(S0_1_pin, INPUT);
                          pinMode(S0_2_pin, INPUT);
                          pinMode(S0_3_pin, INPUT);
                          pinMode(S0_4_pin, INPUT);
                          Wire.begin(); // join i2c bus (address optional for master)
                        
                        
                        //****************** Init Debug Interface ********************************************
                          #ifdef KDEBUG
                              // Start debug serial with 9600 bauds
                              DEBUGSERIAL.begin(115200);
                          #if defined(__AVR_ATmega32U4__) || defined(__SAMD21G18A__)
                              // wait for serial port to connect. Needed for Leonardo/Micro/ProMicro/Zero only
                              while (!DEBUGSERIAL)
                          #endif
                              // make debug serial port known to debug class
                              // Means: KONNEKTING will sue the same serial port for console debugging
                              Debug.setPrintStream(&DEBUGSERIAL);
                              Debug.print(F("KONNEKTING DemoSketch\n"));
                          #endif
                        
                        //****************** Init Debug KONNEKTING ********************************************  
                          Konnekting.setMemoryReadFunc(&readEeprom);
                          Konnekting.setMemoryWriteFunc(&writeEeprom);
                          Konnekting.setMemoryUpdateFunc(&updateEeprom);    
                        
                          // Initialize KNX enabled Arduino Board
                          Konnekting.init(KNX_SERIAL,
                                    PROG_BUTTON_PIN,
                                    PROG_LED_PIN,
                                    MANUFACTURER_ID,
                                    DEVICE_ID,
                                    REVISION);
                        
                        
                        
                        //****************** Read Parameter ***************************************************
                          #ifdef KDEBUG
                          Debug.println("READ Parameter");  
                          #endif
                          abfrage_Interval            = (((uint8_t) Konnekting.getUINT8Param(0)+1)*30);  // abfrage_Interval
                          sende_Zyklus_Zaehler        = (uint8_t) Konnekting.getUINT8Param(1);           // sende_Zyklus_Zaehler
                          zimmerMaskierung_Sendvalue  = (uint8_t) Konnekting.getUINT8Param(2);           // Ob HIGH oder LOW gesendet wird
                          filter_count                = (uint8_t) Konnekting.getUINT8Param(3);           // Anzahl wie oft jeder Kanal gemessen wird
                        
                          #ifdef KDEBUG
                          Debug.print("Abfrage-Interval: ");  
                          Debug.println("%d",abfrage_Interval); 
                          Debug.print("Zimmer Maskierung Sendvalue: ");  
                          Debug.println("%d",zimmerMaskierung_Sendvalue); 
                          Debug.print("Anzahl Messungen: ");  
                          Debug.println("%d",filter_count); 
                          #endif
                        
                        //****************** Set Sendezyklus (S0-Schnittstelle) ********************************
                          if(sende_Zyklus_Zaehler == 1) sende_Zyklus =   6000;  // 1min
                          if(sende_Zyklus_Zaehler == 2) sende_Zyklus =  60000;  //10min
                          if(sende_Zyklus_Zaehler == 3) sende_Zyklus = 180000;  //30min
                          if(sende_Zyklus_Zaehler == 4) sende_Zyklus = 360000;  //60min
                        
                          #ifdef KDEBUG
                          Debug.print("Sende-Zyklus: ");  
                          Debug.println("%d",sende_Zyklus); 
                          #endif
                        
                        //****************** Load Settings *****************************************************  
                          //Kanal 1 - 16 Load Settings
                          for(int cha=0; cha<16; cha++)
                            {
                             CH_invert[cha] = (uint8_t) Konnekting.getUINT8Param(cha+5); 
                            }
                          //S0 1 - 4 Load Settings
                          for(int cha=1; cha<5; cha++)
                            {
                            S0_aktiv[cha] = (uint8_t) Konnekting.getUINT8Param(cha+20); 
                            }
                          //Zählerimpulse Load Settings
                          for(int cha=0; cha<4; cha++)
                            {
                            zaehler_Impulse[cha] = (uint16_t) Konnekting.getUINT16Param(cha+25);   
                            }
                          #ifdef KDEBUG
                          Debug.println("READ Zaehler");
                          Debug.print("S0_1 Zaehler(Imp/kwh): ");
                          Debug.println("%d",zaehler_Impulse[0]);
                          Debug.print("S0_2 Zaehler(Imp/kwh): ");
                          Debug.println("%d",zaehler_Impulse[1]);
                          Debug.print("S0_3 Zaehler(Imp/kwh): ");
                          Debug.println("%d",zaehler_Impulse[2]);
                          Debug.print("S0_4 Zaehler(Imp/kwh): ");
                          Debug.println("%d",zaehler_Impulse[3]);
                          #endif  
                        
                          #ifdef KDEBUG
                          Debug.println("READ Zimmermaske");  
                          #endif
                          //ZimmerMasken Load Settings
                          for(int cha=0; cha<5; cha++)
                            {
                            mask_Zimmer[cha] = (uint16_t) Konnekting.getUINT16Param(cha+29);
                            }
                          #ifdef KDEBUG
                          Debug.print("Zimmer1: ");  
                          SerialUSB.println(mask_Zimmer[0], BIN);
                          Debug.print("Zimmer2: ");  
                          SerialUSB.println(mask_Zimmer[1], BIN);
                          Debug.print("Zimmer3: ");  
                          SerialUSB.println(mask_Zimmer[2], BIN);
                          Debug.print("Zimmer4: ");  
                          SerialUSB.println(mask_Zimmer[3], BIN);
                          Debug.print("Zimmer5: ");  
                          SerialUSB.println(mask_Zimmer[4], BIN);
                          #endif    
                        
                          #ifdef KDEBUG
                          Debug.println("READ Zaehlerstaende");  
                          #endif
                          //Read Zählerstände
                          S0_Zaehler[0] = (((uint16_t)readEeprom(1024))<<8 | readEeprom(1025));
                          S0_Zaehler[1] = (((uint16_t)readEeprom(1026))<<8 | readEeprom(1027));
                          S0_Zaehler[2] = (((uint16_t)readEeprom(1028))<<8 | readEeprom(1029));
                          S0_Zaehler[3] = (((uint16_t)readEeprom(1030))<<8 | readEeprom(1031));
                          S0_impuls[0]  = (((uint16_t)readEeprom(1032))<<8 | readEeprom(1033));
                          S0_impuls[1]  = (((uint16_t)readEeprom(1034))<<8 | readEeprom(1035));
                          S0_impuls[2]  = (((uint16_t)readEeprom(1036))<<8 | readEeprom(1037));
                          S0_impuls[3]  = (((uint16_t)readEeprom(1038))<<8 | readEeprom(1039));
                          attachInterrupt(SAVE_PIN,SAVE_State, FALLING);
                        
                          #ifdef KDEBUG
                          Debug.println("Aktuelle Zähler_Impulse");
                          Debug.print("S0_1 Zaehler(Imp): ");
                          Debug.println("%d",S0_impuls[0]);
                          Debug.print("S0_2 Zaehler(Imp): ");
                          Debug.println("%d",S0_impuls[1]);
                          Debug.print("S0_3 Zaehler(Imp): ");
                          Debug.println("%d",S0_impuls[2]);
                          Debug.print("S0_4 Zaehler(Imp): ");
                          Debug.println("%d",S0_impuls[3]);
                          #endif   
                        
                        //  S0_Zaehler[0] = 100;
                        //  S0_Zaehler[1] = 200;
                        //  S0_Zaehler[2] = 300;
                        //  S0_Zaehler[3] = 400;
                        
                          S0_Zaehler_old[0] = S0_Zaehler[0];
                          S0_Zaehler_old[1] = S0_Zaehler[1];
                          S0_Zaehler_old[2] = S0_Zaehler[2];
                          S0_Zaehler_old[3] = S0_Zaehler[3];
                        
                          //Sendet aktuellen Zählerstand
                          sendZaehlerStand_2(0,S0_Zaehler);
                          sendZaehlerStand_2(1,S0_Zaehler);
                          sendZaehlerStand_2(2,S0_Zaehler);
                          sendZaehlerStand_2(3,S0_Zaehler);
                        
                        
                          //S0 Schnittstelle 
                          if (S0_aktiv[1] == 1)   
                              {attachInterrupt(S0_1_pin,irq_S0_1, FALLING);
                               #ifdef KDEBUG
                               Debug.println("S0_1 aktiv");  
                               #endif 
                               }
                          else {
                                #ifdef KDEBUG 
                                Debug.println("S0_1 inaktiv");  
                                #endif 
                                }
                          if (S0_aktiv[2] == 1)   
                              {attachInterrupt(S0_2_pin,irq_S0_2, FALLING);
                               #ifdef KDEBUG
                               Debug.println("S0_2 aktiv");  
                               #endif
                               }
                          else {
                                #ifdef KDEBUG 
                                Debug.println("S0_2 inaktiv");  
                                #endif 
                                }     
                          if (S0_aktiv[3] == 1)   
                              {attachInterrupt(S0_3_pin,irq_S0_3, FALLING);
                               #ifdef KDEBUG
                               Debug.println("S0_3 aktiv");  
                               #endif
                               }
                           else {
                                 #ifdef KDEBUG 
                                 Debug.println("S0_3 inaktiv");  
                                 #endif 
                                 }    
                           if (S0_aktiv[4] == 1)   
                              {attachInterrupt(S0_4_pin,irq_S0_4, FALLING);
                               #ifdef KDEBUG
                               Debug.println("S0_4 aktiv");  
                               #endif
                               }
                           else {
                                 #ifdef KDEBUG 
                                 Debug.println("S0_4 inaktiv");  
                                 #endif 
                                 }    
                        
                          //Init POrt Abfrage
                          CHState = SetVCC;
                        
                        
                          //INIT I2C Expander
                          #ifdef KDEBUG
                          Debug.println("Expander INIT START");
                          #endif
                        
                          expander.begin(0x20);
                        
                          #ifdef KDEBUG
                          Debug.println("Expander IO finish");
                          #endif
                          expander_VCC.begin(0x23);
                          #ifdef KDEBUG
                          Debug.println("Expander VCC finish");
                          #endif
                          #ifdef ANZEIGE_Platine
                          expander_LED.begin(0x24);    
                          #endif
                          #ifdef KDEBUG
                          Debug.println("Expander INIT FINISH");
                          #endif
                          // Init OUTPUTS LED 
                          #ifdef I2COFF
                          for(int i=0;i<16;i++)
                                {expander.pinMode(i, INPUT_PULLUP);
                                 expander_VCC.pinMode(i, OUTPUT);
                                 expander_VCC.digitalWrite(i,LOW);
                                 #ifdef ANZEIGE_Platine
                                 expander_LED.pinMode(i, OUTPUT);
                                 expander_LED.digitalWrite(i,LOW);
                                 #endif 
                                 } 
                          #endif      
                          // Daten Lesen
                          #ifdef I2COFF
                          PNS = expander.read();
                          #endif
                        
                          for(int i=0;i<16;i++)
                                {
                                 //check Open_HIGH & Open_LOW
                                 if(CH_invert[i]==1) //wenn Open_LOW
                                   {PNS ^= 1 << i;}
                                }   
                           maske = (uint16_t) PNS;
                        
                           // Abfrage Ports
                           for(int i=0;i<16;i++)
                                {
                                 // HW-PIN "open" 
                                 if( (maske & (1 << i)))  
                                  { ch_old[i] = false; }          
                                 //HW-PIN "closed"
                                 else                   
                                   { ch_old[i] = true; } 
                        
                                sendStatus(i,ch_old);  
                                } 
                        
                           // CHECK Zimmer maskierung
                           for(int cha=0;cha<5;cha++){  
                              if((maske & mask_Zimmer[cha]) != 0) 
                                  {state_Zimmer[cha]= true;}
                              else     
                                  {state_Zimmer[cha]= false;} 
                                   #ifdef KDEBUG
                                   Debug.println("%d",state_Zimmer[cha]);  
                                   #endif
                             // if(state_Zimmer[cha] != state_Zimmer_old[cha])
                                  send_Zimmer_Status(cha,state_Zimmer);
                                  state_Zimmer_old[cha]=state_Zimmer[cha];
                              }
                        
                        
                          //****************** Init Timer *******************************************************  
                          setTimer();
                          setTimer_ms(10);
                        
                          #ifdef KDEBUG
                          Debug.println("FINISH Setup");  
                          #endif
                          digitalWrite(LED_YELLOW, LOW);
                        }
                        
                        
                        // #################################################################################
                        // ### Loop()
                        // #################################################################################
                        
                        void loop(){ 
                          //digitalWrite(LED_YELLOW, LOW);
                          Knx.task();
                          if (Konnekting.isReadyForApplication()) {
                            // Sendet bei Zählerstand-Änderung
                            if(sende_Zyklus_Zaehler == 0){
                              if(S0_aktiv[1]== 1) sendZaehlerStand(0,S0_Zaehler,S0_Zaehler_old);
                              if(S0_aktiv[2]== 1) sendZaehlerStand(1,S0_Zaehler,S0_Zaehler_old);
                              if(S0_aktiv[3]== 1) sendZaehlerStand(2,S0_Zaehler,S0_Zaehler_old);
                              if(S0_aktiv[4]== 1) sendZaehlerStand(3,S0_Zaehler,S0_Zaehler_old);
                              }
                            else if(sendZaehler_Cycle==true){
                              sendZaehler_Cycle = false;
                              if(S0_aktiv[1]== 1) sendZaehlerStand(0,S0_Zaehler,!S0_Zaehler);
                              if(S0_aktiv[2]== 1) sendZaehlerStand(1,S0_Zaehler,!S0_Zaehler);
                              if(S0_aktiv[3]== 1) sendZaehlerStand(2,S0_Zaehler,!S0_Zaehler);
                              if(S0_aktiv[4]== 1) sendZaehlerStand(3,S0_Zaehler,!S0_Zaehler);
                              }  
                        
                            // Zyklisches Abfragen
                            if(isDelay==true)
                            {  
                        
                             if(inputCH<16)
                                  {
                                    switch(CHState)
                                    {
                                      case SetVCC:
                                        expander_VCC.digitalWrite(inputCH*2,LOW);
                                        CHState = ReadIO;
                                      break;
                                      case ReadIO:
                                        #ifdef I2COFF
                                        PNS = expander.read();
                                        #endif
                                        CHState = IsInvert;
                                      break;
                                      case IsInvert:
                                        if(CH_invert[inputCH]==1) //wenn Open_LOW
                                           {PNS ^= 1 << inputCH;}
                                        if(CH_invert[inputCH+1]==1) //wenn Open_LOW
                                           {PNS ^= 1 << inputCH+1;}   
                                        CHState = MaskIO;
                                      break;
                                      case MaskIO:
                                         if( (PNS & (1 << inputCH)))  {ch[inputCH] = 0;} 
                                         else                         {ch[inputCH] = 1;} 
                                         if( (PNS & (1 << inputCH+1))){ch[inputCH+1] = 0;} 
                                         else                         {ch[inputCH+1] = 1;} 
                                         CHState = IsChange_CH_ONE;
                                      break;
                                      case IsChange_CH_ONE:
                                       isChange(inputCH,ch,ch_old); 
                                       CHState = IsChange_CH_TWO;
                                        #ifdef KDEBUG
                                        //Debug.println("IsCh");  
                                        #endif
                                      break;
                                      case IsChange_CH_TWO:
                                       isChange(inputCH+1,ch,ch_old); 
                                       CHState = UnsetVCC;
                                      break;
                                      case UnsetVCC:
                                        expander_VCC.digitalWrite(inputCH*2,HIGH);
                                        CHState = MaskRoom;
                                      break;
                                      case MaskRoom:
                                        if(ch[inputCH] == true)    {maske |= (1<<inputCH);}
                                        else                        {maske &= ~(1<<inputCH);}
                                        if(ch[inputCH+1] == true)    {maske |= (1<<inputCH+1);}
                                        else                        {maske &= ~(1<<inputCH+1);}
                                        CHState = Finish;
                                      break;
                                      case Finish:
                                        inputCH=inputCH+2;
                                        if(inputCH==16)
                                          {
                                            inputCH = 17;
                                            isDelay = false;    
                                          }
                                        CHState = SetVCC;   
                                      break;   
                                    }//Ende Switch
                                   }//Ende Abfrage Ports
                        
                                // CHECK Zimmer maskierung
                                for(int cha=0;cha<5;cha++)
                                     {  
                                       maske2 = maske & mask_Zimmer[cha];
                                       if( maske2 !=  mask_Zimmer[cha]) 
                                              {state_Zimmer[cha]= true;}
                                       else     
                                              {state_Zimmer[cha]= false;} 
                                       if(state_Zimmer[cha] != state_Zimmer_old[cha])
                                              {state_Zimmer_old[cha]=state_Zimmer[cha];
                                               send_Zimmer_Status(cha,state_Zimmer);}
                                      }
                        
                              }//ENDE ISDELAY
                        
                        
                            if(set_S0_LED[3] == true)
                              { 
                                set_S0_LED_time[3] = time_count;
                                S0_LED_ON[3] = true;
                                set_S0_LED[3] = false;
                                #ifdef ANZEIGE_Platine
                                expander_LED.digitalWrite(MAX_CH-15,LOW);
                                #endif  
                              }
                            if(S0_LED_ON[3] == true && (time_count > set_S0_LED_time[3]+30))
                              {
                                S0_LED_ON[3] = false;
                                #ifdef ANZEIGE_Platine
                                expander_LED.digitalWrite(MAX_CH-15,HIGH);
                                #endif
                              }
                        
                            if(run_save == true)
                              {
                                run_save = false;
                                #ifdef KDEBUG
                                Debug.println("Set Zaehlerstand");
                                #endif  
                                sendZaehlerStand_2(0,S0_Zaehler);
                                sendZaehlerStand_2(1,S0_Zaehler);
                                sendZaehlerStand_2(2,S0_Zaehler);
                                sendZaehlerStand_2(3,S0_Zaehler);
                                writeSAVE(S0_Zaehler,S0_impuls);
                              }
                          }//ENDE KONNEKTING APPLIKATION RUNING
                        }
                        
                        
                        
                        
                        
                        void TC3_Handler()
                        {
                          static int loop_count = 0;
                          static int loop_count2 = 0;
                          TcCount16* TC = (TcCount16*) TC3; // get timer struct
                          /*if (TC->INTFLAG.bit.OVF == 1) {  // A overflow caused the interrupt
                              TC->INTFLAG.bit.OVF = 1;    // writing a one clears the flag ovf flag
                          }*/
                          if (TC->INTFLAG.bit.MC0 == 1) {  // A compare to cc0 caused the interrupt
                            TC->INTFLAG.bit.MC0 = 1;    // writing a one clears the flag ovf flag
                          }
                        
                         // S0 Schnittstelle LED-Blink-Timer
                         time_count++;
                        
                         // Zyklisches Portabfragen
                         loop_count++;
                         if(loop_count==abfrage_Interval){isDelay = true;loop_count = 0; inputCH = 0; } 
                        
                         // Zyklisches Zählerstände schicken
                         loop_count2++;
                         if(loop_count2==sende_Zyklus){sendZaehler_Cycle = true;}
                         if(loop_count2>=sende_Zyklus){loop_count2 = 0;} 
                        
                        }

                        Kommentar


                          Es ist vollbracht, die HW ist komplett und betriebsbereit :-)

                          Nur die SW braucht noch etwas :-(

                          weitere Infos folgen !!!

                          20170424_223508.jpg

                          Kommentar


                            Auch die OKW Gehäuse sind jetzt auf dem Weg zu mir :-)

                            Kommentar


                              So dann noch weitere Informationen.

                              Den große SW Bug zum Einlesen der Binäreingänge ist behoben. Jetzt muss ich nur noch ein paar Kleinigkeiten anpassen um die restlichen Funktionen darstellen zu können.

                              Aber mal zusammengefasst was dieses schöne Teil so alles kann :-)
                              1. 16CH Binäreingänge für Reed-Kontakte
                              2. 4x S0-Schnittstellen (CH13 – CH16)
                              3. S0-Zählerstände werden in EEPROM gespeichert (Busspannungseinbruch sicher)
                              4. Es können „Zimmer“ definiert werden, sobald eines der Fenster geöffnet wird, wird ein KO gesendet. Es können dazu eine beliebige Anzahl von CH. benutzt werden.
                              5. Alarm-Funktion: sobald sich ein Status eines Einganges ändert, wird ein KO geschickt.


                              KONNEKTING SUITE:

                              Über die Suite kann folgendes parametrisiert werden:
                              1. Abfrage-Intervall der Eingänge: 300ms / 500ms / 1000ms
                              2. Sende-Zyklus Zählerstände: bei Änderung / 1min / 10min / 30min / 60min
                              3. „Zimmer“ Abfrage: ON / OFF
                              4. Jeder CH kann Invertiert werden (ob eine 0 oder 1 bei offenen Fenster geschickt wird)
                              5. S0-Schnittsellen für CH13 bis CH16 individuell aktiviert werden
                              6. Impulsanzahl/KWH für die S0 Schnittstellen eingetragen werden (werden in EEPROM gespeichert)

                              Kommentar


                                Falls jemand an solch einem Device (einfacher Bausatz) hat, dann kann er sich bitte hier oder per PM bei mir melden. Es Hilft mir etwas abzuschätzen ob ich darauf sitzen bleibe oder schauen muss, ob ich eine Massenproduktion aufbauen muss :-)

                                Es wäre das komplette Device mit Gehäuse (siehe oben)

                                Für die ersten 5 Erwerber würde ich mal einen Preis von 99€ (+Versand) ansetzen und euch die Möglichkeit geben, das Device bei nichtgefallen innerhalb von 3 Monaten zurückzugeben. Ihr wärt dann ja etwas die Versuchskaninchen :-)

                                Falls die Nachfrage größer wäre, dann wird der Preis von 99€ nicht bestehen bleiben. Die Materialkosten sind nicht weit von dem angeben Preis weg und der Zeitaufwand zum Umsetzen ist erheblich. Es sind 4 Platinen die aufgebaut und bestückt werden müssen.
                                Ich hoffe das Ihr das versteht, aber die ersten 5 haben ja die Möglichkeit ein Schnäppchen zu machen :-)



                                Wenn Ihr Fragen dazu habt, dann schreibt mich einfach mal an !!!



                                Noch ein kleiner Hinweis:
                                Aus rechtlichen Gründen werde ich euch nicht das fertige Device sondern einen einfachen Bausatz schicken. Alle SMD-Bauteile sind aber gelötet, es müssten noch einfache Bauteile wie die Terminals, MicroMatch-Stecker, Stiftleisten gelötet werden. Dazu reicht aber jeder billig Baumarkt Lötkolben. Ein paar Schrauben und fertig :-)
                                Alle Bauteile die benötigt werden sind im Bausatz.

                                Kommentar

                                Lädt...
                                X