Wiedereinsteiger - ich komme nicht weiter beim Programmieren von KO und Parametern

[Haka]

Hallo liebe Forengemeinde,

nach über zwei Jahren habe ich zwischen den Jahren endlich wieder Muse gefunden, mich mit dem Thema "KONNEKTING" zu befassen - zunächst einmal, ich bin hellauf begeistert, wie wir das Projekt inzwischen gediehen ist.

Leider stehe ich aktuell komplett auf dem Schlauch mit meinem ersten Testprogramm und komme einfach nicht weiter.

Kurzbeschreibung meines Setups und meiner Probleme, Details kommen unten:

• Ich verwende einen MEGA2560, mein Projekt braucht viele viele viele PWMs (soll ein Dimmer für bis zu 4 RGB LED Stripes draus werden)
• Zum Testen habe ich mir auf dem Schreibtisch einen kleinen lokalen KNX-Bus aufgebaut, bestehend aus
  • MDT Busnetzteil
  • Einfacher GIRA Wipptaster
  • Raspberry Pi2 mit KNXD, angebunden über den Weinzierl 330 USB Stick
• Ich musste in der Library (BETA4) eine kleine Anpassung vornehmen: Beim Programmieren hatte ich immer Abbrüche, bis ich herausgefunden habe, dass es der MEGA wohl nicht mag, wenn irgendwo drei oder mehr Ausrufezeichen am Stück stehen - daher habe ich in der Library die Ausrufezeichen in Gruppen reduziert, wenn diese in DEBUG-Ausgaben o.ä. vorhanden waren, oder durch # / * / ... ersetzt, wenn es Kommentare waren.
• Programmier-Taster-Logik und Programmier-LED funktioniert, sehe ich über die Serielle Konsole (und die LED geht an und auch wieder aus)
• Mein Hauptproblem: Ich bekomme über die SUITE offenbar zwar die physikalische Adresse gesetzt, danach bricht die Programmierung mit einem Fehler ab. KOs oder Parameter einzeln zu setzen funktioniert leider auch nicht.

First Things First, hier mein Sketch (eigentlich noch 1:1 das Demo Sketch):

#include <KonnektingDevice.h>

#include "kdevice_DemoSketch.h"

// ################################################
// ### THIS SKETCH RELIES ON THE MEGA2560...
// ################################################

// ################################################
// ### DEBUG CONFIGURATION
// ################################################
#define KDEBUG // comment this line to disable DEBUG mode
#ifdef KDEBUG
#include <DebugUtil.h>
#define DEBUGSERIAL Serial  //As we use the MEGA, we can go to Regular USB Output Directly
#endif


// ################################################
// ### KONNEKTING Configuration
// ################################################
#define KNX_SERIAL Serial1 // MEGA Uses SERIAL1 - Don't forget to wire the ADUM1201

// ################################################
// ### IO Configuration
// ################################################
#define PROG_LED_PIN 22
#define PROG_BUTTON_PIN 2
#define TEST_LED 23


// ################################################
// ### Global variables, sketch related
// ################################################
unsigned long blinkDelay = 2500; // default value
unsigned long lastmillis = millis();
int laststate = false;


// ################################################
// ### SETUP
// ################################################

void setup() {
  pinMode(TEST_LED, OUTPUT);

  #ifdef KDEBUG
    // Start debug serial with 9600 bauds
    DEBUGSERIAL.begin(9600);
    DEBUGSERIAL.println("TP-UART Test");
    DEBUGSERIAL.println("Debug Mode Active");

    // make debug serial port known to debug class
    // Means: KONNEKTING will sue the same serial port for console debugging
     Debug.setPrintStream(&DEBUGSERIAL);
     DEBUGSERIAL.println("KONNEKTING DemoSketch");

#endif

     Debug.println("-------------");
     Debug.println("INITIALIZING KONNEKTING");
    // Initialize KNX enabled Arduino Board
    Konnekting.init(KNX_SERIAL,
            PROG_BUTTON_PIN,
            PROG_LED_PIN,
            MANUFACTURER_ID,
            DEVICE_ID,
            REVISION);

    // If device has been parametrized with KONNEKTING Suite, read params from EEPROM
    // Otherwise continue with global default values from sketch
    if (!Konnekting.isFactorySetting()) {
        Debug.println("KONNEKTING NOT FACTORY SETTING");
         blinkDelay = (int) Konnekting.getUINT16Param(PARAM_blinkDelay); //blink every xxxx ms
         Debug.println("*** END KONNEKTING NOT FACTORY SETTING");

    }

    lastmillis = millis();
    if(blinkDelay<1000 || blinkDelay >65000){
          // Can't somehow read the settings from the EEPROM...
          Debug.println(F("SET BLINK DELAY TO 10000ms"));
          blinkDelay = 10000;
    }

    Debug.println(F("Toggle LED every %d ms."), blinkDelay);
    Debug.println(F("Setup is ready. go to loop..."));
}

