Arduino Asksin library

MarcelK · 24 September 2014, 22:59:01

Zitat von: trilu am 23 September 2014, 19:00:20
hättest du nicht lust mit an der asksin zu arbeiten?
so ein codereview und optimierung könnten nicht schaden?

schalte dich auch gerne für den github frei

Ich hab gedacht ich steig ein wenn der ganze Spaß fertig ist

Nein, irgendwann wollte ich mal anfangen eigene Devices mit der Library zu bauen, insofern schau ich gerne mal drüber wenn ich die Zeit finde. Mein GitHub User ist "MarcelKilgus".

Viele Grüße, Marcel

thunder1902 · 29 September 2014, 13:31:31

Hallo!
Sorry, wenn ich kurz "unterbreche" - aber ich möchte mir ein Device zusammenbasteln, das mind. 3 Steckdosen schalten kann.

Dazu möchte ich ein Arduino Mini Pro mit 8MhZ und 3,3 Volt verwenden, ein CC1101, und mind. 3 Fets, mit denen ich dann Relais (oder etwas anderes) schalten kann. Dazu möchte ich den CMOS Baustein CD4007 verwenden, der 3 N und 3 P - Fets beinhaltet.

Soweit zu meinem Vorhaben -
Es gibt ja in dem Ordner "Examples" mehrere "Programme" für unterschiedliche Devices:

HM6TastenSwitch = Ein Sensor-Device, das 6 Buttons (Taster) hat und NUR die Schaltbefehle an Aktoren senden kann (?)

HM_LC_SW1_BA_PCB    = Ein Sensor/Aktor-Device mit 1 Button (Taster) und einem Schaltausgang (?)
HM_LC_Sw1_Pl    = Ein Aktor Device mit einem Schaltausgang (?)
HM_WDS10_TH_O   = Wetter-Sensor, ähnlich wie Dirk's Wettersensor (?)
LedLampeRelay = das gleiche wie HM_LC_Sw1_Pl (?)

Ist das so richtig? Könnte man z.B. den Beispiel-Code HM_LC_SW1_BA_PCB   auf 3 Sensor/Aktor Ein-und Ausgänge erweitern, indem ich den Code:
   button[0].regInHM(0,&hm);                                             // register buttons in HM per channel, handover HM class pointer
   button[0].config(8, NULL);                                             // configure button on specific pin and handover a function pointer to the main sketch

   relay[0].regInHM(1,&hm);

einfach erweitere???

Danke schonmal für eure Antwort!

Schrottpresse · 01 Oktober 2014, 07:48:35

Hallo

Hat schon jemand versucht, einen Moteino mit der Arduino Asksin Library in ein FHEM System direkt einzubinden? Hat ja auch einen 868 MHz Transceiver eingebaut.
Kosten ca. 12 euro, PIR Sensoren ein paar cent - dann würde man sich nämlich einiges zb. bei den Bewegungssensoren sparen, wenn man sein system plant.

Kleine Halb-Off-Topic Frage: Als Sender/Empfänger verwendet man am einfachsten den EQ3 85128, oder?

LG Martin

trilu · 01 Oktober 2014, 15:36:36

@Schrottpresse - Das mit dem Moteino wird ziemlich aufwendig. Der nutzt ein RF12 Modul, HM nutzt einen CC1101 transceiver.
Ist kein Problem der Frequenz, eher ein Problem der Richtigen Preambel und der automatischen Checksum.

@Thunder 1902
3 Steckdosen schalten, heisst du brauchst 3 mal einen Channel. Folglich musst du zuerst die Register.h anpassen. Das ganze wird per destillregs.pm generiert. Nachfolgend eine Beispielconfig die du durch die destillregs jagen kannst.

Code Auswählen


use strict;
#Beispiel 
# ========================switch =====================================
# battery powered 6 channel switch
#   "006C" => {name=>"HM-LC-SW1-BA-PCB"        ,st=>'switch'            ,cyc=>''      ,rxt=>'b'      ,lst=>'3'            ,chn=>"",},
# 1 device
# 1 kanal
# 6 peers je kanal erlaubt
#----------------define reglist types-----------------
package usrRegs;
my %listTypes = (
      regDev =>{ intKeyVisib=>1, ledMode=>1, lowBatLimitBA=>1, pairCentral=>1,
              },
      regChan       =>{ sign          =>1,    #|     literal        |          | signature (AES) options:on,off
                        lgActionType  =>1,    #|     literal        | required |  options:toggleToCntInv,off,toggleToCnt,jmpToTarget
                        lgCtDlyOff    =>1,    #|     literal        | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
                        lgCtDlyOn     =>1,    #|     literal        | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
												lgCtOff       =>1,    #|     literal        | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
                        lgCtOn        =>1,    #|     literal        | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
												lgCtValHi     =>1,    #|   0 to 255         | required | Condition value high for CT table
                        lgCtValLo     =>1,    #|   0 to 255         | required | Condition value low for CT table
												lgMultiExec   =>1,    #|     literal        | required | multiple execution per repeat of long trigger options:on,off
												lgOffDly      =>1,    #|   0 to 111600s     | required | off delay
												lgOffTime     =>1,    #|   0 to 111600s     | required | off time, 111600 = infinite
												lgOffTimeMode =>1,    #|     literal        | required | off time mode options:minimal,absolut
												lgOnDly       =>1,    #|   0 to 111600s     | required | on delay
												lgOnTime      =>1,    #|   0 to 111600s     | required | on time, 111600 = infinite
												lgOnTimeMode  =>1,    #|     literal        | required | on time mode options:minimal,absolut
												lgSwJtDlyOff  =>1,    #|     literal        | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
												lgSwJtDlyOn   =>1,    #|     literal        | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
												lgSwJtOff     =>1,    #|     literal        | required | Jump from off options:on,off,dlyOn,no,dlyOff
												lgSwJtOn      =>1,    #|     literal        | required | Jump from on options:on,off,dlyOn,no,dlyOff
												shActionType  =>1,    #|     literal        | required |  options:toggleToCntInv,off,toggleToCnt,jmpToTarget
												shCtDlyOff    =>1,    #|     literal        | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
												shCtDlyOn     =>1,    #|     literal        | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
												shCtOff       =>1,    #|     literal        | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
												shCtOn        =>1,    #|     literal        | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
												shCtValHi     =>1,    #|   0 to 255         | required | Condition value high for CT table
												shCtValLo     =>1,    #|   0 to 255         | required | Condition value low for CT table
												shOffDly      =>1,    #|   0 to 111600s     | required | off delay
												shOffTime     =>1,    #|   0 to 111600s     | required | off time, 111600 = infinite
												shOffTimeMode =>1,    #|     literal        | required | off time mode options:minimal,absolut
												shOnDly       =>1,    #|   0 to 111600s     | required | on delay
												shOnTime      =>1,    #|   0 to 111600s     | required | on time, 111600 = infinite
												shOnTimeMode  =>1,    #|     literal        | required | on time mode options:minimal,absolut
												shSwJtDlyOff  =>1,    #|     literal        | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
												shSwJtDlyOn   =>1,    #|     literal        | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
												shSwJtOff     =>1,    #|     literal        | required | Jump from off options:on,off,dlyOn,no,dlyOff
												shSwJtOn      =>1,    #|     
		          },
     );
