Commit c8aa2affae4a854d42a4852e2fe0c059ffbc719c

Michael Tross
Fri Sep 03 09:06:40 CEST 2010

Tree SHA1: a40b6d2
Parent SHA1: 4e965b6 (dss-socket build fixes)
raw diff | raw patch

modified payload to use a generic dS485Container

removed all references to raw data packets

Diff rendering mode:
inline
side by side


17	17
18	18	#define dSMAPI_CALL_TIMEOUT_SEKUNDEN 5
19	19
20
21		#if defined(__GNUC__)
22		#pragma pack(1)
23		#endif
24
25	20	#include "core/ds485-socket/ds485c.h"
26	21
27	22	extern dsidType dSIDBroadcast;
28	23
29		/*
30		* dS485 Frame for transporting through socket
31		*/
32		typedef struct _dS485TransportFrame {
33		unsigned char start;
34	24
35		unsigned char typeflag : 1;
36		unsigned char broadcastflag : 1;
37		unsigned char destination : 6;
38
39		unsigned char msgid : 2;
40		unsigned char source : 6;
41
42		unsigned char length : 4;
43		unsigned char command : 4;
44
45		unsigned char data[15]; /* 15 data bytes max on the wire */
46		unsigned char _pad0; /* some systems require word alignment ... */
47
48		unsigned short crc16;
49		} dS485TransportFrame;
50
51		/*
52		* dS485 Container for internal
53		*/
54		/*
55		typedef struct _dS485Container {
56		unsigned char broadcastflag;
57		dsidType destination;
58
59		unsigned char msgid;
60
61		unsigned char length;
62		unsigned char command;
63		union _data {
64		struct _parameter{
65		unsigned char msgID;
66		unsigned short parameter1;
67		unsigned short parameter2;
68		unsigned short parameter3;
69		unsigned short parameter4;
70		unsigned short parameter5;
71		unsigned short parameter6;
72		unsigned short parameter7;
73		} parameter;
74		unsigned char plaindata[15];
75		} data;
76		} dS485Container;
77		*/
78		/*
79		* dS485 Datagramm
80		*/
81		typedef struct _dS485Packet {
82		dS485TransportFrame frame;
83		time_t tstamp;
84		unsigned short length;
85		unsigned short flags;
86		unsigned short valid;
87		struct _dS485Packet* next;
88		} dS485Packet;
89
90
91		#if defined(__GNUC__)
92		#pragma pack()
93		#endif
94
95	25	typedef enum {
96		notWaiting,
97		Waiting,
98		Received
	26	notWaiting,
	27	Waiting,
	28	Received
99	29	} answerState;
100	30
101	31	typedef struct {


104	104	{
105	105	int messageID=pFrage.data[0];
106	106
107		dsid_t dSMID=getdsid_tFromdsidType(pFrage.destination);
	107	dsid_t dSMID=getdsid_tFromdsidType(pFrage.deviceId);
108	108
109	109	int zoneID,devID,groupID,sceneID;
110	110	int FID;
…	…
230	230	}
231	231	case MAPI_GET_POWER_CONSUMPTION:
232	232	{
233		if (pFrage.containerType==DSTELEGRAM_RESPONSE)
	233	if (pFrage.containerType==DS485_CONTAINER_RESPONSE)
234	234	{
235	235	ModelEvent* pEvent = new ModelEvent(ModelEvent::etPowerConsumption);
236	236	pEvent->setMeter(dSMID);
…	…
241	241	}
242	242	case MAPI_GET_POWER_METERVALUE:
243	243	{
244		if (pFrage.containerType==DSTELEGRAM_RESPONSE)
	244	if (pFrage.containerType==DS485_CONTAINER_RESPONSE)
245	245	{
246	246	ModelEvent* pEvent = new ModelEvent(ModelEvent::etEnergyMeterValue);
247	247	pEvent->setMeter(dSMID);
…	…
252	252	}
253	253	case MAPI_GET_DSID:
254	254	{
255		if (pFrage.containerType==DSTELEGRAM_RESPONSE)
	255	if (pFrage.containerType==DS485_CONTAINER_RESPONSE)
256	256	{
257	257	ModelEvent* pEvent = new ModelEvent(ModelEvent::etDS485DeviceDiscovered);
258	258	pEvent->setMeter(dSMID);
…	…
267	267	{
268	268	int messageID=pFrage.data[0];
269	269	int zoneID,devID,groupID,sceneID,sensorIndex,value;
270		dsid_t dSMID=getdsid_tFromdsidType(pFrage.destination);
	270	dsid_t dSMID=getdsid_tFromdsidType(pFrage.deviceId);
271	271
272	272	switch (messageID){
273	273	case DSMAPI_DEVICE_ADDED:
…	…
377	377	}
378	378	case DSMAPI_DSM_CIRCUIT_METERING_VALUE:
379	379	{
380		if (pFrage.containerType==DSTELEGRAM_RESPONSE)
	380	if (pFrage.containerType==DS485_CONTAINER_RESPONSE)
381	381	{
382	382	ModelEvent* pEvent = new ModelEvent(ModelEvent::etEnergyMeterValue);
383	383
…	…
394	394	}
395	395	case DSMAPI_DSM_DSID:
396	396	{
397		if (pFrage.containerType==DSTELEGRAM_RESPONSE)
	397	if (pFrage.containerType==DS485_CONTAINER_RESPONSE)
398	398	{
399	399	ModelEvent* pEvent = new ModelEvent(ModelEvent::etDS485DeviceDiscovered);
400	400	pEvent->setMeter(dSMID);
…	…
427	427	formatContainer(oLogMSG,&pFrage);
428	428	log("Callback:\n" + std::string(oLogMSG), lsInfo);
429	429	*/
430		if (ds485_get_dsid_state(pFrage.destination)==1)
	430	if (ds485_get_dsid_state(pFrage.deviceId)==1)
431	431	mycallBackOld(pFrage);
432	432	else
433	433	mycallBackNew(pFrage);
…	…
755	755	dSMAPI_getEnergyMeterValue(dSIDBroadcast);
756	756
757	757	dS485Container pFrame;
758		pFrame.containerType=DSTELEGRAM_REQUEST;
759		pFrame.destination=dSIDBroadcast;
	758	pFrame.containerType=DS485_CONTAINER_REQUEST;
	759	pFrame.deviceId=dSIDBroadcast;
760	760	pFrame.data[0]=DSMAPI_DSM_CIRCUIT_METERING_VALUE;
761	761	setModifier(pFrame,DSMAPI_MODIFIER_GET);
762	762	setParameterCount(pFrame,0);
…	…
769	769	dSMAPI_getPowerConsumption(dSIDBroadcast);
770	770
771	771	dS485Container pFrame;
772		pFrame.containerType=DSTELEGRAM_REQUEST;
773		pFrame.destination=dSIDBroadcast;
	772	pFrame.containerType=DS485_CONTAINER_REQUEST;
	773	pFrame.deviceId=dSIDBroadcast;
774	774	pFrame.data[0]=DSMAPI_DSM_CIRCUIT_METERING_VALUE;
775	775	setModifier(pFrame,DSMAPI_MODIFIER_GET);
776	776	setParameterCount(pFrame,0);


28	28	#include "ds485d-interface.h"
29	29	#include "ds485RawFunction-old.h"
30	30	#include "ds485Connection.h"
	31
	32
31	33	/******************************************************************************
32	34	*
33	35	*/
34	36
	37	typedef enum {
	38	API_VERSION_1 = 1,
	39	API_VERSION_2 = 2,
	40	} ApiVersion_t;
	41
35	42	typedef struct
36	43	{
37		dsidType oDSID;
38		int state;
39		}oDSIDItem;
	44	dsidType oDSID;
	45	ApiVersion_t state;
	46	} oDSIDItem;
40	47
41	48	typedef struct
42	49	{
43		BusState_t sessionState;
44		oDSIDItem dSIDExisting[64];
45		char* dProtocol;
46		char* dHostname;
47		char* dPort;
48		int sockfd;
	50	BusState_t sessionState;
	51	oDSIDItem dSIDExisting[64];
	52	char* dProtocol;
	53	char* dHostname;
	54	char* dPort;
	55	int sockfd;
49	56	} connectionItem_t;
50	57
51	58	connectionItem_t connectionItem[MAX_THREADS];
52	59	client_callback_state_t stateCallback;
53	60	client_callback_container_t responseCallback;
54	61
55		extern char *optarg;
56		extern int optind;
	62	dsidType dSIDBroadcast = { 0xff, };
	63	dsidType dSIDNull = { 0, };
57	64
58		dsidType dSIDBroadcast;
59
60	65	typedef struct _dS485RXCommand {
61		uint8_t command;
62		uint8_t length;
63		dS485TransportFrame pFrame;
64		} dS485RXCommand;
	66	uint8_t command;
	67	uint8_t length;
	68	dS485Container apiData;
	69	} __attribute__ ((packed)) dS485RXCommand;
65	70
66	71
67		static int verbose = 0;
	72	static int verbose = 1;
68	73	static pthread_t rxThread;
69	74
70	75	/* server connection spec */
…	…
81	81	pthread_mutex_t answer_mutex;
82	82	pthread_cond_t answer_threshold_cv;
83	83
	84
	85	//void formatFrame(char pTarget,dS485TransportFrame pFrame);
	86	void formatContainer(char pTarget, dS485Container pMessage);
	87	void formatConnectionItem(char p, connectionItem_t pItem, unsigned char deviceAddress);
	88
	89
84	90	/********************** SOCKET CONNECTION *****************************/
85	91
86	92	int connectsock(const char host, const char service, const char *protocol)
…	…
130	130	if (connect(s, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
131	131	close(s);
132	132	return -5;
133		}
	133	}
134	134
135	135	int opts = fcntl(s, F_GETFL);
136	136	if (opts > 0) {
…	…
159	159	int status = write(fd, data, dlen);
160	160
161	161	if (status == dlen ) {
	162	//printf("wrote %d bytes to socket[%d].\n", status, fd);
162	163	return status;
163	164	}
164	165	else if (status > -1) {
165		printf("short write disconnecting client [%d]\n", fd);
	166	printf("short write disconnecting socket[%d]\n", fd);
166	167	close(fd);
167	168	return 0;
168		} else if (errno == EAGAIN \|\| errno == EINTR) {
169		printf("client[%d] has not written data.\n", fd);
	169	} else if (errno == EAGAIN \|\| errno == EINTR) {
	170	printf("socket[%d] write failed, no data sent.\n", fd);
170	171	return 0;
171	172	}
172	173	else if (errno == EBADF) {
173		printf("client[%d] has vanished.\n", fd);
	174	printf("socket[%d] has vanished.\n", fd);
174	175	}
175	176	else if (errno == EWOULDBLOCK /&& (timestamp() - cl->active) > NOREAD_TIMEOUT/) {
176		printf("client[%d] timed out.\n", fd);
	177	printf("socket[%d] timed out.\n", fd);
177	178	}
178	179	else {
179		printf("client[%d] write: %s\n", fd, strerror(errno));
	180	printf("socket[%d] write: %s\n", fd, strerror(errno));
180	181	}
181		close(fd);
	182	close(fd);
182	183	return status;
183	184	}
184	185
…	…
189	189	static uint32_t rxTotal[MAX_THREADS];
190	190	static uint64_t rxBytes[MAX_THREADS];
191	191
192		static int sysServiceDispatch(uint8_t* data, int dlen,int iSocketIndex)
	192	static int sysServiceDispatch(uint8_t* data, int dlen, int iSocketIndex)
193	193	{
194	194	char oLGMSG[1000];
195	195	dS485Container pContainer;
196	196	dS485dCommand* cmd;
197	197	uint8_t len;
198	198
199		int iWork=1;
200
201	199	cmd = (dS485dCommand *) data;
202	200	len = cmd->length;
203	201
…	…
213	213
214	214	case DS845D_CMD_RX_PACKET:
215	215	{
216		dS485Packet* pPacket = (dS485Packet *) cmd->data;
	216	dS485Container* pData = (dS485Container *) cmd->data;
	217	uint8_t deviceAddress = pData->deviceAddress & 0x3f;
217	218
218	219	rxTotal[iSocketIndex] ++;
219		rxBytes[iSocketIndex] += pPacket->length;
	220	rxBytes[iSocketIndex] += pData->length;
220	221
	222	if (1 \|\| compareDSID(pData->deviceId, dSIDNull)) {
	223	pData->deviceId = connectionItem[iSocketIndex].dSIDExisting[deviceAddress].oDSID;
	224	}
	225
	226	#if 0
	227	if (verbose) {
	228	printf("Empfanges Packet von socket %d, device %d:\n", iSocketIndex, deviceAddress);
	229	formatContainer(oLGMSG, pData);
	230	printf("%s",oLGMSG);
	231	}
	232	#endif
	233
221	234	pthread_mutex_lock(&answer_mutex);
222	235
223		/* Dump to ... to console */
224		//if (verbose) {
225		printf("Empfanges Packet von socket %d:\n",iSocketIndex);
226		formatFrame(oLGMSG,&(pPacket->frame));
227		printf("%s",oLGMSG);
228		//}
229	236
230		if ((pPacket->frame.broadcastflag)\|\|(pPacket->frame.data[0]==0x25)){
	237	#ifdef FEATURE_PACKET_FORWARDING_TO_ALL_SOCKETS
	238	if ((pData->containerFlags & DS485_FLAG_BROADCAST) \|\|
	239	(pData->data[0]==0x25))
	240	{
231	241	if ((pPacket->frame.command==0x09) \|\| (pPacket->frame.command==0x0f))
232	242	{
233	243	if (verbose)
…	…
263	263	sockwrite(connectionItem[jSocketIndex].sockfd, (uint8_t *) &cmdCall, sizeof(dS485RXCommand));
264	264	}
265	265	}
266		if (pPacket->frame.data[0]==0x90)
267		{ // switching Version
268		// 5 = 2
269		// 6 >53
	266	#endif
	267
	268	if (pData->data[0]==0x90)
	269	{ // switching Version, old Api < 2.60, new Api >= 2.60
	270	// Byte 5 Version Major
	271	// Byte 6 Version Minor
270	272	connectionItem[iSocketIndex].sessionState=DSBUS_ACTIVE;
271		int iVersionsID=(pPacket->frame.data[5])*100 + pPacket->frame.data[6];
272		if (iVersionsID<253) {
273		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].state=1;
	273	int iVersionsID=(pData->data[5])*100 + pData->data[6];
	274	if (iVersionsID < 260) {
	275	connectionItem[iSocketIndex].dSIDExisting[deviceAddress].state = API_VERSION_1;
274	276	} else {
275		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].state=2;
	277	connectionItem[iSocketIndex].dSIDExisting[deviceAddress].state = API_VERSION_2;
276	278	}
	279	formatConnectionItem(oLGMSG, &connectionItem[iSocketIndex], deviceAddress);
	280	printf("Received Type Response: %s", oLGMSG);
277	281	}
278		if (pPacket->frame.data[0]==0x91)
	282	if (pData->data[0]==0x91)
279	283	{
280	284	// update internal addressing
281		if (connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].state==1)
	285	if (connectionItem[iSocketIndex].dSIDExisting[deviceAddress].state == API_VERSION_1)
282	286	{
283	287	// old API
284	288	connectionItem[iSocketIndex].sessionState=DSBUS_ACTIVE;
285		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[0]=pPacket->frame.data[1]&0xff;
286		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[1]=pPacket->frame.data[2]&0xff;
287		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[2]=pPacket->frame.data[3]&0xff;
288		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[3]=pPacket->frame.data[4]&0xff;
289		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[4]=pPacket->frame.data[5]&0xff;
290		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[5]=pPacket->frame.data[6]&0xff;
291		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[6]=pPacket->frame.data[7]&0xff;
292		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[7]=pPacket->frame.data[8]&0xff;
293		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[8]=pPacket->frame.data[9]&0xff;
294		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[9]=pPacket->frame.data[10]&0xff;
295		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[10]=pPacket->frame.data[11]&0xff;
296		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[11]=pPacket->frame.data[12]&0xff;
	289	memcpy(&connectionItem[iSocketIndex].dSIDExisting[deviceAddress].oDSID.value[0], &pData->data[1], 12);
297	290	}
298		if (connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].state==2) {
	291	else if (connectionItem[iSocketIndex].dSIDExisting[deviceAddress].state == API_VERSION_2)
	292	{
299	293	// new API
300		if (pPacket->frame.data[3]!=0x35)
	294	if (pData->data[3]!=0x35)
301	295	{
302	296	printf ("-----------------------\nWrong Answer\n--------------------------\n");
303	297	pthread_cond_signal(&answer_threshold_cv);
304	298	pthread_mutex_unlock(&answer_mutex);
305	299	return len;
306	300	}
307
308	301	connectionItem[iSocketIndex].sessionState=DSBUS_ACTIVE;
309		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[0]=pPacket->frame.data[3]&0xff;
310		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[1]=pPacket->frame.data[4]&0xff;
311		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[2]=pPacket->frame.data[5]&0xff;
312		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[3]=pPacket->frame.data[6]&0xff;
313		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[4]=pPacket->frame.data[7]&0xff;
314		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[5]=pPacket->frame.data[8]&0xff;
315		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[6]=pPacket->frame.data[9]&0xff;
316		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[7]=pPacket->frame.data[10]&0xff;
317		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[8]=pPacket->frame.data[11]&0xff;
318		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[9]=pPacket->frame.data[12]&0xff;
319		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[10]=pPacket->frame.data[13]&0xff;
320		connectionItem[iSocketIndex].dSIDExisting[(pPacket->frame.destination)].oDSID.value[11]=pPacket->frame.data[14]&0xff;
	302	memcpy(&connectionItem[iSocketIndex].dSIDExisting[deviceAddress].oDSID.value[0], &pData->data[3], 12);
321	303	}
	304	formatConnectionItem(oLGMSG, &connectionItem[iSocketIndex], deviceAddress);
	305	printf("Received DSID Response: %s", oLGMSG);
322	306	}
323		switch(pPacket->frame.command) {
324		case 0x09:
325		pContainer.containerType=DSTELEGRAM_REQUEST;
326		break;
327		case 0x0a:
328		pContainer.containerType=DSTELEGRAM_RESPONSE;
329		break;
330		case 0x0e:
331		pContainer.containerType=DSTELEGRAM_EVENT;
332		break;
333		}
334		pContainer.length=pPacket->frame.length;
335		int i;
336		for (i=0;i<15;i++)
337		pContainer.data[i]=pPacket->frame.data[i];
338	307
339		pContainer.destination=connectionItem[iSocketIndex].dSIDExisting[pPacket->frame.destination].oDSID;
	308	pContainer = *pData;
	309	pContainer.deviceId = connectionItem[iSocketIndex].dSIDExisting[deviceAddress].oDSID;
340	310
341	311	if (oAnswer.Status==Waiting)
342		if (compareDSID(pContainer.destination,oAnswer.request.destination))
343		if (pContainer.containerType==oAnswer.request.containerType)
344		if (pContainer.data[0]==oAnswer.request.data[0])
	312	if (compareDSID(pContainer.deviceId, oAnswer.request.deviceId))
	313	if (pContainer.containerType == oAnswer.request.containerType)
	314	if (pContainer.data[0] == oAnswer.request.data[0])
345	315	{
346		oAnswer.answer=pContainer;
347		oAnswer.Status=Received;
	316	oAnswer.answer = pContainer;
	317	oAnswer.Status = Received;
348	318	pthread_cond_signal(&answer_threshold_cv);
349	319	}
350	320
351	321
352	322	/* Calling Callbacks */
353	323	if (responseCallback) {
354		responseCallback(iSocketIndex,pContainer);
	324	responseCallback(iSocketIndex, pContainer);
355	325	}
356	326
357	327
…	…
360	360	int rval;
361	361	int rxLen = 0;
362	362
363		#define RXBUFLEN 300
	363	#define RXBUFLEN 1024
364	364	uint8_t* rxBuffer = (uint8_t *) malloc(RXBUFLEN);
365	365	uint8_t* p;
366	366	/*
…	…
370	370	iSocketIndex=iIndex;
371	371	}
372	372	*/
373		printf("Receive thread started.\n");
374	373	while (mainActive) {
375	374
376	375	for (iSocketIndex=0;iSocketIndex<MAX_THREADS;iSocketIndex++)
…	…
399	399	}
400	400	else {
401	401	if (FD_ISSET(connectionItem[iSocketIndex].sockfd, &rfds)) {
402		if (verbose) printf("Readausfuehren: %d ",connectionItem[iSocketIndex].sockfd);
403	402	rval = read(connectionItem[iSocketIndex].sockfd, rxBuffer + rxLen, RXBUFLEN - rxLen);
404		if (verbose) printf("gelesen rxLen %d, rval %d \n",rxLen,rval);
405	403	if (rval < 0) {
406	404	if (verbose) printf("client socket read error %d [%d]\n", rval, connectionItem[iSocketIndex].sockfd);
407	405	continue;
…	…
407	407	else if (rval == 0) {
408	408	if (verbose) printf("client socket closed by server [%d]\n", connectionItem[iSocketIndex].sockfd);
409	409	shutdown(connectionItem[iSocketIndex].sockfd, 2);
	410
	411	// TODO: handle reconnect ...
	412
410	413	break;
411	414	}
412	415
413	416	rxLen += rval;
414		if (verbose) printf("sockfd %d, rx %d bytes\n", connectionItem[iSocketIndex].sockfd, rval);
	417	//if (verbose) printf("sockfd %d, rx %d bytes, total %d\n", connectionItem[iSocketIndex].sockfd, rval, rxLen);
415	418
416	419	p = rxBuffer;
417	420	while (rxLen >= 2) {
…	…
450	450	}
451	451
452	452	free(rxBuffer);
453		printf("Receive thread terminated.\n");
454
455		mainActive = 0;
456	453	return NULL;
457	454	}
458	455
459
460		/*
461		void sendMessageToSocket (dS485Container pFrame)
462		{
463		dS485RXCommand cmdCall;
464		char oLGMSG[1000];
465		int iSocketIndex;
466		int i,j;
467
468		cmdCall.command = DS845D_CMD_TX_PACKET;
469		cmdCall.length = sizeof(dS485RXCommand);
470		cmdCall.pFrame.typeflag=0;
471		cmdCall.pFrame.command=pFrame.command;
472		cmdCall.pFrame.broadcastflag=0;
473		for (i=0;i<15;i++)
474		cmdCall.pFrame.data[i]=pFrame.data.plaindata[i];
475		cmdCall.pFrame.length=(pFrame.length*2)+1;
476
477		if (pFrame.broadcastflag)
478		{
479		for (iSocketIndex=0;iSocketIndex<MAX_THREADS;iSocketIndex++)
480		if (connectionItem[iSocketIndex].sockfd) {
481		cmdCall.pFrame.broadcastflag=1;
482		cmdCall.pFrame.destination=0;
483
484		if (verbose) {
485		printf("Sende Packet to socket %d(%x):\n",iSocketIndex, connectionItem[iSocketIndex].sockfd);
486		formatFrame(oLGMSG,&cmdCall.pFrame);
487		printf("%s",oLGMSG);
488		}
489		sockwrite(connectionItem[iSocketIndex].sockfd, (uint8_t *) &cmdCall, sizeof(dS485RXCommand));
490		}
491		return;
492		}
493
494		int iSearchIndex=-1;
495
496		for (j=0;j<MAX_THREADS;j++)
497		if (connectionItem[j].sessionState==DSBUS_ACTIVE)
498		for (i=0;i<64;i++)
499		if (connectionItem[j].dSIDExisting[i].state)
500		if (compareDSID(connectionItem[j].dSIDExisting[i].oDSID,pFrame.destination)) {
501		iSearchIndex=i;
502		iSocketIndex=j;
503		}
504
505		if (iSearchIndex!=-1) {
506		cmdCall.pFrame.destination=iSearchIndex;
507
508		if (verbose) {
509		printf("Sende Packet to socket %d(%x):\n",iSocketIndex, connectionItem[iSocketIndex].sockfd);
510		formatFrame(oLGMSG,&cmdCall.pFrame);
511		printf("%s",oLGMSG);
512		}
513		sockwrite(sockfd[iSocketIndex], (uint8_t *) &cmdCall, sizeof(dS485RXCommand));
514		}
515		}
516		*/
517	456	void setVerbose(int iVerbose)
518	457	{
519	458	verbose=iVerbose;
…	…
503	503	printf("use Socket #%d\n",iNewThread);
504	504
505	505	oAnswer.Status=notWaiting;
506		verbose=iVerbose;
507	506
508
509	507	connectionItem[iNewThread].dProtocol = strdup(pProtokol);
510	508	connectionItem[iNewThread].dHostname = strdup(pHostname);
511	509	connectionItem[iNewThread].dPort = strdup(pPort);
	510	connectionItem[iNewThread].sessionState = DSBUS_ISOLATED;
512	511
513		connectionItem[iNewThread].sessionState=DSBUS_ISOLATED;
514
515	512	/*
516	513	* Connect to server socket
517	514	*/
518	515	connectionItem[iNewThread].sockfd = connectsock(connectionItem[iNewThread].dHostname, connectionItem[iNewThread].dPort, connectionItem[iNewThread].dProtocol);
519	516	if (connectionItem[iNewThread].sockfd < 0) {
520	517	connectionItem[iNewThread].sockfd=0;
521		connectionItem[iNewThread].sessionState=DSBUS_INACTIVE;
522
	518	connectionItem[iNewThread].sessionState = DSBUS_INACTIVE;
523	519	return &mainActive;
524		} else
525		if (verbose) {
	520	} else if (verbose) {
526	521	printf("get SocketNumber #%d(%x) \n",iNewThread,connectionItem[iNewThread].sockfd);
527	522	}
528	523
529	524	rxTotal[iNewThread]=0;
530	525	rxBytes[iNewThread]=0;
	526
531	527	/*
532	528	* Set connection options
533	529	*/
534	530	dS485dCommand cmd;
535
536		cmd.command = DS845D_CMD_RAWMODE;
537		cmd.length = 3;
538		cmd.data[0] = 1;
539		rval = sockwrite(connectionItem[iNewThread].sockfd, (uint8_t *) &cmd, sizeof(dS485dCommand));
540
541	531	cmd.command = DS845D_CMD_PACKETFILTER;
542	532	cmd.length = 3;
543	533	cmd.data[0] = DS485_FILTER_STANDARD;
544	534	rval = sockwrite(connectionItem[iNewThread].sockfd, (uint8_t *) &cmd, sizeof(dS485dCommand));
	535
545	536	/*
546	537	* Start receiver thread
547	538	*/
548	539	if (!preInitDone)
549		if (pthread_create(&rxThread, NULL, sysRxThread,NULL)) {
550		}
	540	if (pthread_create(&rxThread, NULL, sysRxThread,NULL)) {
	541	}
551	542	preInitDone=1;
552	543
553	544	dS485Container pFrame;
554		pFrame.containerType=DSTELEGRAM_REQUEST;
	545	pFrame.containerType=DS485_CONTAINER_REQUEST;
555	546	pFrame.data[0]=0x90;
556	547	pFrame.length=1;
557		pFrame.destination=dSIDBroadcast;
	548	pFrame.deviceId=dSIDBroadcast;
558	549	ds485_client_send_command(&pFrame);
559	550
560	551	dS485Container pFrame2;
561		pFrame2.containerType=DSTELEGRAM_REQUEST;
	552	pFrame2.containerType=DS485_CONTAINER_REQUEST;
562	553	pFrame2.data[0]=0x91;
563	554	pFrame2.length=1;
564		pFrame2.destination=dSIDBroadcast;
	555	pFrame2.deviceId=dSIDBroadcast;
565	556	ds485_client_send_command(&pFrame2);
	557
566	558	return &mainActive;
567	559	}
568	560
…	…
573	573
574	574	return;
575	575	}
576		/*
577	576
578		dsidType DeviceForIndex(int iIndex)
579		{
580		int i;
581		dsidType nulldSID;
582		nulldSID.value[0]=0;
583		nulldSID.value[1]=0;
584		nulldSID.value[2]=0;
585		nulldSID.value[3]=0;
586		nulldSID.value[4]=0;
587		nulldSID.value[5]=0;
588		nulldSID.value[6]=0;
589		nulldSID.value[7]=0;
590		nulldSID.value[8]=0;
591		nulldSID.value[9]=0;
592		nulldSID.value[10]=0;
593		nulldSID.value[11]=0;
594		for (j=0;j<MAX_THREADS;j++)
595		for (i=0;i<64;i++)
596		if (connectionItem[j].sessionState==DSBUS_ACTIVE)
597		if (connectionItem[j].dSIDExisting[i].state) {
598		if (iIndex==0)
599		return connectionItem[j].dSIDExisting[i].oDSID;
600		else
601		iIndex--;
602		}
603		return nulldSID;
604		}
605		*/
606		/*dS485Container synchronizedCall(dS485Container pFrame){
607
608		dS485Container pFrameResult;
609
610		pthread_mutex_lock(&answer_mutex);
611
612		if (!pFrame.broadcastflag) {
613		oAnswer.Status=Waiting;
614		oAnswer.request=pFrame;
615		}
616		oAnswer.request.command=0x0a;
617		sendMessageToSocket(pFrame);
618
619		if (!pFrame.broadcastflag) {
620		struct timespec ts;
621		struct timeval now;
622		gettimeofday(&now,NULL);
623		ts.tv_sec = now.tv_sec +dSMAPI_CALL_TIMEOUT_SEKUNDEN;
624		ts.tv_nsec = now.tv_usec * 1000;
625
626		pthread_cond_timedwait(&answer_threshold_cv, &answer_mutex,&ts);
627		if (oAnswer.Status==Received)
628		{
629		pFrameResult=oAnswer.answer;
630		} else {
631		pFrameResult.msgid=0xff;
632		}
633		oAnswer.Status=notWaiting;
634		} else
635		pFrameResult.msgid=0xfe;
636
637		pthread_mutex_unlock(&answer_mutex);
638		return pFrameResult;
639		}
640		*/
	577	#if 0
641	578	void formatFrame(char pTarget,dS485TransportFrame pMessage)
642	579	{
643	580	char *pChar=pTarget;
…	…
591	591	pChar+=sprintf(pChar,"param7 : %.2x%.2x ",pMessage->data[14],pMessage->data[13]);
592	592	pChar+=sprintf(pChar,"length : %.2d\r\n",(pMessage->length-1)/2);
593	593	}
	594	#endif
594	595
595		void formatContainer(char pTarget,dS485Container pMessage)
	596	void formatContainer(char pTarget, dS485Container pMessage)
596	597	{
597		char *pChar=pTarget;
598		pChar+=sprintf(pChar," Type : %.1x ",pMessage->containerType);
599		pChar+=sprintf(pChar," addr : %.2x%.2x ",pMessage->destination.value[10],pMessage->destination.value[11]);
600		pChar+=sprintf(pChar," msgId : %.2x\r\n",pMessage->data[0]);
601		pChar+=sprintf(pChar,"param1 : %.2x%.2x ",pMessage->data[2],pMessage->data[1]);
602		pChar+=sprintf(pChar,"param2 : %.2x%.2x ",pMessage->data[4],pMessage->data[3]);
603		pChar+=sprintf(pChar,"param3 : %.2x%.2x ",pMessage->data[6],pMessage->data[5]);
604		pChar+=sprintf(pChar,"param4 : %.2x%.2x\r\n" ,pMessage->data[8],pMessage->data[7]);
605		pChar+=sprintf(pChar,"param5 : %.2x%.2x ",pMessage->data[10],pMessage->data[9]);
606		pChar+=sprintf(pChar,"param6 : %.2x%.2x ",pMessage->data[12],pMessage->data[11]);
607		pChar+=sprintf(pChar,"param7 : %.2x%.2x ",pMessage->data[14],pMessage->data[13]);
608		pChar+=sprintf(pChar,"length : %.2d\r\n",(pMessage->length-1)/2);
	598	char *pChar = pTarget;
	599	unsigned char n;
	600
	601	pChar+=sprintf(pChar," Type : %.1x ", pMessage->containerType);
	602	pChar+=sprintf(pChar," Flags : %.1x ", pMessage->containerFlags);
	603	pChar+=sprintf(pChar," msgId : %.2x ", pMessage->data[0]);
	604	pChar+=sprintf(pChar," addr : %d/", pMessage->deviceAddress);
	605	for (n = 0; n < 12; n ++)
	606	pChar += sprintf(pChar, "%02x", pMessage->deviceId.value[n]);
	607	pChar+=sprintf(pChar,"\n");
	608	pChar+=sprintf(pChar,"param1 : %.2x%.2x ", pMessage->data[2],pMessage->data[1]);
	609	pChar+=sprintf(pChar,"param2 : %.2x%.2x ", pMessage->data[4],pMessage->data[3]);
	610	pChar+=sprintf(pChar,"param3 : %.2x%.2x ", pMessage->data[6],pMessage->data[5]);
	611	pChar+=sprintf(pChar,"param4 : %.2x%.2x\r\n", pMessage->data[8],pMessage->data[7]);
	612	pChar+=sprintf(pChar,"param5 : %.2x%.2x ", pMessage->data[10],pMessage->data[9]);
	613	pChar+=sprintf(pChar,"param6 : %.2x%.2x ", pMessage->data[12],pMessage->data[11]);
	614	pChar+=sprintf(pChar,"param7 : %.2x%.2x ", pMessage->data[14],pMessage->data[13]);
	615	pChar+=sprintf(pChar,"length : %d\r\n", pMessage->length);
609	616	}
610	617
	618	void formatConnectionItem(char p, connectionItem_t pItem, unsigned char deviceAddress)
	619	{
	620	unsigned char n;
	621	p += sprintf(p, "Device: addr: %d/", deviceAddress);
	622	for (n = 0; n < 12; n ++)
	623	p += sprintf(p, "%02x", pItem->dSIDExisting[deviceAddress].oDSID.value[n]);
	624	p += sprintf(p, ", state:%d\n", pItem->dSIDExisting[deviceAddress].state);
	625	}
611	626
612	627	/////////////////////////////////////////////////////////////////////////////
613	628
…	…
649	649	token = strtok(NULL, ":");
650	650	if (token) pTempPort = token;
651	651
652		init(pTempPort,pTempHost,pTempPort,0);
	652	init(pTempPort, pTempHost, pTempPort, 1);
653	653	}
654	654
655	655	/**
…	…
735	735	int ds485_client_send_command(dS485Container *pCommand)
736	736	{
737	737	dS485RXCommand cmdCall;
	738	unsigned int cmdLength;
738	739	char oLGMSG[1000];
739	740	int iSocketIndex;
740	741	int i,j;
741	742
742		cmdCall.command = DS845D_CMD_TX_PACKET;
743		cmdCall.length = sizeof(dS485RXCommand);
744		cmdCall.pFrame.typeflag=0;
745		switch(pCommand->containerType)
746		{
747		case DSTELEGRAM_REQUEST:
748		cmdCall.pFrame.command=0x09;
749		break;
750		case DSTELEGRAM_RESPONSE:
751		cmdCall.pFrame.command=0x0a;
752		break;
753		case DSTELEGRAM_EVENT:
754		cmdCall.pFrame.command=0x0e;
755		break;
756		}
757		cmdCall.pFrame.broadcastflag=0;
758		for (i=0;i<15;i++)
759		cmdCall.pFrame.data[i]=pCommand->data[i];
760		cmdCall.pFrame.length=pCommand->length;
	743	memset(&cmdCall, 0, sizeof(dS485RXCommand));
761	744
762		if (compareDSID(pCommand->destination,dSIDBroadcast))
	745	cmdCall.apiData.deviceAddress = pCommand->deviceAddress;
	746	cmdCall.apiData.deviceId = pCommand->deviceId;
	747	cmdCall.apiData.containerType = pCommand->containerType;
	748	cmdCall.apiData.containerFlags = DS485_FLAG_NONE;
	749	cmdCall.apiData.length = pCommand->length;
	750	memcpy(&cmdCall.apiData.data, pCommand->data, cmdCall.apiData.length);
	751
	752	cmdLength = DS485_CONTAINER_SIZE + cmdCall.apiData.length + 2;
	753
	754	cmdCall.length = cmdLength;
	755	cmdCall.command = DS845D_CMD_TX_PACKET;
	756
	757	if (compareDSID(pCommand->deviceId, dSIDBroadcast))
763	758	{
764		for (iSocketIndex=0;iSocketIndex<MAX_THREADS;iSocketIndex++)
765		if (connectionItem[iSocketIndex].sockfd) {
766		cmdCall.pFrame.broadcastflag=1;
767		cmdCall.pFrame.destination=0;
	759	cmdCall.apiData.deviceAddress = 0xff;
	760	cmdCall.apiData.containerFlags \|= DS485_FLAG_BROADCAST;
768	761
769		if (verbose) {
770		printf("Sende Packet to socket %d(%x):\n",iSocketIndex, connectionItem[iSocketIndex].sockfd);
771		formatFrame(oLGMSG,&cmdCall.pFrame);
772		printf("%s",oLGMSG);
773		}
774		sockwrite(connectionItem[iSocketIndex].sockfd, (uint8_t *) &cmdCall, sizeof(dS485RXCommand));
	762	#if 0
	763	if (verbose) {
	764	printf("ds485_client_send_command:\n");
	765	formatContainer(oLGMSG, &cmdCall.apiData);
	766	printf("%s",oLGMSG);
	767	}
	768	#endif
	769
	770	for (iSocketIndex=0;iSocketIndex<MAX_THREADS;iSocketIndex++)
	771	if (connectionItem[iSocketIndex].sockfd) {
	772	sockwrite(connectionItem[iSocketIndex].sockfd, (uint8_t *) &cmdCall, cmdLength);
775	773	}
776	774	return 0;
777	775	}
778	776
779	777	int iSearchIndex=-1;
780
781	778	for (j=0;j<MAX_THREADS;j++)
782	779	if (connectionItem[j].sessionState==DSBUS_ACTIVE)
783	780	for (i=0;i<64;i++)
784	781	if (connectionItem[j].dSIDExisting[i].state) {
785		if (compareDSID(connectionItem[j].dSIDExisting[i].oDSID,pCommand->destination)) {
	782	if (compareDSID(connectionItem[j].dSIDExisting[i].oDSID, pCommand->deviceId)) {
786	783	iSearchIndex=i;
787	784	iSocketIndex=j;
788
789	785	}
790	786	}
791	787
792	788	if (iSearchIndex!=-1) {
793		cmdCall.pFrame.destination=iSearchIndex;
	789	cmdCall.apiData.deviceAddress = iSearchIndex;
	790	cmdCall.apiData.deviceId = connectionItem[j].dSIDExisting[iSearchIndex].oDSID;
794	791
795		if (verbose) {
796		printf("Sende Packet to socket %d(%x):\n",iSocketIndex, connectionItem[iSocketIndex].sockfd);
797		formatFrame(oLGMSG,&cmdCall.pFrame);
798		printf("%s",oLGMSG);
799		}
800		sockwrite(connectionItem[iSocketIndex].sockfd, (uint8_t *) &cmdCall, sizeof(dS485RXCommand));
	792	#if 0
	793	if (verbose) {
	794	printf("ds485_client_send_command:\n");
	795	formatContainer(oLGMSG, &cmdCall.apiData);
	796	printf("%s",oLGMSG);
	797	}
	798	#endif
	799
	800	if (connectionItem[iSocketIndex].sockfd) {
	801	sockwrite(connectionItem[iSocketIndex].sockfd, (uint8_t *) &cmdCall, cmdLength);
	802	}
801	803	return 0;
802	804	}
803	805
	806	printf("ds485_client_send: id not found\n");
804	807	return -1;
805	808	}
806	809
…	…
812	812	*/
813	813	int ds485_client_send_sync_command(dS485Container pCommand, dS485Container pResponse)
814	814	{
815		int result;
	815	int result, rval;
816	816	pthread_mutex_lock(&answer_mutex);
817	817
818	818	pResponse->data[1]=0xff;
819	819	pResponse->data[2]=0xff;
820	820
821		if (!(compareDSID(pCommand->destination,dSIDBroadcast))) {
822		oAnswer.Status=Waiting;
823		oAnswer.request=*pCommand;
	821	if (!(compareDSID(pCommand->deviceId,dSIDBroadcast))) {
	822	oAnswer.Status = Waiting;
	823	oAnswer.request = *pCommand;
824	824	}
825		oAnswer.request.containerType=DSTELEGRAM_RESPONSE;
	825	oAnswer.request.containerType = DS485_CONTAINER_RESPONSE;
	826
826	827	result=ds485_client_send_command(pCommand);
827		if (result==0)
828		if (!(compareDSID(pCommand->destination,dSIDBroadcast))) {
	828	if (result==0) {
	829	if (!(compareDSID(pCommand->deviceId,dSIDBroadcast))) {
829	830	struct timespec ts;
830	831	struct timeval now;
831	832	gettimeofday(&now,NULL);
…	…
834	834	ts.tv_nsec = now.tv_usec * 1000;
835	835	result=0;
836	836
837		pthread_cond_timedwait(&answer_threshold_cv, &answer_mutex,&ts);
838		if (oAnswer.Status==Received)
839		{
840		*pResponse=oAnswer.answer;
841		} else {
842		result=-1;
843		}
	837	while (oAnswer.Status != Received) {
	838	rval = pthread_cond_timedwait(&answer_threshold_cv, &answer_mutex,&ts);
	839	if (oAnswer.Status == Received)
	840	{
	841	*pResponse=oAnswer.answer;
	842	break;
	843	} else {
	844	result = -1;
	845	}
	846	}
844	847	oAnswer.Status=notWaiting;
845		} else
	848	} else {
846	849	result=-2;
	850	}
	851	}
847	852
848	853	pthread_mutex_unlock(&answer_mutex);
849	854	return result;


14	14	void deinit() ;
15	15	void setVerbose(int iVerbose);
16	16
17		void formatFrame(char pTarget,dS485TransportFrame pFrame);
18		void formatContainer(char pTarget,dS485Container pMessage);
19
20	17	#ifdef __cplusplus
21	18	}
22	19	#endif


28	28	extern pthread_cond_t answer_threshold_cv;
29	29
30	30
31		#define setPara(dSFrame, ParameterNummer, Value) dSFrame.data[(((ParameterNummer)-1)2)+1]=Value&0xff; dSFrame.data[(((ParameterNummer)-1)2)+2]=(Value>>8)&0xff
32		#define setParaCount(dSFrame, ParameterCount) dSFrame.length=1+(ParameterCount*2)
33		#define getPara(dSFrame, ParameterNummer) (dSFrame.data[((ParameterNummer-1)2)+1] \| ((dSFrame.data[((ParameterNummer-1)2)+2]<<8)&0xff00))
	31	//#define setPara(dSFrame, ParameterNummer, Value) dSFrame.data[(((ParameterNummer)-1)2)+1]=Value&0xff; dSFrame.data[(((ParameterNummer)-1)2)+2]=(Value>>8)&0xff
	32	//#define setParaCount(dSFrame, ParameterCount) dSFrame.length=1+(ParameterCount*2)
	33	//#define getPara(dSFrame, ParameterNummer) (dSFrame.data[((ParameterNummer-1)2)+1] \| ((dSFrame.data[((ParameterNummer-1)2)+2]<<8)&0xff00))
34	34
	35	#define setPara16(dSFrame, ParameterNummer, Value) { uint16_t obj = (uint16_t ) & (dSFrame.data[1+((ParameterNummer)-1)2]); obj = (Value); }
	36	#define getPara16(dSFrame, ParameterNummer) ( (uint16_t ) & (dSFrame.data[1+((ParameterNummer)-1)*2]))
35	37
36	38	long dSMAPI_addRoom(dsidType dSMdSID, unsigned int roomId){
37	39	long returnValue;
38	40	dS485Container pFrame,pFrameAnswer;
39	41
40		pFrame.destination=dSMdSID;
41
42		pFrame.containerType=DSTELEGRAM_REQUEST;
	42	pFrame.deviceId=dSMdSID;
	43	pFrame.containerType=DS485_CONTAINER_REQUEST;
43	44	pFrame.data[0]=MAPI_ADD_ROOM;
44		setPara(pFrame,1,roomId);
	45	setPara16(pFrame,1,roomId);
45	46	setParaCount(pFrame,1);
46
47	47	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
48	48
49		returnValue=getPara(pFrameAnswer,1);
50
	49	returnValue=getPara16(pFrameAnswer,1);
51	50	return returnValue;
52	51	}
53	52
…	…
54	54	long returnValue;
55	55	dS485Container pFrame,pFrameAnswer;
56	56
57		pFrame.destination=dSMdSID;
58
59
60		pFrame.containerType=DSTELEGRAM_REQUEST;
	57	pFrame.deviceId=dSMdSID;
	58	pFrame.containerType=DS485_CONTAINER_REQUEST;
61	59	pFrame.data[0]=MAPI_REM_ROOM;
62		setPara(pFrame,1,roomId);
	60	setPara16(pFrame,1,roomId);
63	61	setParaCount(pFrame,1);
64	62	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
65	63
66		returnValue=getPara(pFrameAnswer,1);
	64	returnValue=getPara16(pFrameAnswer,1);
67	65	return returnValue;
68	66	}
69	67
…	…
69	69	long returnValue;
70	70	dS485Container pFrame,pFrameAnswer;
71	71
72		pFrame.destination=dSMdSID;
73
74
75
76		pFrame.containerType=DSTELEGRAM_REQUEST;
	72	pFrame.deviceId=dSMdSID;
	73	pFrame.containerType=DS485_CONTAINER_REQUEST;
77	74	pFrame.data[0]=MAPI_REM_ALL_ROOMS;
78	75	setParaCount(pFrame,0);
79	76	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
80	77
81		returnValue=getPara(pFrameAnswer,1);
	78	returnValue=getPara16(pFrameAnswer,1);
82	79	return returnValue;
83	80	}
84	81
…	…
83	83	long returnValue;
84	84	dS485Container pFrame,pFrameAnswer;
85	85
86		pFrame.destination=dSMdSID;
87
88
89		pFrame.containerType=DSTELEGRAM_REQUEST;
	86	pFrame.deviceId=dSMdSID;
	87	pFrame.containerType=DS485_CONTAINER_REQUEST;
90	88	pFrame.data[0]=MAPI_GET_GROUP_COUNT;
91		setPara(pFrame,1,roomId);
	89	setPara16(pFrame,1,roomId);
92	90	setParaCount(pFrame,1);
93	91	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
94	92
95		returnValue=getPara(pFrameAnswer,1);
	93	returnValue=getPara16(pFrameAnswer,1);
96	94	return returnValue;
97	95	}
98	96
…	…
98	98	long returnValue;
99	99	dS485Container pFrame,pFrameAnswer;
100	100
101		pFrame.destination=dSMdSID;
102
103
104		pFrame.containerType=DSTELEGRAM_REQUEST;
	101	pFrame.deviceId=dSMdSID;
	102	pFrame.containerType=DS485_CONTAINER_REQUEST;
105	103	pFrame.data[0]=MAPI_GET_GROUP_ID_IN_ROOM;
106		setPara(pFrame,1,roomID);
107		setPara(pFrame,2,groupIndex);
	104	setPara16(pFrame,1,roomID);
	105	setPara16(pFrame,2,groupIndex);
108	106	setParaCount(pFrame,2);
109	107	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
110	108
111		returnValue=getPara(pFrameAnswer,1);
112		*grType =getPara(pFrameAnswer,2);
	109	returnValue = getPara16(pFrameAnswer,1);
	110	*grType = getPara16(pFrameAnswer,2);
113	111	return returnValue;
114	112	}
115	113
…	…
115	115	long returnValue;
116	116	dS485Container pFrame,pFrameAnswer;
117	117
118		pFrame.destination=dSMdSID;
119
120
121		pFrame.containerType=DSTELEGRAM_REQUEST;
	118	pFrame.deviceId=dSMdSID;
	119	pFrame.containerType=DS485_CONTAINER_REQUEST;
122	120	pFrame.data[0]=MAPI_GET_DEVICE_COUNT;
123		setPara(pFrame,1,roomId);
	121	setPara16(pFrame,1,roomId);
124	122	setParaCount(pFrame,1);
125
126	123	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
127	124
128		returnValue=getPara(pFrameAnswer,1);
	125	returnValue=getPara16(pFrameAnswer,1);
129	126	return returnValue;
130	127	}
131	128
…	…
130	130	long returnValue;
131	131	dS485Container pFrame,pFrameAnswer;
132	132
133		pFrame.destination=dSMdSID;
134
135
136		pFrame.containerType=DSTELEGRAM_REQUEST;
	133	pFrame.deviceId=dSMdSID;
	134	pFrame.containerType=DS485_CONTAINER_REQUEST;
137	135	pFrame.data[0]=MAPI_GET_DEVICE_ADDRESS;
138		setPara(pFrame,1,roomId);
139		setPara(pFrame,2,devIndex);
	136	setPara16(pFrame,1,roomId);
	137	setPara16(pFrame,2,devIndex);
140	138	setParaCount(pFrame,2);
141
142	139	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
143	140
144		returnValue=getPara(pFrameAnswer,1);
	141	returnValue=getPara16(pFrameAnswer,1);
145	142	return returnValue;
146	143	}
147	144
…	…
146	146	long returnValue;
147	147	dS485Container pFrame,pFrameAnswer;
148	148
149		pFrame.destination=dSMdSID;
150
151
152		pFrame.containerType=DSTELEGRAM_REQUEST;
	149	pFrame.deviceId=dSMdSID;
	150	pFrame.containerType=DS485_CONTAINER_REQUEST;
153	151	pFrame.data[0]=MAPI_GET_ROOM_COUNT;
154	152	setParaCount(pFrame,0);
155
156	153	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
157	154
158		returnValue=getPara(pFrameAnswer,1);
	155	returnValue = getPara16(pFrameAnswer,1);
	156	printf("Device has %d rooms\n", returnValue);
159	157	return returnValue;
160	158	}
161	159
…	…
162	162	long returnValue;
163	163	dS485Container pFrame,pFrameAnswer;
164	164
165		pFrame.destination=dSMdSID;
166
167
168		pFrame.containerType=DSTELEGRAM_REQUEST;
	165	pFrame.deviceId=dSMdSID;
	166	pFrame.containerType=DS485_CONTAINER_REQUEST;
169	167	pFrame.data[0]=MAPI_GET_ROOM_ID;
170	168	setParaCount(pFrame,1);
171		setPara(pFrame,1,index);
	169	setPara16(pFrame,1,index);
172	170	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
173	171
174
175		returnValue=getPara(pFrameAnswer,1);
	172	returnValue=getPara16(pFrameAnswer,1);
176	173	return returnValue;
177	174	}
178	175
…	…
177	177	long returnValue;
178	178	dS485Container pFrame,pFrameAnswer;
179	179
180		pFrame.destination=dSMdSID;
181
182
183		pFrame.containerType=DSTELEGRAM_REQUEST;
	180	pFrame.deviceId=dSMdSID;
	181	pFrame.containerType=DS485_CONTAINER_REQUEST;
184	182	pFrame.data[0]=MAPI_GET_GROUP_DEVICE_COUNT;
185	183	setParaCount(pFrame,2);
186	184	setPara(pFrame,1,roomId);
…	…
193	193	long returnValue;
194	194	dS485Container pFrame,pFrameAnswer;
195	195
196		pFrame.destination=dSMdSID;
197
198
199		pFrame.containerType=DSTELEGRAM_REQUEST;
	196	pFrame.deviceId=dSMdSID;
	197	pFrame.containerType=DS485_CONTAINER_REQUEST;
200	198	pFrame.data[0]=MAPI_GET_GROUP_DEVICE_ADDRESS;
201	199	setParaCount(pFrame,3);
202	200	setPara(pFrame,1,roomId);
…	…
210	210	long returnValue;
211	211	dS485Container pFrame,pFrameAnswer;
212	212
213		pFrame.destination=dSMdSID;
214
215
216		pFrame.containerType=DSTELEGRAM_REQUEST;
	213	pFrame.deviceId=dSMdSID;
	214	pFrame.containerType=DS485_CONTAINER_REQUEST;
217	215	pFrame.data[0]=MAPI_ADD_USER_GROUP;
218	216	setParaCount(pFrame,2);
219	217	setPara(pFrame,1,roomId);
…	…
228	228	long returnValue;
229	229	dS485Container pFrame,pFrameAnswer;
230	230
231		pFrame.destination=dSMdSID;
232
233
234		pFrame.containerType=DSTELEGRAM_REQUEST;
	231	pFrame.deviceId=dSMdSID;
	232	pFrame.containerType=DS485_CONTAINER_REQUEST;
235	233	pFrame.data[0]=MAPI_REM_USER_GROUP;
236	234	setParaCount(pFrame,2);
237	235	setPara(pFrame,1,roomId);
…	…
245	245	long returnValue;
246	246	dS485Container pFrame,pFrameAnswer;
247	247
248		pFrame.destination=dSMdSID;
249
250
251		pFrame.containerType=DSTELEGRAM_REQUEST;
	248	pFrame.deviceId=dSMdSID;
	249	pFrame.containerType=DS485_CONTAINER_REQUEST;
252	250	pFrame.data[0]=MAPI_REM_ALL_USER_GROUPS;
253	251	setParaCount(pFrame,1);
254	252	setPara(pFrame,1,roomId);
…	…
263	263	long returnValue;
264	264	dS485Container pFrame,pFrameAnswer;
265	265
266		pFrame.destination=dSMdSID;
267
268
269		pFrame.containerType=DSTELEGRAM_REQUEST;
	266	pFrame.deviceId=dSMdSID;
	267	pFrame.containerType=DS485_CONTAINER_REQUEST;
270	268	pFrame.data[0]=MAPI_GET_GROUP_LAST_SCENE;
271	269	setParaCount(pFrame,2);
272	270	setPara(pFrame,1,roomId);
…	…
280	280	long returnValue;
281	281	dS485Container pFrame,pFrameAnswer;
282	282
283		pFrame.destination=dSMdSID;
284
285
286		pFrame.containerType=DSTELEGRAM_REQUEST;
	283	pFrame.deviceId=dSMdSID;
	284	pFrame.containerType=DS485_CONTAINER_REQUEST;
287	285	pFrame.data[0]=MAPI_INC_GROUP_VALUE;
288	286	setParaCount(pFrame,2);
289	287	setPara(pFrame,1,roomId);
…	…
297	297	long returnValue;
298	298	dS485Container pFrame,pFrameAnswer;
299	299
300		pFrame.destination=dSMdSID;
301
302
303		pFrame.containerType=DSTELEGRAM_REQUEST;
	300	pFrame.deviceId=dSMdSID;
	301	pFrame.containerType=DS485_CONTAINER_REQUEST;
304	302	pFrame.data[0]=MAPI_DEC_GROUP_VALUE;
305	303	setParaCount(pFrame,2);
306	304	setPara(pFrame,1,roomId);
…	…
314	314	long returnValue;
315	315	dS485Container pFrame,pFrameAnswer;
316	316
317		pFrame.destination=dSMdSID;
318
319
320		pFrame.containerType=DSTELEGRAM_REQUEST;
	317	pFrame.deviceId=dSMdSID;
	318	pFrame.containerType=DS485_CONTAINER_REQUEST;
321	319	pFrame.data[0]=MAPI_INC_STARTDIM_GROUP;
322	320	setParaCount(pFrame,2);
323	321	setPara(pFrame,1,roomId);
…	…
331	331	long returnValue;
332	332	dS485Container pFrame,pFrameAnswer;
333	333
334		pFrame.destination=dSMdSID;
335
336
337		pFrame.containerType=DSTELEGRAM_REQUEST;
	334	pFrame.deviceId=dSMdSID;
	335	pFrame.containerType=DS485_CONTAINER_REQUEST;
338	336	pFrame.data[0]=MAPI_DEC_STARTDIM_GROUP;
339	337	setParaCount(pFrame,2);
340	338	setPara(pFrame,1,roomId);
…	…
348	348	long returnValue;
349	349	dS485Container pFrame,pFrameAnswer;
350	350
351		pFrame.destination=dSMdSID;
352
353
354		pFrame.containerType=DSTELEGRAM_REQUEST;
	351	pFrame.deviceId=dSMdSID;
	352	pFrame.containerType=DS485_CONTAINER_REQUEST;
355	353	pFrame.data[0]=MAPI_STOPDIM_GROUP;
356	354	setParaCount(pFrame,2);
357	355	setPara(pFrame,1,roomId);
…	…
365	365	long returnValue;
366	366	dS485Container pFrame,pFrameAnswer;
367	367
368		pFrame.destination=dSMdSID;
369
370
371		pFrame.containerType=DSTELEGRAM_REQUEST;
	368	pFrame.deviceId=dSMdSID;
	369	pFrame.containerType=DS485_CONTAINER_REQUEST;
372	370	pFrame.data[0]=MAPI_CALL_SCENE_GROUP;
373	371	setParaCount(pFrame,3);
374	372	setPara(pFrame,1,roomId);
…	…
384	384	long returnValue;
385	385	dS485Container pFrame,pFrameAnswer;
386	386
387		pFrame.destination=dSMdSID;
388
389
390		pFrame.containerType=DSTELEGRAM_REQUEST;
	387	pFrame.deviceId=dSMdSID;
	388	pFrame.containerType=DS485_CONTAINER_REQUEST;
391	389	pFrame.data[0]=MAPI_SAVE_SCENE_GROUP;
392	390	setParaCount(pFrame,3);
393	391	setPara(pFrame,1,roomId);
…	…
401	401	long returnValue;
402	402	dS485Container pFrame,pFrameAnswer;
403	403
404		pFrame.destination=dSMdSID;
405
406
407		pFrame.containerType=DSTELEGRAM_REQUEST;
	404	pFrame.deviceId=dSMdSID;
	405	pFrame.containerType=DS485_CONTAINER_REQUEST;
408	406	pFrame.data[0]=MAPI_UNDO_GROUP;
409	407	setParaCount(pFrame,2);
410	408	setPara(pFrame,1,roomId);
…	…
417	417	long returnValue;
418	418	dS485Container pFrame,pFrameAnswer;
419	419
420		pFrame.destination=dSMdSID;
421
422
423		pFrame.containerType=DSTELEGRAM_REQUEST;
	420	pFrame.deviceId=dSMdSID;
	421	pFrame.containerType=DS485_CONTAINER_REQUEST;
424	422	pFrame.data[0]=MAPI_SET_VALUE_GROUP;
425	423	setParaCount(pFrame,3);
426	424	setPara(pFrame,1,roomId);
…	…
435	435	long returnValue;
436	436	dS485Container pFrame,pFrameAnswer;
437	437
438		pFrame.destination=dSMdSID;
439
440
441		pFrame.containerType=DSTELEGRAM_REQUEST;
	438	pFrame.deviceId=dSMdSID;
	439	pFrame.containerType=DS485_CONTAINER_REQUEST;
442	440	pFrame.data[0]=MAPI_IDENTIFY_GROUP;
443	441	setParaCount(pFrame,3);
444	442	setPara(pFrame,1,addressSelection);
…	…
452	452	long returnValue;
453	453	dS485Container pFrame,pFrameAnswer;
454	454
455		pFrame.destination=dSMdSID;
456
457
458		pFrame.containerType=DSTELEGRAM_REQUEST;
	455	pFrame.deviceId=dSMdSID;
	456	pFrame.containerType=DS485_CONTAINER_REQUEST;
459	457	pFrame.data[0]=MAPI_REM_FROM_ALL_GROUPS;
460	458	setParaCount(pFrame,1);
461	459	setPara(pFrame,1,deviceAdr);
…	…
467	467	long returnValue;
468	468	dS485Container pFrame,pFrameAnswer;
469	469
470		pFrame.destination=dSMdSID;
471
472
473		pFrame.containerType=DSTELEGRAM_REQUEST;
	470	pFrame.deviceId=dSMdSID;
	471	pFrame.containerType=DS485_CONTAINER_REQUEST;
474	472	pFrame.data[0]=MAPI_ADD_TO_NEW_GROUP;
475	473	setParaCount(pFrame,1);
476	474	setPara(pFrame,1,deviceAdr);
…	…
482	482	long returnValue;
483	483	dS485Container pFrame,pFrameAnswer;
484	484
485		pFrame.destination=dSMdSID;
486
487
488		pFrame.containerType=DSTELEGRAM_REQUEST;
	485	pFrame.deviceId=dSMdSID;
	486	pFrame.containerType=DS485_CONTAINER_REQUEST;
489	487	pFrame.data[0]=MAPI_REM_ALL_DEVS_FR_ROOM;
490	488	setParaCount(pFrame,1);
491	489	setPara(pFrame,1,roomId);
…	…
497	497	long returnValue;
498	498	dS485Container pFrame,pFrameAnswer;
499	499
500		pFrame.destination=dSMdSID;
501
502
503		pFrame.containerType=DSTELEGRAM_REQUEST;
	500	pFrame.deviceId=dSMdSID;
	501	pFrame.containerType=DS485_CONTAINER_REQUEST;
504	502	pFrame.data[0]=MAPI_ADD_TO_GROUP;
505	503	setParaCount(pFrame,2);
506	504	setPara(pFrame,1,deviceAdr);
…	…
513	513	long returnValue;
514	514	dS485Container pFrame,pFrameAnswer;
515	515
516		pFrame.destination=dSMdSID;
517
518
519		pFrame.containerType=DSTELEGRAM_REQUEST;
	516	pFrame.deviceId=dSMdSID;
	517	pFrame.containerType=DS485_CONTAINER_REQUEST;
520	518	pFrame.data[0]=MAPI_REM_FROM_GROUP;
521	519	setParaCount(pFrame,2);
522	520	setPara(pFrame,1,deviceAdr);
…	…
529	529	long returnValue;
530	530	dS485Container pFrame,pFrameAnswer;
531	531
532		pFrame.destination=dSMdSID;
533
534
535		pFrame.containerType=DSTELEGRAM_REQUEST;
	532	pFrame.deviceId=dSMdSID;
	533	pFrame.containerType=DS485_CONTAINER_REQUEST;
536	534	pFrame.data[0]=MAPI_INC_VALUE_DEVICE;
537	535	setParaCount(pFrame,1);
538	536	setPara(pFrame,1,deviceAdr);
…	…
544	544	long returnValue;
545	545	dS485Container pFrame,pFrameAnswer;
546	546
547		pFrame.destination=dSMdSID;
548
549
550		pFrame.containerType=DSTELEGRAM_REQUEST;
	547	pFrame.deviceId=dSMdSID;
	548	pFrame.containerType=DS485_CONTAINER_REQUEST;
551	549	pFrame.data[0]=MAPI_DEC_VALUE_DEVICE;
552	550	setParaCount(pFrame,1);
553	551	setPara(pFrame,1,deviceAdr);
…	…
559	559	long returnValue;
560	560	dS485Container pFrame,pFrameAnswer;
561	561
562		pFrame.destination=dSMdSID;
563
564
565		pFrame.containerType=DSTELEGRAM_REQUEST;
	562	pFrame.deviceId=dSMdSID;
	563	pFrame.containerType=DS485_CONTAINER_REQUEST;
566	564	pFrame.data[0]=MAPI_CALL_SCENE_DEVICE;
567	565	setParaCount(pFrame,2);
568	566	setPara(pFrame,1,deviceAdr);
…	…
579	579	long returnValue;
580	580	dS485Container pFrame,pFrameAnswer;
581	581
582		pFrame.destination=dSMdSID;
583
584
585		pFrame.containerType=DSTELEGRAM_REQUEST;
	582	pFrame.deviceId=dSMdSID;
	583	pFrame.containerType=DS485_CONTAINER_REQUEST;
586	584	pFrame.data[0]=MAPI_SAVE_SCENE_DEVICE;
587	585	setParaCount(pFrame,2);
588	586	setPara(pFrame,1,deviceAdr);
…	…
595	595	long returnValue;
596	596	dS485Container pFrame,pFrameAnswer;
597	597
598		pFrame.destination=dSMdSID;
599
600
601		pFrame.containerType=DSTELEGRAM_REQUEST;
	598	pFrame.deviceId=dSMdSID;
	599	pFrame.containerType=DS485_CONTAINER_REQUEST;
602	600	pFrame.data[0]=MAPI_UNDO_DEVICE;
603	601	setParaCount(pFrame,1);
604	602	setPara(pFrame,1,deviceAdr);
…	…
610	610	long returnValue;
611	611	dS485Container pFrame,pFrameAnswer;
612	612
613		pFrame.destination=dSMdSID;
614
615
616		pFrame.containerType=DSTELEGRAM_REQUEST;
	613	pFrame.deviceId=dSMdSID;
	614	pFrame.containerType=DS485_CONTAINER_REQUEST;
617	615	pFrame.data[0]=MAPI_INC_STARTDIM_DEVICE;
618	616	setParaCount(pFrame,1);
619	617	setPara(pFrame,1,deviceAdr);
…	…
625	625	long returnValue;
626	626	dS485Container pFrame,pFrameAnswer;
627	627
628		pFrame.destination=dSMdSID;
629
630
631		pFrame.containerType=DSTELEGRAM_REQUEST;
	628	pFrame.deviceId=dSMdSID;
	629	pFrame.containerType=DS485_CONTAINER_REQUEST;
632	630	pFrame.data[0]=MAPI_DEC_STARTDIM_DEVICE;
633	631	setParaCount(pFrame,1);
634	632	setPara(pFrame,1,deviceAdr);
…	…
639	639	long returnValue;
640	640	dS485Container pFrame,pFrameAnswer;
641	641
642		pFrame.destination=dSMdSID;
643
644
645		pFrame.containerType=DSTELEGRAM_REQUEST;
	642	pFrame.deviceId=dSMdSID;
	643	pFrame.containerType=DS485_CONTAINER_REQUEST;
646	644	pFrame.data[0]=MAPI_STOPDIM_DEVICE;
647	645	setParaCount(pFrame,1);
648	646	setPara(pFrame,1,deviceAdr);
…	…
654	654	long returnValue;
655	655	dS485Container pFrame,pFrameAnswer;
656	656
657		pFrame.destination=dSMdSID;
658
659
660		pFrame.containerType=DSTELEGRAM_REQUEST;
	657	pFrame.deviceId=dSMdSID;
	658	pFrame.containerType=DS485_CONTAINER_REQUEST;
661	659	pFrame.data[0]=MAPI_SET_PARAMETER;
662	660	setParaCount(pFrame,3);
663	661	setPara(pFrame,1,devAdr);
…	…
671	671	long returnValue;
672	672	dS485Container pFrame,pFrameAnswer;
673	673
674		pFrame.destination=dSMdSID;
675
676
677		pFrame.containerType=DSTELEGRAM_REQUEST;
	674	pFrame.deviceId=dSMdSID;
	675	pFrame.containerType=DS485_CONTAINER_REQUEST;
678	676	pFrame.data[0]=MAPI_INC_PARAMETER_VALUE;
679	677	setParaCount(pFrame,2);
680	678	setPara(pFrame,1,devAdr);
…	…
687	687	long returnValue;
688	688	dS485Container pFrame,pFrameAnswer;
689	689
690		pFrame.destination=dSMdSID;
691
692
693		pFrame.containerType=DSTELEGRAM_REQUEST;
	690	pFrame.deviceId=dSMdSID;
	691	pFrame.containerType=DS485_CONTAINER_REQUEST;
694	692	pFrame.data[0]=MAPI_DEC_PARAMETER_VALUE;
695	693	setParaCount(pFrame,2);
696	694	setPara(pFrame,1,devAdr);
…	…
703	703	long returnValue;
704	704	dS485Container pFrame,pFrameAnswer;
705	705
706		pFrame.destination=dSMdSID;
707
708
709		pFrame.containerType=DSTELEGRAM_REQUEST;
	706	pFrame.deviceId=dSMdSID;
	707	pFrame.containerType=DS485_CONTAINER_REQUEST;
710	708	pFrame.data[0]=MAPI_DEVICE_SET_ROOM_ID;
711	709	setParaCount(pFrame,2);
712	710	setPara(pFrame,1,devAdr);
…	…
718	718	long returnValue;
719	719	dS485Container pFrame,pFrameAnswer;
720	720
721		pFrame.destination=dSMdSID;
722
723
724		pFrame.containerType=DSTELEGRAM_REQUEST;
	721	pFrame.deviceId=dSMdSID;
	722	pFrame.containerType=DS485_CONTAINER_REQUEST;
725	723	pFrame.data[0]=MAPI_DEVICE_SET_VALUE;
726	724	setParaCount(pFrame,2);
727	725	setPara(pFrame,1,devAdr);
…	…
734	734	long returnValue;
735	735	dS485Container pFrame,pFrameAnswer;
736	736
737		pFrame.destination=dSMdSID;
738
739
740		pFrame.containerType=DSTELEGRAM_REQUEST;
	737	pFrame.deviceId=dSMdSID;
	738	pFrame.containerType=DS485_CONTAINER_REQUEST;
741	739	pFrame.data[0]=MAPI_DEVICE_IDENTIFY;
742	740	setParaCount(pFrame,2);
743	741	setPara(pFrame,1,addressSelection);
…	…
750	750	long returnValue;
751	751	dS485Container pFrame;
752	752
753		pFrame.destination=dSMdSID;
754
755
756		pFrame.containerType=DSTELEGRAM_REQUEST;
	753	pFrame.deviceId=dSMdSID;
	754	pFrame.containerType=DS485_CONTAINER_REQUEST;
757	755	pFrame.data[0]=MAPI_GET_PARAMETER_VALUE;
758	756	setParaCount(pFrame,2);
759	757	setPara(pFrame,1,devAdr);
…	…
761	761	oAnswer.request=pFrame;
762	762	}
763	763
764		oAnswer.request.containerType=DSTELEGRAM_RESPONSE;
	764	oAnswer.request.containerType=DS485_CONTAINER_RESPONSE;
765	765	ds485_client_send_command(&pFrame);
766	766
767	767	int iExpAnswers=3;
…	…
804	804	long returnValue;
805	805	dS485Container pFrame,pFrameAnswer;
806	806
807		pFrame.destination=dSMdSID;
808
809
810		pFrame.containerType=DSTELEGRAM_REQUEST;
	807	pFrame.deviceId=dSMdSID;
	808	pFrame.containerType=DS485_CONTAINER_REQUEST;
811	809	pFrame.data[0]=MAPI_GET_DEV_DSID;
812	810	setParaCount(pFrame,1);
813	811	setPara(pFrame,1,devAdr);
…	…
832	832	long returnValue;
833	833	dS485Container pFrame,pFrameAnswer;
834	834
835		pFrame.destination=dSMdSID;
836
837
838		pFrame.containerType=DSTELEGRAM_REQUEST;
	835	pFrame.deviceId=dSMdSID;
	836	pFrame.containerType=DS485_CONTAINER_REQUEST;
839	837	pFrame.data[0]=MAPI_GET_DEV_FID;
840	838	setParaCount(pFrame,1);
841	839	setPara(pFrame,1,devAdr);
…	…
847	847	long returnValue;
848	848	dS485Container pFrame,pFrameAnswer;
849	849
850		pFrame.destination=dSMdSID;
851
852
853		pFrame.containerType=DSTELEGRAM_REQUEST;
	850	pFrame.deviceId=dSMdSID;
	851	pFrame.containerType=DS485_CONTAINER_REQUEST;
854	852	pFrame.data[0]=MAPI_GET_DEV_GROUPFLAGS;
855	853	setParaCount(pFrame,1);
856	854	setPara(pFrame,1,devAdr);
…	…
869	869	long returnValue;
870	870	dS485Container pFrame,pFrameAnswer;
871	871
872		pFrame.destination=dSMdSID;
873
874
875		pFrame.containerType=DSTELEGRAM_REQUEST;
	872	pFrame.deviceId=dSMdSID;
	873	pFrame.containerType=DS485_CONTAINER_REQUEST;
876	874	pFrame.data[0]=MAPI_GET_DEV_VERSION;
877	875	setParaCount(pFrame,1);
878	876	setPara(pFrame,1,devAdr);
…	…
883	883
884	884	long dSMAPI_getType(dsidType dSMdSID,unsigned short deviceType, unsigned short hwVersion, unsigned short *swVersion){
885	885	dS485Container pFrame,pFrameAnswer;
886		pFrame.destination=dSMdSID;
887		pFrame.containerType=DSTELEGRAM_REQUEST;
	886	pFrame.deviceId=dSMdSID;
	887	pFrame.containerType=DS485_CONTAINER_REQUEST;
888	888	pFrame.data[0]=MAPI_GET_TYPE;
889	889	setParaCount(pFrame,0);
890	890	if (ds485_client_send_sync_command(&pFrame,&pFrameAnswer)!=0)
…	…
900	900	long returnValue;
901	901	dS485Container pFrame,pFrameAnswer;
902	902
903		pFrame.destination=dSMdSID;
904
905
906		pFrame.containerType=DSTELEGRAM_REQUEST;
	903	pFrame.deviceId=dSMdSID;
	904	pFrame.containerType=DS485_CONTAINER_REQUEST;
907	905	pFrame.data[0]=MAPI_GET_DSID;
908	906	setParaCount(pFrame,0);
909	907	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
…	…
925	925	long returnValue;
926	926	dS485Container pFrame,pFrameAnswer;
927	927
928		pFrame.destination=dSMdSID;
929
930
931		pFrame.containerType=DSTELEGRAM_REQUEST;
	928	pFrame.deviceId=dSMdSID;
	929	pFrame.containerType=DS485_CONTAINER_REQUEST;
932	930	pFrame.data[0]=MAPI_GET_VERSION_HW;
933	931	setParaCount(pFrame,0);
934	932	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
…	…
938	938	long returnValue;
939	939	dS485Container pFrame,pFrameAnswer;
940	940
941		pFrame.destination=dSMdSID;
942
943
944		pFrame.containerType=DSTELEGRAM_REQUEST;
	941	pFrame.deviceId=dSMdSID;
	942	pFrame.containerType=DS485_CONTAINER_REQUEST;
945	943	pFrame.data[0]=MAPI_GET_VERSION_SW;
946	944	setParaCount(pFrame,0);
947	945	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
…	…
951	951	long returnValue;
952	952	dS485Container pFrame,pFrameAnswer;
953	953
954		pFrame.destination=dSMdSID;
955
956
957		pFrame.containerType=DSTELEGRAM_REQUEST;
	954	pFrame.deviceId=dSMdSID;
	955	pFrame.containerType=DS485_CONTAINER_REQUEST;
958	956	pFrame.data[0]=MAPI_GET_POWER_CONSUMPTION;
959	957	setParaCount(pFrame,0);
960	958	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
…	…
965	965	long returnValue;
966	966	dS485Container pFrame,pFrameAnswer;
967	967
968		pFrame.destination=dSMdSID;
969
970
971		pFrame.containerType=DSTELEGRAM_REQUEST;
	968	pFrame.deviceId=dSMdSID;
	969	pFrame.containerType=DS485_CONTAINER_REQUEST;
972	970	pFrame.data[0]=MAPI_GET_POWER_METERVALUE;
973	971	setParaCount(pFrame,0);
974	972	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
…	…
978	978	long dSMAPI_setEnergyBorder(dsidType dSMdSID,unsigned int Gelb, unsigned int Rot){
979	979	dS485Container pFrame,pFrameAnswer;
980	980
981		pFrame.destination=dSMdSID;
982
983
984		pFrame.containerType=DSTELEGRAM_REQUEST;
	981	pFrame.deviceId=dSMdSID;
	982	pFrame.containerType=DS485_CONTAINER_REQUEST;
985	983	pFrame.data[0]=MAPI_SET_ENERGY_BORDER;
986	984	setParaCount(pFrame,2);
987	985	setPara(pFrame,1,Gelb);
…	…
991	991	long dSMAPI_getEnergyBorder(dsidType dSMdSID,unsigned int Gelb, unsigned int Rot){
992	992	dS485Container pFrame,pFrameAnswer;
993	993
994		pFrame.destination=dSMdSID;
995
996
997		pFrame.containerType=DSTELEGRAM_REQUEST;
	994	pFrame.deviceId=dSMdSID;
	995	pFrame.containerType=DS485_CONTAINER_REQUEST;
998	996	pFrame.data[0]=MAPI_GET_ENERGY_BORDER;
999	997	setParaCount(pFrame,0);
1000	998	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);
…	…
1005	1005	long returnValue;
1006	1006
1007	1007	dS485Container pFrameP1;
1008
1009	1008	dS485Container pFrameP2;
1010	1009
1011	1010	pthread_mutex_lock(&answer_mutex);
1012	1011
1013		pFrameP1.destination=dSMdSID;
1014		pFrameP2.destination=dSMdSID;
1015
1016		pFrameP1.containerType=DSTELEGRAM_REQUEST;
1017		pFrameP2.containerType=DSTELEGRAM_REQUEST;
	1012	pFrameP1.deviceId=dSMdSID;
	1013	pFrameP2.deviceId=dSMdSID;
	1014	pFrameP1.containerType=DS485_CONTAINER_REQUEST;
	1015	pFrameP2.containerType=DS485_CONTAINER_REQUEST;
1018	1016	pFrameP1.data[0]=0x9e;
1019	1017	pFrameP2.data[0]=0x9e;
1020	1018
…	…
1035	1035	oAnswer.Status=Waiting;
1036	1036	oAnswer.request=pFrameP2;
1037	1037
1038		oAnswer.request.containerType=DSTELEGRAM_RESPONSE;
	1038	oAnswer.request.containerType=DS485_CONTAINER_RESPONSE;
1039	1039	ds485_client_send_command(&pFrameP1);
1040	1040	ds485_client_send_command(&pFrameP2);
1041	1041
…	…
1073	1073
1074	1074	pthread_mutex_lock(&answer_mutex);
1075	1075
1076
1077		pFrame.destination=dSMdSID;
1078
1079
1080		pFrame.containerType=DSTELEGRAM_REQUEST;
1081
	1076	pFrame.deviceId=dSMdSID;
	1077	pFrame.containerType=DS485_CONTAINER_REQUEST;
1082	1078	pFrame.data[0]=0x9e;
1083
1084	1079	pFrame.data[1]=0x00 \| typeOfName;
1085	1080	pFrame.data[2]=0x00 \| typeOfName;
1086	1081
…	…
1094	1094	oAnswer.Status=Waiting;
1095	1095	oAnswer.request=pFrame;
1096	1096
1097		oAnswer.request.containerType=DSTELEGRAM_RESPONSE;
	1097	oAnswer.request.containerType=DS485_CONTAINER_RESPONSE;
1098	1098	ds485_client_send_command(&pFrame);
1099	1099
1100	1100	struct timespec ts;
…	…
1130	1130	long returnValue;
1131	1131	dS485Container pFrame,pFrameAnswer;
1132	1132
1133		pFrame.destination=dSMdSID;
1134
1135
1136		pFrame.containerType=DSTELEGRAM_REQUEST;
	1133	pFrame.deviceId=dSMdSID;
	1134	pFrame.containerType=DS485_CONTAINER_REQUEST;
1137	1135	pFrame.data[0]=0x9f;
1138	1136	setParaCount(pFrame,1);
1139	1137	setPara(pFrame,1,devAdr);
…	…
1141	1141	oAnswer.request=pFrame;
1142	1142	}
1143	1143
1144		oAnswer.request.containerType=DSTELEGRAM_EVENT;
	1144	oAnswer.request.containerType=DS485_CONTAINER_EVENT;
1145	1145	ds485_client_send_command(&pFrame);
1146	1146
1147	1147	if (compareDSID(dSMdSID,dSIDBroadcast)) {
…	…
1172	1172	long returnValue;
1173	1173	dS485Container pFrame,pFrameAnswer;
1174	1174
1175		pFrame.destination=dSMdSID;
1176
1177
1178		pFrame.containerType=DSTELEGRAM_REQUEST;
	1175	pFrame.deviceId=dSMdSID;
	1176	pFrame.containerType=DS485_CONTAINER_REQUEST;
1179	1177	pFrame.data[0]=0x51;
1180	1178	setParaCount(pFrame,2);
1181	1179	setPara(pFrame,1,devAdr);
…	…
1188	1188	long returnValue;
1189	1189	dS485Container pFrame,pFrameAnswer;
1190	1190
1191		pFrame.destination=dSMdSID;
1192
1193
1194		pFrame.containerType=DSTELEGRAM_REQUEST;
	1191	pFrame.deviceId=dSMdSID;
	1192	pFrame.containerType=DS485_CONTAINER_REQUEST;
1195	1193	pFrame.data[0]=0xb0;
1196	1194	setParaCount(pFrame,3);
1197	1195	setPara(pFrame,1,Stunde);
…	…
1205	1205
1206	1206	dS485Container pFrame,pFrameAnswer;
1207	1207
1208		pFrame.destination=dSMdSID;
1209
1210
1211		pFrame.containerType=DSTELEGRAM_REQUEST;
	1208	pFrame.deviceId=dSMdSID;
	1209	pFrame.containerType=DS485_CONTAINER_REQUEST;
1212	1210	pFrame.data[0]=0xb1;
1213	1211	setParaCount(pFrame,0);
1214	1212	ds485_client_send_sync_command(&pFrame,&pFrameAnswer);


1	1	#ifndef _ds485RawFunction_old_h
2	2	#define _ds485RawFunction_old_h
3	3
4		#ifdef __cplusplus
5		extern "C" {
6		#endif
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
7	7
	8	#include <arpa/inet.h>
	9
8	10	#define setPara(dSFrame, ParameterNummer, Value) dSFrame.data[(((ParameterNummer)-1)2)+1]=Value&0xff; dSFrame.data[(((ParameterNummer)-1)2)+2]=(Value>>8)&0xff
	11	//#define setPara(dSFrame, ParameterNummer, Value) { uint16_t obj = (uint16_t ) & (dSFrame.data[(ParameterNummer)-1)2]); obj = htons(Value); }
	12
9	13	#define setParaCount(dSFrame, ParameterCount) dSFrame.length=1+(ParameterCount*2)
	14
10	15	#define getPara(dSFrame, ParameterNummer) (dSFrame.data[((ParameterNummer-1)2)+1] \| ((dSFrame.data[((ParameterNummer-1)2)+2]<<8)&0xff00))
	16	//#define getPara(dSFrame, ParameterNummer, Value) (ntohs( (uint16_t ) & (dSFrame.data[((ParameterNummer)-1)*2])))
	17
11	18
12	19
13	20	long dSMAPI_addRoom(dsidType dSMdSID, unsigned int roomId);


38	38	int ZoneModify_Add(dsidType dSMdSID, uint16_t ZoneId)
39	39	{
40	40	dS485Container pFrame,pFrameAnswer;
41		pFrame.containerType=DSTELEGRAM_REQUEST;
42		pFrame.destination=dSMdSID;
	41	pFrame.containerType=DS485_CONTAINER_REQUEST;
	42	pFrame.deviceId=dSMdSID;
43	43	pFrame.data[0]=DSMAPI_ZONE_MODIFY;
44	44	setModifier(pFrame,DSMAPI_MODIFIER_ADD);
45	45	setParameter(pFrame,1,ZoneId);
…	…
54	54	uint16_t ZoneId)
55	55	{
56	56	dS485Container pFrame,pFrameAnswer;
57		pFrame.containerType=DSTELEGRAM_REQUEST;
58		pFrame.destination=dSMdSID;
	57	pFrame.containerType=DS485_CONTAINER_REQUEST;
	58	pFrame.deviceId=dSMdSID;
59	59	pFrame.data[0]=DSMAPI_ZONE_MODIFY;
60	60	setModifier(pFrame,DSMAPI_MODIFIER_REMOVE);
61	61	setParameter(pFrame,1,ZoneId);
…	…
71	71	uint16_t *DeviceCount)
72	72	{
73	73	dS485Container pFrame,pFrameAnswer;
74		pFrame.containerType=DSTELEGRAM_REQUEST;
75		pFrame.destination=dSMdSID;
	74	pFrame.containerType=DS485_CONTAINER_REQUEST;
	75	pFrame.deviceId=dSMdSID;
76	76	pFrame.data[0]=DSMAPI_ZONE_DEVICE_COUNT;
77	77	setModifier(pFrame,DSMAPI_MODIFIER_ONLY_ACTIVE);
78	78	setParameter(pFrame,1,ZoneId);
…	…
88	88	uint16_t *DeviceCount)
89	89	{
90	90	dS485Container pFrame,pFrameAnswer;
91		pFrame.containerType=DSTELEGRAM_REQUEST;
92		pFrame.destination=dSMdSID;
	91	pFrame.containerType=DS485_CONTAINER_REQUEST;
	92	pFrame.deviceId=dSMdSID;
93	93	pFrame.data[0]=DSMAPI_ZONE_DEVICE_COUNT;
94	94	setModifier(pFrame,DSMAPI_MODIFIER_ONLY_INACTIVE);
95	95	setParameter(pFrame,1,ZoneId);
…	…
105	105	out uint16_t deviceCount, uint16_t lastScene)
106	106	{
107	107	dS485Container pFrame,pFrameAnswer;
108		pFrame.containerType=DSTELEGRAM_REQUEST;
109		pFrame.destination=dSMdSID;
	108	pFrame.containerType=DS485_CONTAINER_REQUEST;
	109	pFrame.deviceId=dSMdSID;
110	110	pFrame.data[0]=DSMAPI_ZONE_GROUP_INFO;
111	111	setModifier(pFrame,DSMAPI_MODIFIER_GET);
112	112	setParameter(pFrame,1,ZoneId);
…	…
123	123	uint16_t *ZoneCount)
124	124	{
125	125	dS485Container pFrame,pFrameAnswer;
126		pFrame.containerType=DSTELEGRAM_REQUEST;
127		pFrame.destination=dSMdSID;
	126	pFrame.containerType=DS485_CONTAINER_REQUEST;
	127	pFrame.deviceId=dSMdSID;
128	128	pFrame.data[0]=DSMAPI_ZONE_COUNT;
129	129	setModifier(pFrame,DSMAPI_MODIFIER_GET);
130	130	setParameterCount(pFrame,0);
…	…
139	139	uint16_t ZoneID, uint16_t FunctionID, uint16_t MyClickNumber, uint16_t TargetGroup, uint16_t PingCounter, uint16_t StatusFlags, uint16_t *ProductID)
140	140	{
141	141	dS485Container pFrame,pFrameAnswer;
142		pFrame.containerType=DSTELEGRAM_REQUEST;
143		pFrame.destination=dSMdSID;
	142	pFrame.containerType=DS485_CONTAINER_REQUEST;
	143	pFrame.deviceId=dSMdSID;
144	144	pFrame.data[0]=DSMAPI_DEVICE_PROPERTIES;
145	145	setParameter(pFrame,1,DeviceId);
146	146	setModifier(pFrame,DSMAPI_MODIFIER_GET);
…	…
164	164	uint16_t DeviceId, uint16_t ZoneId)
165	165	{
166	166	dS485Container pFrame,pFrameAnswer;
167		pFrame.containerType=DSTELEGRAM_REQUEST;
168		pFrame.destination=dSMdSID;
	167	pFrame.containerType=DS485_CONTAINER_REQUEST;
	168	pFrame.deviceId=dSMdSID;
169	169	pFrame.data[0]=DSMAPI_DEVICE_PROPERTIES;
170	170	setParameter(pFrame,1,DeviceId);
171	171	setParameter(pFrame,2,ZoneId);
…	…
180	180	uint16_t DeviceId, uint16_t MyClickId)
181	181	{
182	182	dS485Container pFrame,pFrameAnswer;
183		pFrame.containerType=DSTELEGRAM_REQUEST;
184		pFrame.destination=dSMdSID;
	183	pFrame.containerType=DS485_CONTAINER_REQUEST;
	184	pFrame.deviceId=dSMdSID;
185	185	pFrame.data[0]=DSMAPI_DEVICE_PROPERTIES;
186	186	setParameter(pFrame,1,DeviceId);
187	187	setParameter(pFrame,2,MyClickId);
…	…
196	196	uint16_t DeviceId, uint16_t MyTargetGroupId)
197	197	{
198	198	dS485Container pFrame,pFrameAnswer;
199		pFrame.containerType=DSTELEGRAM_REQUEST;
200		pFrame.destination=dSMdSID;
	199	pFrame.containerType=DS485_CONTAINER_REQUEST;
	200	pFrame.deviceId=dSMdSID;
201	201	pFrame.data[0]=DSMAPI_DEVICE_PROPERTIES;
202	202	setParameter(pFrame,1,DeviceId);
203	203	setParameter(pFrame,2,MyTargetGroupId);
…	…
212	212	uint16_t DeviceId, uint16_t fLocked)
213	213	{
214	214	dS485Container pFrame,pFrameAnswer;
215		pFrame.containerType=DSTELEGRAM_REQUEST;
216		pFrame.destination=dSMdSID;
	215	pFrame.containerType=DS485_CONTAINER_REQUEST;
	216	pFrame.deviceId=dSMdSID;
217	217	pFrame.data[0]=DSMAPI_DEVICE_PROPERTIES;
218	218	setParameter(pFrame,1,DeviceId);
219	219	setParameter(pFrame,2,fLocked);
…	…
228	228	uint16_t DeviceId, uint16_t GroupId)
229	229	{
230	230	dS485Container pFrame,pFrameAnswer;
231		pFrame.containerType=DSTELEGRAM_REQUEST;
232		pFrame.destination=dSMdSID;
	231	pFrame.containerType=DS485_CONTAINER_REQUEST;
	232	pFrame.deviceId=dSMdSID;
233	233	pFrame.data[0]=DSMAPI_DEVICE_GROUP_MODIFY;
234	234	setParameter(pFrame,1,DeviceId);
235	235	setParameter(pFrame,2,GroupId);
…	…
244	244	uint16_t DeviceId, uint16_t GroupId)
245	245	{
246	246	dS485Container pFrame,pFrameAnswer;
247		pFrame.containerType=DSTELEGRAM_REQUEST;
248		pFrame.destination=dSMdSID;
	247	pFrame.containerType=DS485_CONTAINER_REQUEST;
	248	pFrame.deviceId=dSMdSID;
249	249	pFrame.data[0]=DSMAPI_DEVICE_GROUP_MODIFY;
250	250	setParameter(pFrame,1,DeviceId);
251	251	setParameter(pFrame,2,GroupId);
…	…
260	260	uint16_t DeviceId)
261	261	{
262	262	dS485Container pFrame,pFrameAnswer;
263		pFrame.containerType=DSTELEGRAM_REQUEST;
264		pFrame.destination=dSMdSID;
	263	pFrame.containerType=DS485_CONTAINER_REQUEST;
	264	pFrame.deviceId=dSMdSID;
265	265	pFrame.data[0]=DSMAPI_DEVICE_GROUP_MODIFY;
266	266	setParameter(pFrame,1,DeviceId);
267	267	setModifier(pFrame,DSMAPI_MODIFIER_REMOVE_ALL);
…	…
277	277	uint16_t *GroupId)
278	278	{
279	279	dS485Container pFrame,pFrameAnswer;
280		pFrame.containerType=DSTELEGRAM_REQUEST;
281		pFrame.destination=dSMdSID;
	280	pFrame.containerType=DS485_CONTAINER_REQUEST;
	281	pFrame.deviceId=dSMdSID;
282	282	pFrame.data[0]=DSMAPI_ZONE_GROUP_MODIFY;
283	283	setParameter(pFrame,1,ZoneId);
284	284	setModifier(pFrame,DSMAPI_MODIFIER_ADD);
…	…
293	293	uint16_t ZoneId, uint16_t GroupId)
294	294	{
295	295	dS485Container pFrame,pFrameAnswer;
296		pFrame.containerType=DSTELEGRAM_REQUEST;
297		pFrame.destination=dSMdSID;
	296	pFrame.containerType=DS485_CONTAINER_REQUEST;
	297	pFrame.deviceId=dSMdSID;
298	298	pFrame.data[0]=DSMAPI_ZONE_GROUP_MODIFY;
299	299	setParameter(pFrame,1,ZoneId);
300	300	setParameter(pFrame,2,GroupId);
…	…
309	309	uint16_t ZoneId)
310	310	{
311	311	dS485Container pFrame,pFrameAnswer;
312		pFrame.containerType=DSTELEGRAM_REQUEST;
313		pFrame.destination=dSMdSID;
	312	pFrame.containerType=DS485_CONTAINER_REQUEST;
	313	pFrame.deviceId=dSMdSID;
314	314	pFrame.data[0]=DSMAPI_ZONE_GROUP_MODIFY;
315	315	setParameter(pFrame,1,ZoneId);
316	316	setModifier(pFrame,DSMAPI_MODIFIER_REMOVE_ALL);
…	…
325	325	uint16_t ZoneId, uint16_t GroupId, uint16_t SceneNr)
326	326	{
327	327	dS485Container pFrame,pFrameAnswer;
328		pFrame.containerType=DSTELEGRAM_REQUEST;
329		pFrame.destination=dSMdSID;
	328	pFrame.containerType=DS485_CONTAINER_REQUEST;
	329	pFrame.deviceId=dSMdSID;
330	330	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
331	331	setModifier(pFrame,DSMAPI_MODIFIER_CALL_SCENE);
332	332	setParameter(pFrame,1,ZoneId);
…	…
342	342	uint16_t ZoneId, uint16_t GroupId, uint16_t SceneNr)
343	343	{
344	344	dS485Container pFrame,pFrameAnswer;
345		pFrame.containerType=DSTELEGRAM_REQUEST;
346		pFrame.destination=dSMdSID;
	345	pFrame.containerType=DS485_CONTAINER_REQUEST;
	346	pFrame.deviceId=dSMdSID;
347	347	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
348	348	setModifier(pFrame,DSMAPI_MODIFIER_SAVE_SCENE);
349	349	setParameter(pFrame,1,ZoneId);
…	…
359	359	uint16_t ZoneId, uint16_t GroupId)
360	360	{
361	361	dS485Container pFrame,pFrameAnswer;
362		pFrame.containerType=DSTELEGRAM_REQUEST;
363		pFrame.destination=dSMdSID;
	362	pFrame.containerType=DS485_CONTAINER_REQUEST;
	363	pFrame.deviceId=dSMdSID;
364	364	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
365	365	setModifier(pFrame,DSMAPI_MODIFIER_UNDO_SCENE);
366	366	setParameter(pFrame,1,ZoneId);
…	…
374	374	uint16_t ZoneId, uint16_t GroupId, uint16_t OutvalIndex, uint16_t Value)
375	375	{
376	376	dS485Container pFrame,pFrameAnswer;
377		pFrame.containerType=DSTELEGRAM_REQUEST;
378		pFrame.destination=dSMdSID;
	377	pFrame.containerType=DS485_CONTAINER_REQUEST;
	378	pFrame.deviceId=dSMdSID;
379	379	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
380	380	setModifier(pFrame,DSMAPI_MODIFIER_SET_OUTVAL);
381	381	setParameter(pFrame,1,ZoneId);
…	…
391	391	uint16_t ZoneId, uint16_t GroupId, uint16_t OutvalIndex)
392	392	{
393	393	dS485Container pFrame,pFrameAnswer;
394		pFrame.containerType=DSTELEGRAM_REQUEST;
395		pFrame.destination=dSMdSID;
	394	pFrame.containerType=DS485_CONTAINER_REQUEST;
	395	pFrame.deviceId=dSMdSID;
396	396	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
397	397	setModifier(pFrame,DSMAPI_MODIFIER_INC_OUTVAL);
398	398	setParameter(pFrame,1,ZoneId);
…	…
406	406	uint16_t ZoneId, uint16_t GroupId, uint16_t OutvalIndex)
407	407	{
408	408	dS485Container pFrame,pFrameAnswer;
409		pFrame.containerType=DSTELEGRAM_REQUEST;
410		pFrame.destination=dSMdSID;
	409	pFrame.containerType=DS485_CONTAINER_REQUEST;
	410	pFrame.deviceId=dSMdSID;
411	411	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
412	412	setModifier(pFrame,DSMAPI_MODIFIER_DEC_OUTVAL);
413	413	setParameter(pFrame,1,ZoneId);
…	…
421	421	uint16_t ZoneId, uint16_t GroupId, uint16_t OutvalIndex)
422	422	{
423	423	dS485Container pFrame,pFrameAnswer;
424		pFrame.containerType=DSTELEGRAM_REQUEST;
425		pFrame.destination=dSMdSID;
	424	pFrame.containerType=DS485_CONTAINER_REQUEST;
	425	pFrame.deviceId=dSMdSID;
426	426	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
427	427	setModifier(pFrame,DSMAPI_MODIFIER_MIN_OUTVAL);
428	428	setParameter(pFrame,1,ZoneId);
…	…
436	436	uint16_t ZoneId, uint16_t GroupId, uint16_t OutvalIndex)
437	437	{
438	438	dS485Container pFrame,pFrameAnswer;
439		pFrame.containerType=DSTELEGRAM_REQUEST;
440		pFrame.destination=dSMdSID;
	439	pFrame.containerType=DS485_CONTAINER_REQUEST;
	440	pFrame.deviceId=dSMdSID;
441	441	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
442	442	setModifier(pFrame,DSMAPI_MODIFIER_MAX_OUTVAL);
443	443	setParameter(pFrame,1,ZoneId);
…	…
451	451	uint16_t ZoneId, uint16_t GroupId, uint16_t OutvalIndex)
452	452	{
453	453	dS485Container pFrame,pFrameAnswer;
454		pFrame.containerType=DSTELEGRAM_REQUEST;
455		pFrame.destination=dSMdSID;
	454	pFrame.containerType=DS485_CONTAINER_REQUEST;
	455	pFrame.deviceId=dSMdSID;
456	456	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
457	457	setModifier(pFrame,DSMAPI_MODIFIER_STOP_OUTVAL);
458	458	setParameter(pFrame,1,ZoneId);
…	…
466	466	uint16_t ZoneId, uint16_t GroupId)
467	467	{
468	468	dS485Container pFrame,pFrameAnswer;
469		pFrame.containerType=DSTELEGRAM_REQUEST;
470		pFrame.destination=dSMdSID;
	469	pFrame.containerType=DS485_CONTAINER_REQUEST;
	470	pFrame.deviceId=dSMdSID;
471	471	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
472	472	setModifier(pFrame,DSMAPI_MODIFIER_REMOVE_LOCAL_PRIO);
473	473	setParameter(pFrame,1,ZoneId);
…	…
481	481	uint16_t ZoneId, uint16_t GroupId)
482	482	{
483	483	dS485Container pFrame,pFrameAnswer;
484		pFrame.containerType=DSTELEGRAM_REQUEST;
485		pFrame.destination=dSMdSID;
	484	pFrame.containerType=DS485_CONTAINER_REQUEST;
	485	pFrame.deviceId=dSMdSID;
486	486	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
487	487	setModifier(pFrame,DSMAPI_MODIFIER_SIGNAL);
488	488	setParameter(pFrame,1,ZoneId);
…	…
496	496	uint16_t ZoneId)
497	497	{
498	498	dS485Container pFrame,pFrameAnswer;
499		pFrame.containerType=DSTELEGRAM_REQUEST;
500		pFrame.destination=dSMdSID;
	499	pFrame.containerType=DS485_CONTAINER_REQUEST;
	500	pFrame.deviceId=dSMdSID;
501	501	pFrame.data[0]=DSMAPI_ZONE_GROUP_ACTION;
502	502	setModifier(pFrame,DSMAPI_MODIFIER_SHOW_COLOR);
503	503	setParameter(pFrame,1,ZoneId);
…	…
511	511	uint16_t DeviceId, uint16_t SceneNr)
512	512	{
513	513	dS485Container pFrame,pFrameAnswer;
514		pFrame.containerType=DSTELEGRAM_REQUEST;
515		pFrame.destination=dSMdSID;
	514	pFrame.containerType=DS485_CONTAINER_REQUEST;
	515	pFrame.deviceId=dSMdSID;
516	516	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
517	517	setModifier(pFrame,DSMAPI_MODIFIER_CALL_SCENE);
518	518	setParameter(pFrame,1,DeviceId);
…	…
526	526	uint16_t DeviceId, uint16_t SceneNr)
527	527	{
528	528	dS485Container pFrame,pFrameAnswer;
529		pFrame.containerType=DSTELEGRAM_REQUEST;
530		pFrame.destination=dSMdSID;
	529	pFrame.containerType=DS485_CONTAINER_REQUEST;
	530	pFrame.deviceId=dSMdSID;
531	531	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
532	532	setModifier(pFrame,DSMAPI_MODIFIER_SAVE_SCENE);
533	533	setParameter(pFrame,1,DeviceId);
…	…
541	541	uint16_t DeviceId)
542	542	{
543	543	dS485Container pFrame,pFrameAnswer;
544		pFrame.containerType=DSTELEGRAM_REQUEST;
545		pFrame.destination=dSMdSID;
	544	pFrame.containerType=DS485_CONTAINER_REQUEST;
	545	pFrame.deviceId=dSMdSID;
546	546	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
547	547	setModifier(pFrame,DSMAPI_MODIFIER_UNDO_SCENE);
548	548	setParameter(pFrame,1,DeviceId);
…	…
555	555	uint16_t DeviceId, uint16_t OutvalIndex, uint16_t Value)
556	556	{
557	557	dS485Container pFrame,pFrameAnswer;
558		pFrame.containerType=DSTELEGRAM_REQUEST;
559		pFrame.destination=dSMdSID;
	558	pFrame.containerType=DS485_CONTAINER_REQUEST;
	559	pFrame.deviceId=dSMdSID;
560	560	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
561	561	setModifier(pFrame,DSMAPI_MODIFIER_SET_OUTVAL);
562	562	setParameter(pFrame,1,DeviceId);
…	…
571	571	uint16_t DeviceId, uint16_t OutvalIndex)
572	572	{
573	573	dS485Container pFrame,pFrameAnswer;
574		pFrame.containerType=DSTELEGRAM_REQUEST;
575		pFrame.destination=dSMdSID;
	574	pFrame.containerType=DS485_CONTAINER_REQUEST;
	575	pFrame.deviceId=dSMdSID;
576	576	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
577	577	setModifier(pFrame,DSMAPI_MODIFIER_INC_OUTVAL);
578	578	setParameter(pFrame,1,DeviceId);
…	…
585	585	uint16_t DeviceId, uint16_t OutvalIndex)
586	586	{
587	587	dS485Container pFrame,pFrameAnswer;
588		pFrame.containerType=DSTELEGRAM_REQUEST;
589		pFrame.destination=dSMdSID;
	588	pFrame.containerType=DS485_CONTAINER_REQUEST;
	589	pFrame.deviceId=dSMdSID;
590	590	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
591	591	setModifier(pFrame,DSMAPI_MODIFIER_DEC_OUTVAL);
592	592	setParameter(pFrame,1,DeviceId);
…	…
599	599	uint16_t DeviceId, uint16_t OutvalIndex)
600	600	{
601	601	dS485Container pFrame,pFrameAnswer;
602		pFrame.containerType=DSTELEGRAM_REQUEST;
603		pFrame.destination=dSMdSID;
	602	pFrame.containerType=DS485_CONTAINER_REQUEST;
	603	pFrame.deviceId=dSMdSID;
604	604	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
605	605	setModifier(pFrame,DSMAPI_MODIFIER_MIN_OUTVAL);
606	606	setParameter(pFrame,1,DeviceId);
…	…
613	613	uint16_t DeviceId, uint16_t OutvalIndex)
614	614	{
615	615	dS485Container pFrame,pFrameAnswer;
616		pFrame.containerType=DSTELEGRAM_REQUEST;
617		pFrame.destination=dSMdSID;
	616	pFrame.containerType=DS485_CONTAINER_REQUEST;
	617	pFrame.deviceId=dSMdSID;
618	618	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
619	619	setModifier(pFrame,DSMAPI_MODIFIER_MAX_OUTVAL);
620	620	setParameter(pFrame,1,DeviceId);
…	…
627	627	uint16_t DeviceId, uint16_t OutvalIndex)
628	628	{
629	629	dS485Container pFrame,pFrameAnswer;
630		pFrame.containerType=DSTELEGRAM_REQUEST;
631		pFrame.destination=dSMdSID;
	630	pFrame.containerType=DS485_CONTAINER_REQUEST;
	631	pFrame.deviceId=dSMdSID;
632	632	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
633	633	setModifier(pFrame,DSMAPI_MODIFIER_STOP_OUTVAL);
634	634	setParameter(pFrame,1,DeviceId);
…	…
641	641	uint16_t DeviceId)
642	642	{
643	643	dS485Container pFrame,pFrameAnswer;
644		pFrame.containerType=DSTELEGRAM_REQUEST;
645		pFrame.destination=dSMdSID;
	644	pFrame.containerType=DS485_CONTAINER_REQUEST;
	645	pFrame.deviceId=dSMdSID;
646	646	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
647	647	setModifier(pFrame,DSMAPI_MODIFIER_REMOVE_LOCAL_PRIO);
648	648	setParameter(pFrame,1,DeviceId);
…	…
655	655	uint16_t DeviceId)
656	656	{
657	657	dS485Container pFrame,pFrameAnswer;
658		pFrame.containerType=DSTELEGRAM_REQUEST;
659		pFrame.destination=dSMdSID;
	658	pFrame.containerType=DS485_CONTAINER_REQUEST;
	659	pFrame.deviceId=dSMdSID;
660	660	pFrame.data[0]=DSMAPI_DEVICE_ACTION;
661	661	setModifier(pFrame,DSMAPI_MODIFIER_SIGNAL);
662	662	setParameter(pFrame,1,DeviceId);
…	…
672	672	uint32_t Level1, uint32_t Level2)
673	673	{
674	674	dS485Container pFrame,pFrameAnswer;
675		pFrame.containerType=DSTELEGRAM_REQUEST;
676		pFrame.destination=dSMdSID;
	675	pFrame.containerType=DS485_CONTAINER_REQUEST;
	676	pFrame.deviceId=dSMdSID;
677	677	pFrame.data[0]=DSMAPI_DSM_CIRCUIT_ENERGY_LEVEL;
678	678	setModifier(pFrame,DSMAPI_MODIFIER_GET);
679	679	setParameterCount(pFrame,0);
…	…
688	688	uint32_t Level1, uint32_t Level2)
689	689	{
690	690	dS485Container pFrame,pFrameAnswer;
691		pFrame.containerType=DSTELEGRAM_REQUEST;
692		pFrame.destination=dSMdSID;
	691	pFrame.containerType=DS485_CONTAINER_REQUEST;
	692	pFrame.deviceId=dSMdSID;
693	693	pFrame.data[0]=DSMAPI_DSM_CIRCUIT_ENERGY_LEVEL;
694	694	setModifier(pFrame,DSMAPI_MODIFIER_SET);
695	695	setParameter(pFrame,1,Level1);
…	…
705	705	uint32_t PowerConsumption, uint32_t EnergyMeterValue)
706	706	{
707	707	dS485Container pFrame,pFrameAnswer;
708		pFrame.containerType=DSTELEGRAM_REQUEST;
709		pFrame.destination=dSMdSID;
	708	pFrame.containerType=DS485_CONTAINER_REQUEST;
	709	pFrame.deviceId=dSMdSID;
710	710	pFrame.data[0]=DSMAPI_DSM_CIRCUIT_METERING_VALUE;
711	711	setModifier(pFrame,DSMAPI_MODIFIER_GET);
712	712	setParameterCount(pFrame,0);
…	…
724	724	{
725	725
726	726	dS485Container pFrame,pFrameAnswer;
727		pFrame.containerType=DSTELEGRAM_REQUEST;
728		pFrame.destination=dSMdSID;
	727	pFrame.containerType=DS485_CONTAINER_REQUEST;
	728	pFrame.deviceId=dSMdSID;
729	729	pFrame.data[0]=DSMAPI_DSM_TIME;
730	730	setModifier(pFrame,DSMAPI_MODIFIER_GET);
731	731	setParameterCount(pFrame,0);
…	…
739	739	uint32_t TimeValue)
740	740	{
741	741	dS485Container pFrame,pFrameAnswer;
742		pFrame.containerType=DSTELEGRAM_REQUEST;
743		pFrame.destination=dSMdSID;
	742	pFrame.containerType=DS485_CONTAINER_REQUEST;
	743	pFrame.deviceId=dSMdSID;
744	744	pFrame.data[0]=DSMAPI_DSM_TIME;
745	745	setModifier(pFrame,DSMAPI_MODIFIER_SET);
746	746	setParameter(pFrame,1,TimeValue);
…	…
755	755	dsidType *dsid)
756	756	{
757	757	dS485Container pFrame,pFrameAnswer;
758		pFrame.containerType=DSTELEGRAM_REQUEST;
759		pFrame.destination=dSMdSID;
	758	pFrame.containerType=DS485_CONTAINER_REQUEST;
	759	pFrame.deviceId=dSMdSID;
760	760	pFrame.data[0]=DSMAPI_DSM_DSID;
761	761	setModifier(pFrame,DSMAPI_MODIFIER_GET);
762	762	setParameterCount(pFrame,0);
…	…
783	783	uint16_t RevHW, uint16_t RevSW, uint16_t FeatureFlags, uint32_t BuildTime)
784	784	{
785	785	dS485Container pFrame,pFrameAnswer;
786		pFrame.containerType=DSTELEGRAM_REQUEST;
787		pFrame.destination=dSMdSID;
	786	pFrame.containerType=DS485_CONTAINER_REQUEST;
	787	pFrame.deviceId=dSMdSID;
788	788	pFrame.data[0]=DSMAPI_DSM_INFO;
789	789	setModifier(pFrame,DSMAPI_MODIFIER_GET);
790	790	setParameterCount(pFrame,0);
…	…
801	801	int MeterMaintance_StartPing(dsidType dSMdSID)
802	802	{
803	803	dS485Container pFrame,pFrameAnswer;
804		pFrame.containerType=DSTELEGRAM_REQUEST;
805		pFrame.destination=dSMdSID;
	804	pFrame.containerType=DS485_CONTAINER_REQUEST;
	805	pFrame.deviceId=dSMdSID;
806	806	pFrame.data[0]=DSMAPI_DSM_PING_DEVICES;
807	807	setModifier(pFrame,DSMAPI_MODIFIER_GET);
808	808	setParameterCount(pFrame,0);
…	…
815	815	int MeterMaintance_RemoveInactiveDevices(dsidType dSMdSID)
816	816	{
817	817	dS485Container pFrame,pFrameAnswer;
818		pFrame.containerType=DSTELEGRAM_REQUEST;
819		pFrame.destination=dSMdSID;
	818	pFrame.containerType=DS485_CONTAINER_REQUEST;
	819	pFrame.deviceId=dSMdSID;
820	820	pFrame.data[0]=DSMAPI_DSM_REMOVE_INACTIVE;
821	821	setModifier(pFrame,DSMAPI_MODIFIER_GET);
822	822	setParameterCount(pFrame,0);
…	…
829	829	int MeterRestart(dsidType dSMdSID)
830	830	{
831	831	dS485Container pFrame,pFrameAnswer;
832		pFrame.containerType=DSTELEGRAM_REQUEST;
833		pFrame.destination=dSMdSID;
	832	pFrame.containerType=DS485_CONTAINER_REQUEST;
	833	pFrame.deviceId=dSMdSID;
834	834	pFrame.data[0]=DSMAPI_REBOOT;
835	835	setModifier(pFrame,DSMAPI_MODIFIER_GET);
836	836	setParameterCount(pFrame,0);
…	…
844	844	uint16_t DeviceId, uint16_t ConfigClass, uint16_t ConfigId, uint16_t Value)
845	845	{
846	846	dS485Container pFrame,pFrameAnswer;
847		pFrame.containerType=DSTELEGRAM_REQUEST;
848		pFrame.destination=dSMdSID;
	847	pFrame.containerType=DS485_CONTAINER_REQUEST;
	848	pFrame.deviceId=dSMdSID;
849	849	pFrame.data[0]=DSMAPI_DEVICE_CONFIG;
850	850	setModifier(pFrame,DSMAPI_MODIFIER_GET);
851	851	setParameter(pFrame,1,DeviceId);
…	…
863	863	uint16_t ZoneId, unsigned char GroupMask)
864	864	{
865	865	dS485Container pFrame,pFrameAnswer;
866		pFrame.containerType=DSTELEGRAM_REQUEST;
867		pFrame.destination=dSMdSID;
	866	pFrame.containerType=DS485_CONTAINER_REQUEST;
	867	pFrame.deviceId=dSMdSID;
868	868	pFrame.data[0]=DSMAPI_ZONE_INFO;
869	869	setModifier(pFrame,DSMAPI_MODIFIER_GET);
870	870	setParameter(pFrame,1,ZoneIndex);
…	…
883	883	{
884	884	dS485Container pFrame,pFrameAnswer;
885	885
886		pFrame.containerType=DSTELEGRAM_REQUEST;
887		pFrame.destination=dSMdSID;
	886	pFrame.containerType=DS485_CONTAINER_REQUEST;
	887	pFrame.deviceId=dSMdSID;
888	888	pFrame.data[0]=DSMAPI_DEVICE_DSID;
889	889	setModifier(pFrame,DSMAPI_MODIFIER_GET);
890	890	setParameter(pFrame,1,DeviceId);
…	…
911	911	{
912	912	dS485Container pFrame,pFrameAnswer;
913	913
914		pFrame.containerType=DSTELEGRAM_REQUEST;
915		pFrame.destination=dSMdSID;
	914	pFrame.containerType=DS485_CONTAINER_REQUEST;
	915	pFrame.deviceId=dSMdSID;
916	916	pFrame.data[0]=DSMAPI_DEVICE_GROUPS;
917	917	setModifier(pFrame,DSMAPI_MODIFIER_GET);
918	918	setParameter(pFrame,1,DeviceId);
…	…
937	937	uint16_t TargetGroup, uint16_t PingCounter, uint16_t StatusFlags, uint16_t ProductId, uint16_t *RevisionsId)
938	938	{
939	939	dS485Container pFrame,pFrameAnswer;
940		pFrame.containerType=DSTELEGRAM_REQUEST;
941		pFrame.destination=dSMdSID;
	940	pFrame.containerType=DS485_CONTAINER_REQUEST;
	941	pFrame.deviceId=dSMdSID;
942	942	pFrame.data[0]=DSMAPI_DEVICE_INFO;
943	943	setModifier(pFrame,DSMAPI_MODIFIER_ONLY_ACTIVE);
944	944	setParameter(pFrame,1,ZoneId);
…	…
965	965	uint16_t TargetGroup, uint16_t PingCounter, uint16_t StatusFlags, uint16_t ProductId, uint16_t *RevisionsId)
966	966	{
967	967	dS485Container pFrame,pFrameAnswer;
968		pFrame.containerType=DSTELEGRAM_REQUEST;
969		pFrame.destination=dSMdSID;
	968	pFrame.containerType=DS485_CONTAINER_REQUEST;
	969	pFrame.deviceId=dSMdSID;
970	970	pFrame.data[0]=DSMAPI_DEVICE_INFO;
971	971	setModifier(pFrame,DSMAPI_MODIFIER_ONLY_INACTIVE);
972	972	setParameter(pFrame,1,ZoneId);


1	1	#ifndef DS485C_H_
2	2	#define DS485C_H_
3	3
4		#ifdef __cplusplus
5		extern "C" {
6		#endif
	4	#ifdef __cplusplus
	5	extern "C" {
	6	#endif
	7
7	8	/**
8	9	* 96-Bit dSID
9	10	*/
…	…
12	12	unsigned char value[12];
13	13	} dsidType;
14	14
15
	15	#if 0
	16	#define compareDSID(oDSID1,oDSID2) (oDSID1.value == oDSID2.value)
	17	#else
16	18	#define compareDSID(oDSID1,oDSID2) ((oDSID1.value[0]==oDSID2.value[0]) && \
17	19	(oDSID1.value[1]==oDSID2.value[1]) && \
18	20	(oDSID1.value[2]==oDSID2.value[2]) && \
…	…
27	27	(oDSID1.value[9]==oDSID2.value[9]) && \
28	28	(oDSID1.value[10]==oDSID2.value[10]) && \
29	29	(oDSID1.value[11]==oDSID2.value[11]))
	30	#endif
30	31
31	32	/**
32	33	* Status des dS485 Bus
33	34	*/
34	35	typedef enum {
35		DSBUS_ISOLATED,
36		DSBUS_INACTIVE,
37		DSBUS_ACTIVE
	36	DSBUS_ISOLATED,
	37	DSBUS_INACTIVE,
	38	DSBUS_ACTIVE
38	39	} BusState_t;
39	40
40	41	/**
41		* Typ des dS485Packets
	42	* Typ des Pakets
42	43	*/
43	44	typedef enum {
44		DSTELEGRAM_REQUEST,
45		DSTELEGRAM_RESPONSE,
46		DSTELEGRAM_EVENT
47		} ContainerType_t;
	45	DS485_CONTAINER_REQUEST = 1,
	46	DS485_CONTAINER_RESPONSE,
	47	DS485_CONTAINER_EVENT
	48	} dS485ContainerType_t;
48	49
49	50	/**
	51	* Flags für das Packet
	52	*/
	53	typedef enum {
	54	DS485_FLAG_NONE = 0,
	55	DS485_FLAG_BROADCAST = 1,
	56	} dS485ContainerFlags_t;
	57
	58	/**
50	59	* dS485 API Daten Container
51	60	*/
	61	#define DS485_CONTAINER_DATA_LENGTH 128
	62	#define DS485_CONTAINER_SIZE (sizeof(struct _dS485Container) - DS485_CONTAINER_DATA_LENGTH)
	63
52	64	typedef struct _dS485Container {
53	65
54		dsidType destination;
55		ContainerType_t containerType;
56		unsigned int length;
57		unsigned char data[128];
58		} dS485Container;
	66	dsidType deviceId;
	67	unsigned char deviceAddress;
	68	unsigned char containerType;
	69	unsigned char containerFlags;
	70	unsigned char length;
	71	unsigned char data[DS485_CONTAINER_DATA_LENGTH];
59	72
	73	} __attribute__ ((packed)) dS485Container;
	74
	75
60	76	/**
61	77	* Callback Methoden
62	78	*/
…	…
144	144	extern int ds485_get_dsid_state(dsidType dSID);
145	145
146	146	#ifdef __cplusplus
147		}
	147	}
148	148	#endif
149	149
150	150


1075	1075	} // distributeFrame
1076	1076
1077	1077	void DSDSMeterSim::dSLinkInterrupt(devid_t _shortAddress) const {
1078		dS485Container result;
1079		result.destination=dSIDBroadcast;
1080		setParaCount(result,2);
1081		result.containerType=DSTELEGRAM_EVENT;
1082		result.data[0]=EventDSLinkInterrupt;
1083		setPara(result,1,_shortAddress);
1084		setPara(result,2,0);
	1078	dS485Container result;
	1079	result.deviceId = dSIDBroadcast;
	1080	setParaCount(result,2);
	1081	result.containerType = DS485_CONTAINER_EVENT;
	1082	result.data[0] = EventDSLinkInterrupt;
	1083	setPara(result,1,_shortAddress);
	1084	setPara(result,2,0);
1085	1085	distributeFrame(result);
1086	1086	} // dSLinkInterrupt
1087	1087

Commit c8aa2affae4a854d42a4852e2fe0c059ffbc719c

Gitorious