// ################################################
// ### LOOP
// ################################################

void loop() {

    // Do KNX related stuff (like sending/receiving KNX telegrams)
    // This is required in every KONNEKTING aplication sketch
    Knx.task();

    unsigned long currentmillis = millis();

    /*
     * only do measurements and other sketch related stuff if not in programming mode
     * means: only when konnekting is ready for appliction
     */
    if (Konnekting.isReadyForApplication()) {

        if (currentmillis - lastmillis >= blinkDelay) {

            Debug.println(F("Actual state: %d"), laststate);
            Knx.write(COMOBJ_trigger, laststate);
            laststate = !laststate;
            lastmillis = currentmillis;

            digitalWrite(TEST_LED, HIGH);
            Debug.println(F("DONE"));

        }

    }

}

// ################################################
// ### KNX EVENT CALLBACK
// ################################################

void knxEvents(byte index) {
              Debug.println("KNX EVENT DETECTED");

    // nothing to do in this sketch
    switch (index) {

        case COMOBJ_ledOnOff: // object index has been updated

            if (Knx.read(COMOBJ_ledOnOff)) {
                digitalWrite(TEST_LED, HIGH);
                Debug.println(F("Toggle LED: on"));
            } else {
                digitalWrite(TEST_LED, LOW);
                Debug.println(F("Toggle LED: off"));
            }
            break;

        default:
            break;
    }
};

Die kdevice_DemoSketch.h und das zugehörige XML habe ich nicht verändert.


Wenn ich das Sketch neu auf den MEGA aufgespielt habe, sehe ich beim Hochfahren im Seriellen Monitor zunächst folgenden Output:

TP-UART Test
Debug Mode Active
DEBUG! free ram: -1
KONNEKTING DemoSketch
-------------
INITIALIZING KONNEKTING
Initialize KonnektingDevice
15/7/255 = 0x7fff
Manufacturer: 0xdead Device: 0xff Revision: 0x00
numberOfCommObjects: 2
memRead: index=0x00
memRead: data=0x7f
_deviceFlags: 01111111
->EEPROM
memRead: index=0x01
memRead: data=0xb1
memRead: index=0x02
memRead: data=0x01
memRead: index=0x0a
memRead: data=0xff
memRead: index=0x0b
memRead: data=0xff
memRead: index=0x0c
memRead: data=0xff
ComObj index=0 HI=0xff LO=0xff GA=0xffff setting=0xff active=1
memRead: index=0x0d
memRead: data=0xff
memRead: index=0x0e
memRead: data=0xff
memRead: index=0x0f
memRead: data=0xff
ComObj index=1 HI=0xff LO=0xff GA=0xffff setting=0xff active=1
IA: 0xb101
Reset triggered!
Reset attempts: 9
Data available: 1
data not useable: 0x00. Expected: 0x03
Data available: 1
Reset successful
Init : Normal mode started

Init successful
KnxDevice startup status: 0x00
KONNEKTING NOT FACTORY SETTING
getParamValue: index=0 _paramTableStartindex=16 skipbytes=0 paremLen=2
memRead: index=0x10
memRead: data=0xff
 val[0]@16 -> 0xff
memRead: index=0x11
memRead: data=0xff
 val[1]@17 -> 0xff