#      -----------assemble device -----------------
my %regList;
$regList{0}={type => "regDev",peers=>1};
$regList{1}={type => "regChan",peers=>6};
$regList{2}={type => "regChan",peers=>6};
$regList{3}={type => "regChan",peers=>6};

sub usr_getHash($){
  my $hn = shift;
  return %regList       if($hn eq "regList"      );
  return %listTypes     if($hn eq "listTypes"       );
}

Mit dem was dabei rauskommt, weiss die AskSin das es ein Gerät mit drei Schaltkanälen ist.
Jetzt musst du noch den Kanälen das Relay zuordnen...
Von der Relay Class 3 unterschiedliche Instanzen erstellen und diese in der Asksin entsprechen dem Kanal einhängen.

Code Auswählen


 relay[0].regInHM(1,&hm);
 relay[1].regInHM(2,&hm);
 relay[2].regInHM(3,&hm);

thunder1902 · 01 Oktober 2014, 15:50:56

Hab mal über die destillregs gegoogelt und bin auf Deinen Beitrag hier gestossen, den ich hier anhänge...

ZitatIch finde es total cool das du dich an die AskSin lib traust! Mir fehlt im Moment leider ein wenig die Zeit um hier aktiv weiter zu machen.
Wird aber bestimmt wieder, dauert nur noch etwas...

Ich versuche mal ein wenig Licht ins Dunkel zur destillRegs zu bringen.
Mit der destillRegs soll es möglich sein sich automatisch den Inhalt der Register.h generieren zu lassen. Am einfachsten ist es hier, auf ein bestehendes Device aufzubauen. Ich mach das mal am Beispiel eines HM_LC_SW1_BA_PCB.
Zuerst schauen wir uns die Register in FHEM an - das geht mit einem get <euer Device> regList

--- Code: ---list: register | range | peer | description
0: confBtnTime | 1 to 255min | | 255=permanent
0: intKeyVisib | literal | | visibility of internal channel options:visib,invisib
0: ledMode | literal | | LED mode options:on,off
0: localResDis | literal | | local reset disable options:on,off
0: lowBatLimitBA | 5 to 15V | | low batterie limit, step .1V
0: pairCentral | 0 to 16777215 | | pairing to central
1: powerUpAction | literal | | behavior on power up options:on,off
1: sign | literal | | signature (AES) options:on,off
1: statusInfoMinDly | 0.5 to 15.5s | | status message min delay
1: statusInfoRandom | 0 to 7s | | status message random delay
1: transmitTryMax | 1 to 10 | | max message re-transmit
3: lgActionType | literal | required | options:toggleToCntInv,off,toggleToCnt,jmpToTarget
3: lgCtDlyOff | literal | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
3: lgCtDlyOn | literal | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
3: lgCtOff | literal | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
3: lgCtOn | literal | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
3: lgCtValHi | 0 to 255 | required | Condition value high for CT table
3: lgCtValLo | 0 to 255 | required | Condition value low for CT table
3: lgMultiExec | literal | required | multiple execution per repeat of long trigger options:on,off
3: lgOffDly | 0 to 111600s | required | off delay
3: lgOffTime | 0 to 111600s | required | off time, 111600 = infinite
3: lgOffTimeMode | literal | required | off time mode options:minimal,absolut
3: lgOnDly | 0 to 111600s | required | on delay
3: lgOnTime | 0 to 111600s | required | on time, 111600 = infinite
3: lgOnTimeMode | literal | required | on time mode options:minimal,absolut
3: lgSwJtDlyOff | literal | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
3: lgSwJtDlyOn | literal | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
3: lgSwJtOff | literal | required | Jump from off options:on,off,dlyOn,no,dlyOff
3: lgSwJtOn | literal | required | Jump from on options:on,off,dlyOn,no,dlyOff
3: shActionType | literal | required | options:toggleToCntInv,off,toggleToCnt,jmpToTarget
3: shCtDlyOff | literal | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
3: shCtDlyOn | literal | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
3: shCtOff | literal | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
3: shCtOn | literal | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
3: shCtValHi | 0 to 255 | required | Condition value high for CT table
3: shCtValLo | 0 to 255 | required | Condition value low for CT table
3: shOffDly | 0 to 111600s | required | off delay
3: shOffTime | 0 to 111600s | required | off time, 111600 = infinite
3: shOffTimeMode | literal | required | off time mode options:minimal,absolut
3: shOnDly | 0 to 111600s | required | on delay
3: shOnTime | 0 to 111600s | required | on time, 111600 = infinite
3: shOnTimeMode | literal | required | on time mode options:minimal,absolut
3: shSwJtDlyOff | literal | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
3: shSwJtDlyOn | literal | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
3: shSwJtOff | literal | required | Jump from off options:on,off,dlyOn,no,dlyOff
3: shSwJtOn | literal | required | Jump from on options:on,off,dlyOn,no,dlyOff

--- Ende Code ---

Was man jetzt sieht sind die möglichen Register des Devices. Wenn man jetzt erweitern oder verändern möchte,
kann man sich die möglichen Register in der HMConfig.pm ansehen. Wirklich eigene Register würde ich im Moment noch nicht
definieren, da die Einbindung in FHEM gerade im Wettersensor Thread geklärt wird.

In der HMConfig.pm gibts ab Zeile ~250 so was hier