*** END KONNEKTING NOT FACTORY SETTING
SET BLINK DELAY TO 10000ms
Toggle LED every 10000 ms.
Setup is ready. go to loop...

Nun zum Programmieren per SUITE

• Ich verwende 1:1 die Produktdefinition aus der Demo, an den KOs und Parametern habe ich auch nichts verändert
• die KNX-Konfiguration ist auf die IP-Adresse des KNXD gesetzt, im Bus-Monitor sehe ich auch die Telegramme, wenn ich den Gira Taster drücke
• Physikalische Adresse: 11.11.11
• KO 0: 10/1/0
• KO 1: 10/1/1
• Parameter Blink Delay: 4444

Programmieren per ROTEM Knopf:

• Roten Knopf drücken in der Suite - Popup erscheint mit Aufforderung
• Programmierknopf am Arduino drücken - Programmier-LED geht an
• Nach einiger Zeit - normalerweise ein paar Sekunden bricht die Programmierung mit einem Fehler in der SUITE ab.
• Die Programmier-LED vom Arduino bleibt gelb.

Ausgabe Busmonitor:

LPDU: BC 11 83 7F FF EF 00 80 00 01 BB 0B 00 00 00 00 00 00 00 00 00 00 8F :L_Data low from 1.1.131 to 15/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 00 01 BB 0B 00 00 00 00 00 00 00 00 00 00

LPDU: BC B1 01 FF FF E1 00 80 92 :L_Data low from 11.1.1 to 31/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 00

LPDU: BC 11 83 7F FF EF 00 80 00 15 00 00 00 00 00 00 00 00 00 00 00 00 2B :L_Data low from 1.1.131 to 15/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 00 15 00 00 00 00 00 00 00 00 00 00 00 00

LPDU: BC 11 83 7F FF EF 00 80 00 15 00 00 00 00 00 00 00 00 00 00 00 00 2B :L_Data low from 1.1.131 to 15/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 00 15 00 00 00 00 00 00 00 00 00 00 00 00

LPDU: BC B1 01 7F FF EF 00 80 00 16 B1 01 00 00 00 00 00 00 00 00 00 00 BA :L_Data low from 11.1.1 to 15/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 00 16 B1 01 00 00 00 00 00 00 00 00 00 00

LPDU: BC 11 83 7F FF EF 00 80 00 14 BB 0B 00 00 00 00 00 00 00 00 00 00 9A :L_Data low from 1.1.131 to 15/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 00 14 BB 0B 00 00 00 00 00 00 00 00 00 00

LPDU: BC B1 01 7F FF EF 00 80 00 16 B1 01 00 00 00 00 00 00 00 00 00 00 BA :L_Data low from 11.1.1 to 15/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write 00 16 B1 01 00 00 00 00 00 00 00 00 00 00

Ausgabe Serielles Log vom Arduino:

konnektingKnxEvents index=255
internalComObject index=255
buffer[0]    hex=0x00 bin=00000000
buffer[1]    hex=0x01 bin=00000001
buffer[2]    hex=0xbb bin=10111011
buffer[3]    hex=0x0b bin=00001011
buffer[4]    hex=0x00 bin=00000000
buffer[5]    hex=0x00 bin=00000000
buffer[6]    hex=0x00 bin=00000000
buffer[7]    hex=0x00 bin=00000000
buffer[8]    hex=0x00 bin=00000000
buffer[9]    hex=0x00 bin=00000000
buffer[10]    hex=0x00 bin=00000000
buffer[11]    hex=0x00 bin=00000000
buffer[12]    hex=0x00 bin=00000000
buffer[13]    hex=0x00 bin=00000000
protocolversion=0x00
msgType=0x01
handleMsgReadDeviceInfo
no matcPing IA


konnektingKnxEvents index=255
internalComObject index=255
buffer[0]    hex=0x00 bin=00000000
buffer[1]    hex=0x01 bin=00000001
buffer[2]    hex=0xbb bin=10111011
buffer[3]    hex=0x0b bin=00001011
buffer[4]    hex=0x00 bin=00000000
buffer[5]    hex=0x00 bin=00000000
buffer[6]    hex=0x00 bin=00000000
buffer[7]    hex=0x00 bin=00000000
buffer[8]    hex=0x00 bin=00000000
buffer[9]    hex=0x00 bin=00000000
buffer[10]    hex=0x00 bin=00000000
buffer[11]    hex=0x00 bin=00000000
buffer[12]    hex=0x00 bin=00000000
buffer[13]    hex=0x00 bin=00000000
protocolversion=0x00
msgType=0x01
handleMsgReadDeviceInfo
no matching IA


konnektingKnxEvents index=255
internalComObject index=255
buffer[0]    hex=0x00 bin=00000000
buffer[1]    hex=0x15 bin=00010101
buffer[2]    hex=0x00 bin=00000000
buffer[3]    hex=0x00 bin=00000000
buffer[4]    hex=0x00 bin=00000000
buffer[5]    hex=0x00 bin=00000000
buffer[6]    hex=0x00 bin=00000000
buffer[7]    hex=0x00 bin=00000000
buffer[8]    hex=0x00 bin=00000000
buffer[9]    hex=0x00 bin=00000000
buffer[10]    hex=0x00 bin=00000000
buffer[11]    hex=0x00 bin=00000000
buffer[12]    hex=0x00 bin=00000000
buffer[13]    hex=0x00 bin=00000000
protocolversion=0x00
msgType=0x15
handleMsgReadIndividualAddress
KNX_WRITE_REQUEST index=255


konnektingKnxEvents index=255
internalComObject index=255
buffer[0]    hex=0x00 bin=00000000
buffer[1]    hex=0x15 bin=00010101
buffer[2]    hex=0x00 bin=00000000
buffer[3]    hex=0x00 bin=00000000
buffer[4]    hex=0x00 bin=00000000
buffer[5]    hex=0x00 bin=00000000
buffer[6]    hex=0x00 bin=00000000
buffer[7]    hex=0x00 bin=00000000
buffer[8]    hex=0x00 bin=00000000
buffer[9]    hex=0x00 bin=00000000
buffer[10]    hex=0x00 bin=00000000
buffer[11]    hex=0x00 bin=00000000
buffer[12]    hex=0x00 bin=00000000
buffer[13]    hex=0x00 bin=00000000
protocolversion=0x00
msgType=0x15
handleMsgReadIndividualAddress
KNX_WRITE_REQUEST index=255


konnektingKnxEvents index=255
internalComObject index=255
buffer[0]    hex=0x00 bin=00000000
buffer[1]    hex=0x14 bin=00010100
buffer[2]    hex=0xbb bin=10111011
buffer[3]    hex=0x0b bin=00001011
buffer[4]    hex=0x00 bin=00000000
buffer[5]    hex=0x00 bin=00000000
buffer[6]    hex=0x00 bin=00000000
buffer[7]    hex=0x00 bin=00000000
buffer[8]    hex=0x00 bin=00000000
buffer[9]    hex=0x00 bin=00000000
buffer[10]    hex=0x00 bin=00000000
buffer[11]    hex=0x00 bin=00000000
buffer[12]    hex=0x00 bin=00000000
buffer[13]    hex=0x00 bin=00000000
protocolversion=0x00
msgType=0x14
handleMsgWriteIndividualAddress
memUpdate: index=0x01 data=0xbb
memUpdate: index=0x02 data=0x0b
DeviceFlags after =0x7f
memUpdate: index=0x00 data=0x7f
sendAck errorcode=0x00 indexInformation=0x00
KNX_WRITE_REQUEST index=255

Fehlermeldung in der SUITE direkt kann ich leider nicht rauskopieren, unten als Screenshot angehängt.

Fehlermeldung in der Shell, aus der die SUITE gestartet wurde:

hakmac:Suite hanskeller$ 2018-01-07 15:02:48.005 INFO [AWT-EventQueue-0] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.getInstance: ###### RUNNING DEBUG MODE #######

2018-01-07 15:02:48.026 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.suite.BackgroundTask$1.run: Begin task(3) '[Programmiere]'