--- Code: ---my %culHmRegDefShLg = (# register that are available for short AND long button press. Will be merged to rgister list at init
#blindActuator mainly
ActionType =>{a=> 10.0,s=>0.2,l=>3,min=>0 ,max=>3 ,c=>'lit' ,f=>'' ,u=>'' ,d=>1,t=>"" ,lit=>{off=>0,jmpToTarget=>1,toggleToCnt=>2,toggleToCntInv=>3}},
OffTimeMode =>{a=> 10.6,s=>0.1,l=>3,min=>0 ,max=>1 ,c=>'lit' ,f=>'' ,u=>'' ,d=>0,t=>"off time mode",lit=>{absolut=>0,minimal=>1}},
OnTimeMode =>{a=> 10.7,s=>0.1,l=>3,min=>0 ,max=>1 ,c=>'lit' ,f=>'' ,u=>'' ,d=>0,t=>"on time mode" ,lit=>{absolut=>0,minimal=>1}},
MaxTimeF =>{a=> 29.0,s=>1.0,l=>3,min=>0 ,max=>25.4 ,c=>'' ,f=>10 ,u=>'s' ,d=>0,t=>"max time first direction"},
DriveMode =>{a=> 31.0,s=>1.0,l=>3,min=>0 ,max=>3 ,c=>'lit' ,f=>'' ,u=>'' ,d=>0,t=>"" ,lit=>{direct=>0,viaUpperEnd=>1,viaLowerEnd=>2,viaNextEnd=>3}},
#dimmer mainly
OnDly =>{a=> 6.0,s=>1.0,l=>3,min=>0 ,max=>111600 ,c=>'fltCvT' ,f=>'' ,u=>'s' ,d=>0,t=>"on delay"},
OnTime =>{a=> 7.0,s=>1.0,l=>3,min=>0 ,max=>111600 ,c=>'fltCvT' ,f=>'' ,u=>'s' ,d=>0,t=>"on time, 111600 = infinite"},

--- Ende Code ---

Das ist die Auflistung der bekannten Registervariablen die über die verschiedenen HM Geräte genutzt werden.

So, aber zurück zur destillRegs und wie es geht - die destillRegs "kompiliert" aus dem Inhalt des Files devDefinition.pm die Inhalte für Register.h
Also müssen jetzt die Inhalte der devDefinition.pm angepasst werden. Der Inhalt sieht dann so aus:

--- Code: ---use strict;
#Beispiel
# ========================switch =====================================
# battery powered 6 channel switch
# "006C" => {name=>"HM-LC-SW1-BA-PCB" ,st=>'switch' ,cyc=>'' ,rxt=>'b' ,lst=>'3' ,chn=>"",},
# 1 device
# 1 kanal
# 6 peers je kanal erlaubt
#----------------define reglist types-----------------
package usrRegs;
my %listTypes = (
regDev =>{ intKeyVisib=>1, ledMode=>1, lowBatLimitBA=>1, pairCentral=>1,
},
regChan =>{ sign =>1, #| literal | | signature (AES) options:on,off
lgActionType =>1, #| literal | required | options:toggleToCntInv,off,toggleToCnt,jmpToTarget
lgCtDlyOff =>1, #| literal | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
lgCtDlyOn =>1, #| literal | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
lgCtOff =>1, #| literal | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
lgCtOn =>1, #| literal | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
lgCtValHi =>1, #| 0 to 255 | required | Condition value high for CT table
lgCtValLo =>1, #| 0 to 255 | required | Condition value low for CT table
lgMultiExec =>1, #| literal | required | multiple execution per repeat of long trigger options:on,off
lgOffDly =>1, #| 0 to 111600s | required | off delay
lgOffTime =>1, #| 0 to 111600s | required | off time, 111600 = infinite
lgOffTimeMode =>1, #| literal | required | off time mode options:minimal,absolut
lgOnDly =>1, #| 0 to 111600s | required | on delay
lgOnTime =>1, #| 0 to 111600s | required | on time, 111600 = infinite
lgOnTimeMode =>1, #| literal | required | on time mode options:minimal,absolut
lgSwJtDlyOff =>1, #| literal | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
lgSwJtDlyOn =>1, #| literal | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
lgSwJtOff =>1, #| literal | required | Jump from off options:on,off,dlyOn,no,dlyOff
lgSwJtOn =>1, #| literal | required | Jump from on options:on,off,dlyOn,no,dlyOff
shActionType =>1, #| literal | required | options:toggleToCntInv,off,toggleToCnt,jmpToTarget
shCtDlyOff =>1, #| literal | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
shCtDlyOn =>1, #| literal | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
shCtOff =>1, #| literal | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
shCtOn =>1, #| literal | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
shCtValHi =>1, #| 0 to 255 | required | Condition value high for CT table
shCtValLo =>1, #| 0 to 255 | required | Condition value low for CT table
shOffDly =>1, #| 0 to 111600s | required | off delay
shOffTime =>1, #| 0 to 111600s | required | off time, 111600 = infinite
shOffTimeMode =>1, #| literal | required | off time mode options:minimal,absolut
shOnDly =>1, #| 0 to 111600s | required | on delay
shOnTime =>1, #| 0 to 111600s | required | on time, 111600 = infinite
shOnTimeMode =>1, #| literal | required | on time mode options:minimal,absolut
shSwJtDlyOff =>1, #| literal | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
shSwJtDlyOn =>1, #| literal | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
shSwJtOff =>1, #| literal | required | Jump from off options:on,off,dlyOn,no,dlyOff
shSwJtOn =>1, #|
},
);
# -----------assemble device -----------------
my %regList;
$regList{0}={type => "regDev",peers=>1};
$regList{1}={type => "regChan",peers=>6};

sub usr_getHash($){
my $hn = shift;
return %regList if($hn eq "regList" );
return %listTypes if($hn eq "listTypes" );
}

--- Ende Code ---

Was wurde jetzt definiert?
Ein Gerät mit einem Channel 0 und Channel 1, wobei der Channel 1 Platz für 6 Peers haben soll
$regList{0}={type => "regDev",peers=>1};
$regList{1}={type => "regChan",peers=>6};
Channel 0 wird aus der Variable regDev befüllt, Channel 1 aus regList

Wollt ihr jetzt ein Device mit mehr Channel, so muss das hier entsprechend definiert werden - etwa so:
$regList{0}={type => "regDev",peers=>1};
$regList{1}={type => "regChan",peers=>6};
$regList{2}={type => "regChan",peers=>6};
$regList{3}={type => "regChan",peers=>6};
Das wäre jetzt ein Device mit 3 Kanälen, die aber alle gleich sind. So würde aus dem Relay Sketch ein 3 Relay Sketch.

Braucht ihr unterschiedliche Variablen für die Kanäle, dann müsst ihr das so machen:
$regList{0}={type => "regDev",peers=>1};
$regList1{1}={type => "regChan",peers=>6};
$regList2{2}={type => "regChan",peers=>6};
Natürlich müsst ihr dann auch die Variablen zur regList1 und regList2 zuordnen. Gleich mehr dazu...

Wenn euch 6 Peers pro Kanal nicht reichen, dann könnt ihr hier entsprechend mehr Platz reservieren.
Aber Vorsicht - pro Peer werden 4 Byte für die Peer Adresse benötigt und zusätzlich die Anzahl der Bytes in List3/4.
In unserem Beispiel sind das 22 byte.
D.h. 26 byte pro Peer, bei einem Dimmer sind das dann etwa 70byte pro Peer. Da wird der EEprom schnell zu klein.

Das Füllen der Variablen ist dieser Teil - ich nehme mal den Channel 0 weil hier nicht so viele Variablen drin sind

--- Code: --- regDev =>{ intKeyVisib=>1, ledMode=>1, lowBatLimitBA=>1, pairCentral=>1,
},

--- Ende Code ---

Hier werden dem Kanal 0 folgende Variablen zugewiesen:
intKeyVisib - visibility of internal channel options:visib,invisib (derzeit noch nicht in der AskSin implementiert)
ledMode - LED mode options:on,off
lowBatLimitBA - low batterie limit, step .1V
pairCentral - pairing to central (der muss immer im Kanal 0 sein, sonst kann das Device nicht mit der Zentrale gepairt werden)

Wenn jetzt die devDefinition.pm soweit fertig ist, dann kann man die destillRegs.pl in einer Shell aufrufen.
perl destillRegs.pl

In der Shell bekommt man jetzt den Inhalt für die Register.h

--- Code: ---HM::s_modtable modTbl[] = {
{0,0,(s_mod_dlgt)NULL},
{0,0,(s_mod_dlgt)NULL},
}; // 24 byte
//- ----------------------------------------------------------------------------------------------------------------------
//- channel slice definition ---------------------------------------------------------------------------------------------
uint8_t sliceStr[] = {
0x02,0x05,0x0a,0x0b,0x0c,0x12,
0x08,
0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,
}; // 29 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- Channel device config ------------------------------------------------------------------------------------------------
struct s_regDevL0 {
// 0x02,0x05,0x0a,0x0b,0x0c,0x12,
uint8_t :7; // l:0, s:7
uint8_t intKeyVisib :1; // 0x02, s:7, e:8
uint8_t :6; // l:0, s:6
uint8_t ledMode :2; // 0x05, s:6, e:8
uint8_t pairCentral[3]; // 0x0a, s:0, e:0
uint8_t lowBatLimitBA; // 0x12, s:0, e:0
};

struct s_regChanL1 {
// 0x08,
uint8_t sign :1; // 0x08, s:0, e:1
uint8_t :7; //
};

struct s_regChanL3 {
// 0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,
uint8_t shCtDlyOn :4; // 0x02, s:0, e:4
uint8_t shCtDlyOff :4; // 0x02, s:4, e:8
uint8_t shCtOn :4; // 0x03, s:0, e:4
uint8_t shCtOff :4; // 0x03, s:4, e:8
uint8_t shCtValLo; // 0x04, s:0, e:0
uint8_t shCtValHi; // 0x05, s:0, e:0
uint8_t shOnDly; // 0x06, s:0, e:0
uint8_t shOnTime; // 0x07, s:0, e:0
uint8_t shOffDly; // 0x08, s:0, e:0
uint8_t shOffTime; // 0x09, s:0, e:0
uint8_t shActionType :2; // 0x0a, s:0, e:2
uint8_t :4; //
uint8_t shOffTimeMode :1; // 0x0a, s:6, e:7
uint8_t shOnTimeMode :1; // 0x0a, s:7, e:8
uint8_t shSwJtOn :4; // 0x0b, s:0, e:4
uint8_t shSwJtOff :4; // 0x0b, s:4, e:8
uint8_t shSwJtDlyOn :4; // 0x0c, s:0, e:4
uint8_t shSwJtDlyOff :4; // 0x0c, s:4, e:8
uint8_t lgCtDlyOn :4; // 0x82, s:0, e:4
uint8_t lgCtDlyOff :4; // 0x82, s:4, e:8
uint8_t lgCtOn :4; // 0x83, s:0, e:4
uint8_t lgCtOff :4; // 0x83, s:4, e:8
uint8_t lgCtValLo; // 0x84, s:0, e:0
uint8_t lgCtValHi; // 0x85, s:0, e:0
uint8_t lgOnDly; // 0x86, s:0, e:0
uint8_t lgOnTime; // 0x87, s:0, e:0
uint8_t lgOffDly; // 0x88, s:0, e:0
uint8_t lgOffTime; // 0x89, s:0, e:0
uint8_t lgActionType :2; // 0x8a, s:0, e:2
uint8_t :3; //
uint8_t lgMultiExec :1; // 0x8a, s:5, e:6
uint8_t lgOffTimeMode :1; // 0x8a, s:6, e:7
uint8_t lgOnTimeMode :1; // 0x8a, s:7, e:8
uint8_t lgSwJtOn :4; // 0x8b, s:0, e:4
uint8_t lgSwJtOff :4; // 0x8b, s:4, e:8
uint8_t lgSwJtDlyOn :4; // 0x8c, s:0, e:4
uint8_t lgSwJtDlyOff :4; // 0x8c, s:4, e:8
};

struct s_regDev {
s_regDevL0 l0;
};

struct s_regChan {
s_regChanL1 l1;
s_regChanL3 l3;
};

struct s_regs {
s_regDev ch0;
s_regChan ch1;
} regs; // 139 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- channel device list table --------------------------------------------------------------------------------------------
s_cnlDefType cnlDefType[] PROGMEM = {
// cnl, lst, pMax, sIdx, sLen, pAddr, pPeer, *pRegs;

{0, 0, 0, 0x00, 6, 0x0000, 0x0000, (void*)&regs.ch0.l0},
{1, 1, 0, 0x06, 1, 0x0006, 0x0000, (void*)&regs.ch1.l1},
{1, 3, 6, 0x07, 22, 0x0007, 0x0000, (void*)&regs.ch1.l3},
}; // 33 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- handover to AskSin lib -----------------------------------------------------------------------------------------------
HM::s_devDef dDef = {
1, 3, sliceStr, cnlDefType,
}; // 6 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- eeprom definition ----------------------------------------------------------------------------------------------------
// define start address and size in eeprom for magicNumber, peerDB, regsDB, userSpace
HM::s_eeprom ee[] = {
{0x0000, 0x0002, 0x001a, 0x00a5,},
{0x0002, 0x0018, 0x008b, 0x0000,},
}; // 16 byte

--- Ende Code ---

Sollten noch Fragen sein, immer gerne

Viele Grüße
Horst

thunder1902 · 07 Oktober 2014, 22:46:46

@trilu:

Hab jetzt mal das destillregs.pl mit deiner oben genannten Config aufgerufen: In Deiner Config steht doch eignentlich drin, dass nur 1 Kanal zur Verfügung steht!?!

Zitat# 1 device
# 1 kanal
# 6 peers je kanal erlaubt

Außerdem ist das, was rauskommt - 1:1 identisch mit der devDefinition.pm - HM_LC_SW1_BA_PCB im destillRegs-Verzeichnis...??

Oder muss ich nur die Relay-Classen 3x definieren?

Wie weiß ich , welche PIN's die Schalter und Aktoren auf dem Arduino Mini Pro haben???

trilu · 08 Oktober 2014, 16:38:16

Zitat von: thunder1902 am 07 Oktober 2014, 22:46:46
@trilu:

Hab jetzt mal das destillregs.pl mit deiner oben genannten Config aufgerufen: In Deiner Config steht doch eignentlich drin, dass nur 1 Kanal zur Verfügung steht!?!

Außerdem ist das, was rauskommt - 1:1 identisch mit der devDefinition.pm - HM_LC_SW1_BA_PCB im destillRegs-Verzeichnis...??

Oder muss ich nur die Relay-Classen 3x definieren?

Wie weiß ich , welche PIN's die Schalter und Aktoren auf dem Arduino Mini Pro haben???

Glaub ich nicht

Code Auswählen

#      -----------assemble device -----------------
my %regList;
$regList{0}={type => "regDev",peers=>1};
$regList{1}={type => "regChan",peers=>6};
$regList{2}={type => "regChan",peers=>6};
$regList{3}={type => "regChan",peers=>6};

Die Zeilen machen den Unterschied.
$regList{2} damit wird Kanal 2 definiert. Kanal zwei bekommt die selben Register wie Kanal 1 zugewiesen, aber in einem eigenen Speicherbereich.
$regList{3} siehe 2

Damit erstellst du aber nur die Register, jetzt musst du mit den Registern noch irgendwas anfangen. Das passiert mit den Channel Modulen - in deinem Fall mit der Relay Class.
relay[0].regInHM(1,&hm);
relay[1].regInHM(2,&hm);
relay[2].regInHM(3,&hm);
Über die Funktion regInHM werden die Class Module in Asksin einem Kanal zugewiesen. Das ist der erste Wert in der Klammer...

Der nächste Schritt ist, du weißt der Relay Class die entsprechenden Pins zu...

Code Auswählen

void MyClassName::config(uint8_t type, uint8_t pinOn, uint8_t pinOff, uint8_t minDelay, uint8_t randomDelay) {
	// store config settings in class
	hwType = type;																// 0 indicates a monostable, 1 a bistable relay
	hwPin[0] = pinOn;															// first byte for on, second for off
	hwPin[1] = pinOff;

	mDel = minDelay;															// remember minimum delay for sending the status
	rDel = (randomDelay)?randomDelay:1;											// remember random delay for sending the status

Bei monostable, wird nur pinOn genutzt. Das ganze folgt der Arduino Pin Nummerierung.
Die Pins müssten eigentlich auf deinem Arduino aufgedruckt sein...

Viele Grüße
Horst

mmatt · 09 Oktober 2014, 11:27:21

Hallo trilu,
ist zwar etwas offtopic aber...
um mehrere Variablen auf die Serielle Konsole auszugeben wird zb. das hier verwendet:

Code Auswählen

Serial << F("s: ") << pHexL(hm.send.data, hm.send.data[0]+1) << '\n';
Das ist sehr praktisch

Das obige habe ich bei einem neuem Sketch versucht, aber "Serial" kennt "<<" nicht. Denke mir fehlt da eine Bibliothek die eingebunden werden muss ?
Kannst Du das kurz erklären ?

Grüsse Martin

trilu · 09 Oktober 2014, 14:02:25

Hi Martin,
das mit der Serial ist einfach...

Dieses Template muss irgendwo in deinem Sketch sein:
template<class T> inline Print &operator <<(Print &obj, T arg) { obj.print(arg); return obj; }

Um sowas wie pHex nutzen zu können, brauchst du folgende Makros:
#define pHexB(x) char((x>>4)>9?(x>>4)+55:(x>>4)+48)<< char((x&0xF)>9?(x&0xF)+55:(x&0xF)+48)
#define pHex(x,y) char(0);for(uint8_t i=0;i<y;i++)dbg<<pHexB(x)<<char(i+1<y?32:0);dbg<<char(0)

Viele Grüße
Horst

thunder1902 · 18 Oktober 2014, 12:25:25

Hallo Trilu,

ich hab die Schritte jetzt alle nochmals probiert - und habe immer noch folgendes Problem:
Was habe ich bis jetzt gemacht?

1. Dein Beispiel von oben (3-Kanal Schalter) durch die destillreg gejagt. Als Ergebnis habe ich folgenden Text erhalten, der 1:1 mit dem entsprechenden Teil in der Register.h im HM_LC_SW1_BA_PCB- example Verzeichnis ist. 3

Zitat
HM::s_modtable modTbl[] = {
{0,0,(s_mod_dlgt)NULL},
{0,0,(s_mod_dlgt)NULL},
}; // 24 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- channel slice definition ---------------------------------------------------------------------------------------------
uint8_t sliceStr[] = {
0x02,0x05,0x0a,0x0b,0x0c,0x12,
0x08,
0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,
}; // 29 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- Channel device config ------------------------------------------------------------------------------------------------
struct s_regDevL0 {
// 0x02,0x05,0x0a,0x0b,0x0c,0x12,
uint8_t :7; // l:0, s:7
uint8_t intKeyVisib :1; // 0x02, s:7, e:8
uint8_t :6; // l:0, s:6
uint8_t ledMode :2; // 0x05, s:6, e:8
uint8_t pairCentral[3]; // 0x0a, s:0, e:0
uint8_t lowBatLimitBA; // 0x12, s:0, e:0
};

struct s_regChanL1 {
// 0x08,
uint8_t sign :1; // 0x08, s:0, e:1
uint8_t :7; //
};

struct s_regChanL3 {
// 0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,
uint8_t shCtDlyOn :4; // 0x02, s:0, e:4
uint8_t shCtDlyOff :4; // 0x02, s:4, e:8
uint8_t shCtOn :4; // 0x03, s:0, e:4
uint8_t shCtOff :4; // 0x03, s:4, e:8
uint8_t shCtValLo; // 0x04, s:0, e:0
uint8_t shCtValHi; // 0x05, s:0, e:0
uint8_t shOnDly; // 0x06, s:0, e:0
uint8_t shOnTime; // 0x07, s:0, e:0
uint8_t shOffDly; // 0x08, s:0, e:0
uint8_t shOffTime; // 0x09, s:0, e:0
uint8_t shActionType :2; // 0x0a, s:0, e:2
uint8_t :4; //
uint8_t shOffTimeMode :1; // 0x0a, s:6, e:7
uint8_t shOnTimeMode :1; // 0x0a, s:7, e:8
uint8_t shSwJtOn :4; // 0x0b, s:0, e:4
uint8_t shSwJtOff :4; // 0x0b, s:4, e:8
uint8_t shSwJtDlyOn :4; // 0x0c, s:0, e:4
uint8_t shSwJtDlyOff :4; // 0x0c, s:4, e:8
uint8_t lgCtDlyOn :4; // 0x82, s:0, e:4
uint8_t lgCtDlyOff :4; // 0x82, s:4, e:8
uint8_t lgCtOn :4; // 0x83, s:0, e:4
uint8_t lgCtOff :4; // 0x83, s:4, e:8
uint8_t lgCtValLo; // 0x84, s:0, e:0
uint8_t lgCtValHi; // 0x85, s:0, e:0
uint8_t lgOnDly; // 0x86, s:0, e:0
uint8_t lgOnTime; // 0x87, s:0, e:0
uint8_t lgOffDly; // 0x88, s:0, e:0
uint8_t lgOffTime; // 0x89, s:0, e:0
uint8_t lgActionType :2; // 0x8a, s:0, e:2
uint8_t :3; //
uint8_t lgMultiExec :1; // 0x8a, s:5, e:6
uint8_t lgOffTimeMode :1; // 0x8a, s:6, e:7
uint8_t lgOnTimeMode :1; // 0x8a, s:7, e:8
uint8_t lgSwJtOn :4; // 0x8b, s:0, e:4
uint8_t lgSwJtOff :4; // 0x8b, s:4, e:8
uint8_t lgSwJtDlyOn :4; // 0x8c, s:0, e:4
uint8_t lgSwJtDlyOff :4; // 0x8c, s:4, e:8
};

struct s_regDev {
s_regDevL0 l0;
};

struct s_regChan {
s_regChanL1 l1;
s_regChanL3 l3;
};

struct s_regs {
s_regDev ch0;
s_regChan ch1;
} regs; // 139 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- channel device list table --------------------------------------------------------------------------------------------
s_cnlDefType cnlDefType[] PROGMEM = {
// cnl, lst, pMax, sIdx, sLen, pAddr, pPeer, *pRegs; // pointer to regs structure

{0, 0, 0, 0x00, 6, 0x0000, 0x0000, (void*)&regs.ch0.l0},
{1, 1, 0, 0x06, 1, 0x0006, 0x0000, (void*)&regs.ch1.l1},
{1, 3, 6, 0x07, 22, 0x0007, 0x0000, (void*)&regs.ch1.l3},
}; // 33 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- handover to AskSin lib -----------------------------------------------------------------------------------------------
HM::s_devDef dDef = {
1, 3, sliceStr, cnlDefType,
}; // 6 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- eeprom definition ----------------------------------------------------------------------------------------------------
// define start address and size in eeprom for magicNumber, peerDB, regsDB, userSpace
HM::s_eeprom ee[] = {
{0x0000, 0x0002, 0x001a, 0x00a5,},
{0x0002, 0x0018, 0x008b, 0x0000,},
}; // 16 byte

Irgendwas ist da schief gelaufen, da die destilreg ja keine Änderungen macht..??

Kannst du mir da sagen was ich falsch mache???

trilu · 19 Oktober 2014, 17:15:00

keine ahnung was da schief läuft...

also, du nimmst das file "devDefinition.pm", da muss dieser content rein:

Code Auswählen


use strict;
#Beispiel 
# ========================switch =====================================
# 
#   "006C" => {name=>"HM-LC-SW1-BA-PCB"        ,st=>'switch'            ,cyc=>''      ,rxt=>'b'      ,lst=>'3'            ,chn=>"",},
# 1 device
# 1 kanal
# 6 peers je kanal erlaubt
#----------------define reglist types-----------------
package usrRegs;
my %listTypes = (
      regDev =>{ intKeyVisib=>1, ledMode=>1, lowBatLimitBA=>1, pairCentral=>1,
              },
      regChan       =>{ sign          =>1,    #|     literal        |          | signature (AES) options:on,off
                        lgActionType  =>1,    #|     literal        | required |  options:toggleToCntInv,off,toggleToCnt,jmpToTarget
                        lgCtDlyOff    =>1,    #|     literal        | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
                        lgCtDlyOn     =>1,    #|     literal        | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
												lgCtOff       =>1,    #|     literal        | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
                        lgCtOn        =>1,    #|     literal        | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
												lgCtValHi     =>1,    #|   0 to 255         | required | Condition value high for CT table
                        lgCtValLo     =>1,    #|   0 to 255         | required | Condition value low for CT table
												lgMultiExec   =>1,    #|     literal        | required | multiple execution per repeat of long trigger options:on,off
												lgOffDly      =>1,    #|   0 to 111600s     | required | off delay
												lgOffTime     =>1,    #|   0 to 111600s     | required | off time, 111600 = infinite
												lgOffTimeMode =>1,    #|     literal        | required | off time mode options:minimal,absolut
												lgOnDly       =>1,    #|   0 to 111600s     | required | on delay
												lgOnTime      =>1,    #|   0 to 111600s     | required | on time, 111600 = infinite
												lgOnTimeMode  =>1,    #|     literal        | required | on time mode options:minimal,absolut
												lgSwJtDlyOff  =>1,    #|     literal        | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
												lgSwJtDlyOn   =>1,    #|     literal        | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
												lgSwJtOff     =>1,    #|     literal        | required | Jump from off options:on,off,dlyOn,no,dlyOff
												lgSwJtOn      =>1,    #|     literal        | required | Jump from on options:on,off,dlyOn,no,dlyOff
												shActionType  =>1,    #|     literal        | required |  options:toggleToCntInv,off,toggleToCnt,jmpToTarget
												shCtDlyOff    =>1,    #|     literal        | required | Jmp on condition from delayOff options:geLo,between,outside,ltLo,geHi,ltHi
												shCtDlyOn     =>1,    #|     literal        | required | Jmp on condition from delayOn options:geLo,between,outside,ltLo,geHi,ltHi
												shCtOff       =>1,    #|     literal        | required | Jmp on condition from off options:geLo,between,outside,ltLo,geHi,ltHi
												shCtOn        =>1,    #|     literal        | required | Jmp on condition from on options:geLo,between,outside,ltLo,geHi,ltHi
												shCtValHi     =>1,    #|   0 to 255         | required | Condition value high for CT table
												shCtValLo     =>1,    #|   0 to 255         | required | Condition value low for CT table
												shOffDly      =>1,    #|   0 to 111600s     | required | off delay
												shOffTime     =>1,    #|   0 to 111600s     | required | off time, 111600 = infinite
												shOffTimeMode =>1,    #|     literal        | required | off time mode options:minimal,absolut
												shOnDly       =>1,    #|   0 to 111600s     | required | on delay
												shOnTime      =>1,    #|   0 to 111600s     | required | on time, 111600 = infinite
												shOnTimeMode  =>1,    #|     literal        | required | on time mode options:minimal,absolut
												shSwJtDlyOff  =>1,    #|     literal        | required | Jump from delayOff options:on,off,dlyOn,no,dlyOff
												shSwJtDlyOn   =>1,    #|     literal        | required | Jump from delayOn options:on,off,dlyOn,no,dlyOff
												shSwJtOff     =>1,    #|     literal        | required | Jump from off options:on,off,dlyOn,no,dlyOff
												shSwJtOn      =>1,    #|     
		          },
     );
#      -----------assemble device -----------------
my %regList;
$regList{0}={type => "regDev",peers=>1};
$regList{1}={type => "regChan",peers=>6};
$regList{2}={type => "regChan",peers=>6};
$regList{3}={type => "regChan",peers=>6};
$regList{4}={type => "regChan",peers=>6};

sub usr_getHash($){
  my $hn = shift;
  return %regList       if($hn eq "regList"      );
  return %listTypes     if($hn eq "listTypes"       );
}

danach abspeichern, wieder öffnen und kontrollieren ob das auch wirklich der inhalt des files ist.

jetzt eine shell öffnen, in das verzeichnis mit dem file wechseln...
jetzt das in die kommandozeile eingeben:

destillRegs.pl devDefinition.pm

danach return drücken - führt zu diesem output:

Code Auswählen


HM::s_modtable modTbl[] = {
    {0,0,(s_mod_dlgt)NULL},
    {0,0,(s_mod_dlgt)NULL},
    {0,0,(s_mod_dlgt)NULL},
    {0,0,(s_mod_dlgt)NULL},
    {0,0,(s_mod_dlgt)NULL},
}; // 72 byte

//- ----------------------------------------------------------------------------------------------------------------------
//- channel slice definition ---------------------------------------------------------------------------------------------
uint8_t sliceStr[] = {
    0x02,0x05,0x0a,0x0b,0x0c,0x12,
    0x08,
    0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,
}; // 29 byte


//- ----------------------------------------------------------------------------------------------------------------------
//- Channel device config ------------------------------------------------------------------------------------------------
struct s_regDevL0 {
    // 0x02,0x05,0x0a,0x0b,0x0c,0x12,
    uint8_t                      :7;     //       l:0, s:7
    uint8_t  intKeyVisib         :1;     // 0x02, s:7, e:8
    uint8_t                      :6;     //       l:0, s:6
    uint8_t  ledMode             :2;     // 0x05, s:6, e:8
    uint8_t  pairCentral[3];             // 0x0a, s:0, e:0
    uint8_t  lowBatLimitBA;              // 0x12, s:0, e:0
};

struct s_regChanL1 {
    // 0x08,
    uint8_t  sign                :1;     // 0x08, s:0, e:1
    uint8_t                      :7;     //
};

struct s_regChanL3 {
    // 0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,
    uint8_t  shCtDlyOn           :4;     // 0x02, s:0, e:4
    uint8_t  shCtDlyOff          :4;     // 0x02, s:4, e:8
    uint8_t  shCtOn              :4;     // 0x03, s:0, e:4
    uint8_t  shCtOff             :4;     // 0x03, s:4, e:8
    uint8_t  shCtValLo;                  // 0x04, s:0, e:0
    uint8_t  shCtValHi;                  // 0x05, s:0, e:0
    uint8_t  shOnDly;                    // 0x06, s:0, e:0
    uint8_t  shOnTime;                   // 0x07, s:0, e:0
    uint8_t  shOffDly;                   // 0x08, s:0, e:0
    uint8_t  shOffTime;                  // 0x09, s:0, e:0
    uint8_t  shActionType        :2;     // 0x0a, s:0, e:2
    uint8_t                      :4;     //
    uint8_t  shOffTimeMode       :1;     // 0x0a, s:6, e:7
    uint8_t  shOnTimeMode        :1;     // 0x0a, s:7, e:8
    uint8_t  shSwJtOn            :4;     // 0x0b, s:0, e:4
    uint8_t  shSwJtOff           :4;     // 0x0b, s:4, e:8
    uint8_t  shSwJtDlyOn         :4;     // 0x0c, s:0, e:4
    uint8_t  shSwJtDlyOff        :4;     // 0x0c, s:4, e:8
    uint8_t  lgCtDlyOn           :4;     // 0x82, s:0, e:4
    uint8_t  lgCtDlyOff          :4;     // 0x82, s:4, e:8
    uint8_t  lgCtOn              :4;     // 0x83, s:0, e:4
    uint8_t  lgCtOff             :4;     // 0x83, s:4, e:8
    uint8_t  lgCtValLo;                  // 0x84, s:0, e:0
    uint8_t  lgCtValHi;                  // 0x85, s:0, e:0
    uint8_t  lgOnDly;                    // 0x86, s:0, e:0
    uint8_t  lgOnTime;                   // 0x87, s:0, e:0
    uint8_t  lgOffDly;                   // 0x88, s:0, e:0
    uint8_t  lgOffTime;                  // 0x89, s:0, e:0
    uint8_t  lgActionType        :2;     // 0x8a, s:0, e:2
    uint8_t                      :3;     //
    uint8_t  lgMultiExec         :1;     // 0x8a, s:5, e:6
    uint8_t  lgOffTimeMode       :1;     // 0x8a, s:6, e:7
    uint8_t  lgOnTimeMode        :1;     // 0x8a, s:7, e:8
    uint8_t  lgSwJtOn            :4;     // 0x8b, s:0, e:4
    uint8_t  lgSwJtOff           :4;     // 0x8b, s:4, e:8
    uint8_t  lgSwJtDlyOn         :4;     // 0x8c, s:0, e:4
    uint8_t  lgSwJtDlyOff        :4;     // 0x8c, s:4, e:8
};

struct s_regDev {
    s_regDevL0 l0;
};

struct s_regChan {
    s_regChanL1 l1;
    s_regChanL3 l3;
};

struct s_regs {
    s_regDev ch0;
    s_regChan ch1;
    s_regChan ch2;
    s_regChan ch3;
    s_regChan ch4;
} regs; // 538 byte


//- ----------------------------------------------------------------------------------------------------------------------
//- channel device list table --------------------------------------------------------------------------------------------
s_cnlDefType cnlDefType[] PROGMEM = {
    // cnl, lst, pMax, sIdx, sLen, pAddr, pPeer, *pRegs;

    {0, 0, 0, 0x00, 6, 0x0000, 0x0000, (void*)&regs.ch0.l0},
    {1, 1, 0, 0x06, 1, 0x0006, 0x0000, (void*)&regs.ch1.l1},
    {1, 3, 6, 0x07, 22, 0x0007, 0x0000, (void*)&regs.ch1.l3},
    {2, 1, 0, 0x06, 1, 0x008b, 0x0000, (void*)&regs.ch2.l1},
    {2, 3, 6, 0x07, 22, 0x008c, 0x0018, (void*)&regs.ch2.l3},
    {3, 1, 0, 0x06, 1, 0x0110, 0x0000, (void*)&regs.ch3.l1},
    {3, 3, 6, 0x07, 22, 0x0111, 0x0030, (void*)&regs.ch3.l3},
    {4, 1, 0, 0x06, 1, 0x0195, 0x0000, (void*)&regs.ch4.l1},
    {4, 3, 6, 0x07, 22, 0x0196, 0x0048, (void*)&regs.ch4.l3},
}; // 99 byte


//- ----------------------------------------------------------------------------------------------------------------------
//- handover to AskSin lib -----------------------------------------------------------------------------------------------
HM::s_devDef dDef = {
    4, 9, sliceStr, cnlDefType,
}; // 6 byte


//- ----------------------------------------------------------------------------------------------------------------------
//- eeprom definition ----------------------------------------------------------------------------------------------------
// define start address  and size in eeprom for magicNumber, peerDB, regsDB, userSpace
HM::s_eeprom ee[] = {
    {0x0000, 0x0002, 0x0062, 0x027c,},
    {0x0002, 0x0060, 0x021a, 0x0000,},
}; // 16 byte

viele grüße
trilu

mmatt · 31 Oktober 2014, 18:03:47

Lieber trilu,
Erst mal danke für die pHex Erklärung.

Ich spiele gerade mit der "alten" Libary herum.
Mit dem Ziel einfach ein paar Daten über ein Device an FHEM zu senden.
Dafür nutze ich die dirrekt CC110x Klasse der Libary.

Mit ein paar Zeilen Code einfach 3 Bytes an FHEM senden:

Code Auswählen

CC110x cc;
uint8_t buffer[]={0x02,0xFF,0xAA};
uint8_t burst=0;

void setup()
{    
  Serial.begin(9600);
  cc.config(10,11,12,13,2,0); // set the respective pins
  cc.init();
}

void loop()
{     
   delay(60000);  
   cc.sendData(buffer,burst);     
}

wenn ich nun die Rohdaten in die ich mit FHEM anschaue bekomme ich:

Code Auswählen

CUL_0: unknown message A028908

A: könnte den Empfang darstellen
02: Anzahl der Bytes
89: ? -> sollte FF

08: ? -> sollte AA

Weisst Du wie die 89 und 08 zustande kommen ?

Grüsse Martin

trilu · 31 Oktober 2014, 18:59:50

Hi Martin,
das wird so einfach nicht funktionieren.
HM sendet verschlüsselt und entschlüsselt nach dem Empfang.
D.h. deine Bytes sind entschlüsselt worden und damit natürlich Käse.

Du musst zumindest diese Funktion vorher aufrufen...
void HM::hm_enc(uint8_t *buf);

Übergibst deinen Send Buffer, also das Array.
Das erste Byte im Array bestimmt die Länge!
In deinem Fall musst du also 4 Byte senden. {0x03, 0x02,0xFF,0xAA}

Viele Grüße
Horst

mmatt · 31 Oktober 2014, 20:43:17

Hallo trilu,

verschlüsselt ...

Ja, mit der Funktion HM::hm_enc(uint8_t *buf) klappt es nun

Hab zuerst gedacht, dass da was beim Senden schief geht.

Danke Dir, und wünsch noch nen schönen Abend.
Grüsse Martin

trilu · 09 November 2014, 13:50:20

@all

In der NewAskSin gibt es jetzt eine Dimmer Class - Funktioniert soweit schon recht ordentlich auf dem Schreibtisch.
Der Dimmer basiert auf den Registererstellungen von einem existierenden LED Dimmer. Hat also mehr Register, als der HM Phasenanschnitt Dimmer.

Pair & Peer läuft, Defaults werden gesetzt. Nutze allerdings noch nicht alle Variablen die durch die List3 angeboten werden.
Zum Teil weiß ich auch nicht was sie bedeuten. Größtenteils habe ich das verhalten von einem existierenden Dimmer nachgeahmt.
Die Verknüpfung mit den virtuellen Channels habe ich auch nicht implementiert, da sich mir der Nutzen noch nicht erschließt.

List1 Inhalte habe ich über die HM Config Soft gesetzt. Verknüpfung mit einem 6-Fach Schalter auch.

Zum testen benötigt ihr eine Led die an PD3 (http://giltesa.com/wp-content/uploads/2014/02/arduino-pinouts.jpg) gegen Masse
angeschlossen wird. Zum Pairen kann man eine Taste an PB8 gegen Masse anschliessen. Langer Tastendruck sendet dann den Pair String an
den Master. Weiterhin habe ich eine ZweifarbLED für die Statuserkennung angeschlossen. Die Pins für die LED sind PD4 und PD6 gegen Masse.

Alles in allem ist die NewAskSin deutlich kleiner geworden. destillRegs.pl überarbeite ich gerade, funktioniert also noch nicht...

Viel Spass beim testen!
Falls ihr Fehler findet, wäre es nett wenn ihr die entsprechenden Logs der seriellen Konsole hier einstellt mit einer kurzen Beschreibung des Fehlers,
bzw. dem Verhalten wie es sein soll...

Die NewAskSin bekommt ihr hier: https://github.com/trilu2000/NewAskSin
Ich kompiliere unter Arduino 1.5.7 mit Visual Micro plugin (http://www.visualmicro.com/) in Atmel Studio 6
Unter Arduino 1.0 kommt es zu fehlern....

Ich frage mich gerade ob es Sinn machen würde, für die NewAskSin einen neuen Thread aufzumachen. Das ist die Lib die ich weiter entwickeln möchte...
Dokumentation ist begonnen, aber auch noch nicht vorzeige fähig. Wer mit entwickeln möchte, bekommt gerne Schreibrechte für den GIT.
Nächste User Module sind, Switch Class zum Aufbau von 2 und 6 Fach Schaltern und eine universelle Sensor Class, bei der HW unabhängig Messwerte
genutzt werden können.

Viele Grüße
Horst