2018-01-07 15:02:48.028 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.deviceconfig.Program.program: About to write physical address '11.11.11'. Please press 'program' button on target device NOW ...

2018-01-07 15:02:48.030 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending: MsgReadDeviceInfo{individualAddress=11.11.11}

2018-01-07 15:02:48.031 FINEST [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending message

ProtocolVersion: 00

MsgTypeId      : 01

data[2..13]    : bb 0b 00 00 00 00 00 00 00 00 00 00

2018-01-07 15:02:48.081 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.expectSingleMessage: Waiting for single message [de.konnekting.mgnt.protocol0x00.MsgAnswerDeviceInfo]

2018-01-07 15:02:48.081 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.waitForMessage: Waiting for message. timeout=5000 returnOnFirst=true

2018-01-07 15:02:50.946 INFO [Timer-0] de.konnekting.suite.StatusPanel$1.run: Clear status message

2018-01-07 15:02:53.106 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending: MsgReadIndividualAddress{}

2018-01-07 15:02:53.107 FINEST [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending message

ProtocolVersion: 00

MsgTypeId      : 15

data[2..13]    : 00 00 00 00 00 00 00 00 00 00 00 00

2018-01-07 15:02:53.200 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.waitForMessage: Waiting for message. timeout=5000 returnOnFirst=false

2018-01-07 15:02:58.221 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.writeIndividualAddress: responsed: 0

2018-01-07 15:02:58.221 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.writeIndividualAddress: No device responded.

2018-01-07 15:02:58.221 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.writeIndividualAddress: KONNEKTINGs in programming mode: 0

2018-01-07 15:02:58.222 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending: MsgReadIndividualAddress{}

2018-01-07 15:02:58.222 FINEST [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending message

ProtocolVersion: 00

MsgTypeId      : 15

data[2..13]    : 00 00 00 00 00 00 00 00 00 00 00 00

2018-01-07 15:02:58.321 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.waitForMessage: Waiting for message. timeout=5000 returnOnFirst=false

2018-01-07 15:02:59.177 INFO [Calimero link notifier] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00$1.write: Received message: AnswerIndividualAddress{individualAddress=11.1.1}

2018-01-07 15:03:03.698 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.writeIndividualAddress: responsed: 1

2018-01-07 15:03:03.699 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.writeIndividualAddress: KONNEKTINGs in programming mode: 1

2018-01-07 15:03:03.699 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.writeIndividualAddress: Writing address ...

2018-01-07 15:03:03.699 INFO [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending: MsgWriteIndividualAddress{individualAddress=11.11.11}

2018-01-07 15:03:03.700 FINEST [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.sendMessage: Sending message

ProtocolVersion: 00

MsgTypeId      : 14

data[2..13]    : bb 0b 00 00 00 00 00 00 00 00 00 00

2018-01-07 15:03:03.748 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.expectSingleMessage: Waiting for single message [de.konnekting.mgnt.protocol0x00.MsgAck]

2018-01-07 15:03:03.749 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.waitForMessage: Waiting for message. timeout=5000 returnOnFirst=true

2018-01-07 15:03:05.527 INFO [Calimero link notifier] de.konnekting.mgnt.protocol0x00.ProgProtocol0x00$1.write: Received message: AnswerIndividualAddress{individualAddress=11.1.1}

2018-01-07 15:03:05.527 SEVERE [BackgroundTask(3) '[Programmiere]'] de.konnekting.deviceconfig.Program.program: Problem writing individual address

de.root1.slicknx.KnxException: Wrong message type received. Expected:class de.konnekting.mgnt.protocol0x00.MsgAck. Got: AnswerIndividualAddress{individualAddress=11.1.1}

at de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.expectSingleMessage(ProgProtocol0x00.java:206)

at de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.expectSingleMessage(ProgProtocol0x00.java:226)

at de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.expectAck(ProgProtocol0x00.java:238)

at de.konnekting.mgnt.protocol0x00.ProgProtocol0x00.writeIndividualAddress(ProgProtocol0x00.java:388)

at de.konnekting.mgnt.KonnektingManagement.writeIndividualAddress(KonnektingManagement.java:70)

at de.konnekting.deviceconfig.Program.program(Program.java:118)

at de.konnekting.suite.ProgramDialog$4.run(ProgramDialog.java:192)

at java.lang.Thread.run(Thread.java:745)

at de.konnekting.suite.BackgroundTask$1.run(BackgroundTask.java:59)




2018-01-07 15:03:05.547 FINE [BackgroundTask(3) '[Programmiere]'] de.konnekting.suite.BackgroundTask$1.run: Finished task(3) '[Programmiere]' in 17522 ms.

Wenn ich jetzt den Programmierknopf wieder drücke (LED AUS), dann erscheint im Seriellen Monitor noch die info "PrgBtn toggl", danach scheint sich der MEGA aufzuhängen (die 13er LED auf der Platine blinkt wie verrückt).


Wenn ich den Arduino dann aber neu starte (also komplett Strom weg - nur RESET hilft nichts), dann sehe ich auf einem im Busmonitor folgendes:

LPDU: BC BB 0B FF FF E1 00 80 92 :L_Data low from 11.11.11 to 31/7/255 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 00

Und zwar alle 10 Sekunden.

Es scheint mir also, als sei zumindest die physikalische Adresse richtig gesetzt worden, sobald es an die KOs und Parameter geht, verabschiedet es sich.

Weiss irgendjemand von euch einen Rat? Ich komme einfach nicht mehr weiter.

Danke euch

Hans


KONNEKTING_Suite1.png

[Haka]

*ARGLBRMMMLLL*

Jetzt wird's peinlich - vermutlich.

Erkenntnis 1 und 2 - kleine Anpassungen für den MEGA in der Library gemacht, haben wunder gewirkt:

• Kleine Ergänzung für den MEGA in der Debug.cpp, und jetzt wird auch korrekt das Memory angezeigt
• Kleine Ergänzung für den MEGA in der KonnektingDevice.cpp und er hängt sich beim Reboot nicht in dieser WDT-Schleife auf sondern macht einen sauberen Reboot.

>> Frage, sollen solche Ergänzungen Teil der offiziellen LIB werden? Wenn ja, wie? Mit git push / commits bin ich nicht mehr so ganz firm...

Erkenntnis 3: Wenn Deine Serial1 zum KNX-Bus/Siemens BCM mit > 9600 Baud sendet, deine Serial(0) zum Seriellen Monitor aber mit 9600, dann gibt diese den Takt vor.

Heisst: Jede KNX-Antwort während des Programmierens kam "dank" Monitor deutlich zu spät.

Habe die Baudrate jetzt auf 115200 gesetzt für den Monitor, und jetzt kann ich tatsächlich die KOs sehen im Busmonitor.

LPDU: BC BB 0C 51 01 E1 00 80 C5 :L_Data low from 11.11.12 to 10/1/1 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 00 
LPDU: BC BB 0C 51 01 E1 00 81 C4 :L_Data low from 11.11.12 to 10/1/1 hops: 06 T_DATA_XXX_REQ A_GroupValue_Write (small) 01

Vielleicht eine Ergänzung für das DEMO Sketch?


BG
Hans

[Sonnengruesser]

Hallo,

Frage, sollen solche Ergänzungen Teil der offiziellen LIB werden?

Die Frage hab ich mir auch schon gestellt.
Du wirst immer das Problem haben, dass nicht alle Arduinos 100%ig unterstützt werden. Es gibt z.B. auch Unterschiede zwischen dem Arduino ProMicro und dem Sparkfun ProMicro.
Ich bin dafür, die "Standard-Konnekting HW" (also DevBoard, MicroBCU, MI) entsprechend zu unterstützen bzw. auch die LIBs dafür anzupassen. Für Verwendung auf anderen Prozessoren ist jeder Bastler selbst verantwortlich.
Sollte es ernsthafte Entwicklungswünsche mit anderen Prozessoren geben, dann macht das sicher Sinn das aufzunehmen.
Ansonsten: Varianten reduzieren, sonst wird das unübersichtlich.
VG
Christoph

[Eugenius]

Hallo zusammen,

ihr könnt auf jedem Fall eure Änderungen/Ergäzungen als PullRequest oder zumindest hier posten. Dann wissen wir, wo wir die Fehler suchen können. Evtl. fließen die Änderungen auch in die Lib mit ein.

Offiziell unterstützen wir MEGA2560 nicht. Einen bestimmten Grund gibt es nicht: Man muss auf jedem Fall beachten, dass MEGA2560 mehr Strom zieht, als BCU liefern kann.
Für sehr viele PWM Pins empfehlen wir PCA9685 Baustein. Da hat man 16 PWM 12bit Kanäle. Das kann MEGA nicht

Gruß
Eugen

[tuxedo]

Ich sehe das ähnlich wie Sonnengruesser. Wir können uns eigtl nur auf die Haupt-Controller konzentrieren. Und das wird aktuell immer mehr der SAMD21.
Was wir aber noch tun können, um es für andere Controller einfacher zu machen:
Wir können die Präprozessor-Angaben (#define) allgemeiner halten und dann mit zusätzlichen Angaben auf die jeweiligen Controller festlegen.

Am beispiel reboot() kann man sich das so vorstellen, dass es sowas gibt:

#ifdefine WDT_REBOOT

.... // reboot via WDT

#else
... // reboot via ASM
#endif

Und dann global weit oben ein

#ifdef __SAMD21G18A__
#define WDT_REBOOT
#endif

Dann wäre das für unseren Contoller so geregelt, und wer was anderes mit einem bisher nicht unterstützten Controller braucht, muss halt das passende #define selbst setzen um den einen oder halt anderen Weg einzuschlagen.

Kurzum: Wenn wir solche Stellen finden, sollten wir sie allgemein behandeln und mit weiteren Flags je Controller entsprechend setzen.



Bzgl. der Baudrate:

Logging macht immer mit 115k2 sinn, weil es einfach schneller ist und weniger den Controller aufhält. Aber auch mit 115k2 kann man mit vielen Logausgaben das Timing negativ beeinflussen. Mein Rat: packt je Abschnitt ein #ifdefine um die Logausgabe drum herum, dann kann man unterschiedliche Abschnitt getrennt voneinander im Logging ein/ausschalten und so die Log-Last reduzieren (reduziert dann auch gleich die Code-Größe...)

Ganz allgemein:
Ich kann nur raten, bei so vielen PWMs auf einen separaten PWM IC zu setzen statt alles dem Controller aufzubürden. Da hast du dann auch weniger Probleme die vielen PWM Kanäle mit der gleichen PWM Frequenz etc zu fahren und hast dann auch auf allen Kanälen die gleiche Bit-Breite. Mit 8 Bit willst du nicht wirklich dimmen. Beispiel:
https://www.ebay.de/itm/PCA9685-16-K...8AAOSwJtdaHuTS
Und wenn du nochmal PWM Kanäle brauchst: Einfach nochmal so ein Modul/IC dazu packen. fertig. Dann hast du 32 Kanäle. Das skaliert recht gut, im Vergleich zu "sehr viele PWM direkt aus dem µC heraus".

[Sonnengruesser]

Haka Noch ein Punkt zu den PWMs: Wenn du einen RGB-Dimmer baust, wirst du sicher die LED-Spannung vom KNX galvanisch trennen wollen (KNX ist SELV). Das geht relativ einfach mit nem PWM IC und nem I²C transponder (ADUM1250). So hab ich das für meine Lüftersteuerung gelöst.
VG
Christoph

[tuxedo]

Korrekt Sonnengruesser . Das ist sogar einer der Haupt-Punkte FÜR das absetzen der PWM generierung über I2C. Da muss man nur zwei Leitungen mit einem ADUM isolieren.

Man kann natürlich auch die BCU per ADUM vom Arduino Controller entkoppeln. Ginge auch. Ich halte es aber so, dass ich alles "externe" auch "extern" behandle. Und für mich ist die DC-Spannung für die LED Ansteuerung, zusammen mit PWM-IC "extern". Also eher I2C per ADUM entkoppeln.