_supla_int_t SRPC_ICACHE_FLASH srpc_ds_async_channel_value_changed(void *_srpc, unsigned char channel_number, char *value) {
TDS_SuplaDeviceChannelValue ncsc;
ncsc.ChannelNumber = channel_number;
memcpy(ncsc.value, value, SUPLA_CHANNELVALUE_SIZE);
return srpc_async_call(_srpc, SUPLA_DS_CALL_DEVICE_CHANNEL_VALUE_CHANGED, (char*)&ncsc, sizeof(TDS_SuplaDeviceChannelValue));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sc_async_event(void *_srpc, TSC_SuplaEvent *event) {
_supla_int_t size = sizeof(TSC_SuplaEvent)-SUPLA_SENDER_NAME_MAXSIZE+event->SenderNameSize;
if ( size > sizeof(TSC_SuplaEvent) )
return 0;
return srpc_async_call(_srpc, SUPLA_SC_CALL_EVENT, (char*)event, size);
}
_supla_int_t SRPC_ICACHE_FLASH srpc_ds_async_set_channel_result(void *_srpc, unsigned char ChannelNumber, _supla_int_t SenderID, char Success) {
TDS_SuplaChannelNewValueResult result;
result.ChannelNumber = ChannelNumber;
result.SenderID = SenderID;
result.Success = Success;
return srpc_async_call(_srpc, SUPLA_DS_CALL_CHANNEL_SET_VALUE_RESULT, (char*)&result, sizeof(TDS_SuplaChannelNewValueResult));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sc_async_location_update(void *_srpc, TSC_SuplaLocation *location) {
_supla_int_t size = sizeof(TSC_SuplaLocation)-SUPLA_LOCATION_CAPTION_MAXSIZE+location->CaptionSize;
if ( size > sizeof(TSC_SuplaLocation) )
return 0;
return srpc_async_call(_srpc, SUPLA_SC_CALL_LOCATION_UPDATE, (char*)location, size);
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sc_async_channel_update(void *_srpc, TSC_SuplaChannel *channel) {
_supla_int_t size = sizeof(TSC_SuplaChannel)-SUPLA_CHANNEL_CAPTION_MAXSIZE+channel->CaptionSize;
if ( size > sizeof(TSC_SuplaChannel) )
return 0;
return srpc_async_call(_srpc, SUPLA_SC_CALL_CHANNEL_UPDATE, (char*)channel, size);
}
int srpc_ds_async_registerdevice_b(void *_srpc, TDS_SuplaRegisterDevice_B *registerdevice) {
int size = sizeof(TDS_SuplaRegisterDevice_B)
- ( sizeof(TDS_SuplaDeviceChannel_B) * SUPLA_CHANNELMAXCOUNT )
+ ( sizeof(TDS_SuplaDeviceChannel_B) * registerdevice->channel_count );
if ( size > sizeof(TDS_SuplaRegisterDevice_B) )
return 0;
return srpc_async_call(_srpc, SUPLA_DS_CALL_REGISTER_DEVICE_B, (char*)registerdevice, size);
}
_supla_int_t SRPC_ICACHE_FLASH srpc_ds_async_registerdevice(void *_srpc, TDS_SuplaRegisterDevice *registerdevice) {
_supla_int_t size = sizeof(TDS_SuplaRegisterDevice)
- ( sizeof(TDS_SuplaDeviceChannel) * SUPLA_CHANNELMAXCOUNT )
+ ( sizeof(TDS_SuplaDeviceChannel) * registerdevice->channel_count );
if ( size > sizeof(TDS_SuplaRegisterDevice) )
return 0;
return srpc_async_call(_srpc, SUPLA_DS_CALL_REGISTER_DEVICE, (char*)registerdevice, size);
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sdc_async_ping_server_result(void *_srpc) {
TSDC_SuplaPingServerResult ps;
#ifdef ESP8266
ps.now.tv_sec = 0;
ps.now.tv_usec = 0;
#else
gettimeofday(&ps.now, NULL);
#endif
return srpc_async_call(_srpc, SUPLA_SDC_CALL_PING_SERVER_RESULT, (char*)&ps, sizeof(TSDC_SuplaPingServerResult));
}
int srpc_dcs_async_ping_server(void *_srpc) {
TDCS_SuplaPingServer ps;
#ifdef ESP8266
ps.now.tv_sec = 0;
ps.now.tv_usec = 0;
#else
gettimeofday(&ps.now, NULL);
#endif
return srpc_async_call(_srpc, SUPLA_DCS_CALL_PING_SERVER, (char*)&ps, sizeof(TDCS_SuplaPingServer));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sdc_async_getversion_result(void *_srpc, char *SoftVer) {
TSDC_SuplaGetVersionResult gvr;
gvr.proto_version = SUPLA_PROTO_VERSION;
gvr.proto_version_min = SUPLA_PROTO_VERSION_MIN;
memcpy(gvr.SoftVer, SoftVer, SUPLA_SOFTVER_MAXSIZE);
return srpc_async_call(_srpc, SUPLA_SDC_CALL_GETVERSION_RESULT, (char*)&gvr, sizeof(TSDC_SuplaGetVersionResult));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_dcs_async_ping_server(void *_srpc) {
TDCS_SuplaPingServer ps;
#if defined(ESP8266)
ps.now.tv_sec = 0;
ps.now.tv_usec = 0;
#elif defined(__AVR__)
ps.now.tv_sec[0] = 0;
ps.now.tv_sec[1] = 0;
ps.now.tv_usec[0] = 0;
ps.now.tv_usec[1] = 0;
#else
gettimeofday(&ps.now, NULL);
#endif
return srpc_async_call(_srpc, SUPLA_DCS_CALL_PING_SERVER, (char*)&ps, sizeof(TDCS_SuplaPingServer));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sc_async_locationpack_update(void *_srpc, TSC_SuplaLocationPack *location_pack) {
_supla_int_t result = 0;
_supla_int_t a;
_supla_int_t n=0;
_supla_int_t size = 0;
_supla_int_t offset = 0;
if ( location_pack->count > SUPLA_CHANNELPACK_MAXSIZE )
return 0;
size = sizeof(TSC_SuplaLocationPack)-(sizeof(TSC_SuplaLocation)*SUPLA_LOCATIONPACK_MAXSIZE);
offset = size;
char *buffer = malloc(size);
memcpy(buffer, location_pack, size);
for(a=0;a<location_pack->count;a++) {
if ( location_pack->locations[a].CaptionSize <= SUPLA_LOCATION_CAPTION_MAXSIZE ) {
size+=sizeof(TSC_SuplaLocation)-SUPLA_LOCATION_CAPTION_MAXSIZE+location_pack->locations[a].CaptionSize;
buffer = (char *)realloc(buffer, size);
memcpy(&buffer[offset], &location_pack->locations[a], size-offset);
offset+=size-offset;
n++;
}
}
((TSC_SuplaLocationPack *)buffer)->count = n;
result = srpc_async_call(_srpc, SUPLA_SC_CALL_LOCATIONPACK_UPDATE, buffer, size);
free(buffer);
return result;
}
// TODO srpc_sc_async_channelpack_update and srpc_sc_async_locationpack_update should be supported by one common function
int srpc_sc_async_channelpack_update(void *_srpc, TSC_SuplaChannelPack *channel_pack) {
int result = 0;
int a;
int n=0;
int size = 0;
int offset = 0;
if ( channel_pack->count > SUPLA_CHANNELPACK_MAXSIZE )
return 0;
size = sizeof(TSC_SuplaChannelPack)-(sizeof(TSC_SuplaChannel)*SUPLA_CHANNELPACK_MAXSIZE);
offset = size;
char *buffer = malloc(size);
memcpy(buffer, channel_pack, size);
for(a=0;a<channel_pack->count;a++) {
if ( channel_pack->channels[a].CaptionSize <= SUPLA_CHANNEL_CAPTION_MAXSIZE ) {
size+=sizeof(TSC_SuplaChannel)-SUPLA_CHANNEL_CAPTION_MAXSIZE+channel_pack->channels[a].CaptionSize;
buffer = (char *)realloc(buffer, size);
memcpy(&buffer[offset], &channel_pack->channels[a], size-offset);
offset+=size-offset;
n++;
}
}
((TSC_SuplaChannelPack *)buffer)->count = n;
result = srpc_async_call(_srpc, SUPLA_SC_CALL_CHANNELPACK_UPDATE, buffer, size);
free(buffer);
return result;
}
_supla_int_t SRPC_ICACHE_FLASH srpc_dcs_async_set_activity_timeout_result(void *_srpc, TSDC_SuplaSetActivityTimeoutResult *sdc_set_activity_timeout_result) {
return srpc_async_call(_srpc, SUPLA_SDC_CALL_SET_ACTIVITY_TIMEOUT_RESULT, (char*)sdc_set_activity_timeout_result, sizeof(TSDC_SuplaSetActivityTimeoutResult));
}
int srpc_cs_async_get_next(void *_srpc) {
return srpc_async_call(_srpc, SUPLA_CS_CALL_GET_NEXT, NULL, 0);
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sd_async_set_channel_value(void *_srpc, TSD_SuplaChannelNewValue *value) {
return srpc_async_call(_srpc, SUPLA_SD_CALL_CHANNEL_SET_VALUE, (char*)value, sizeof(TSD_SuplaChannelNewValue));
}
int srpc_cs_async_set_channel_value(void *_srpc, TCS_SuplaChannelNewValue *value) {
return srpc_async_call(_srpc, SUPLA_CS_CALL_CHANNEL_SET_VALUE, (char*)value, sizeof(TCS_SuplaChannelNewValue));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sc_async_registerclient_result(void *_srpc, TSC_SuplaRegisterClientResult *registerclient_result) {
return srpc_async_call(_srpc, SUPLA_SC_CALL_REGISTER_CLIENT_RESULT, (char*)registerclient_result, sizeof(TSC_SuplaRegisterClientResult));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_cs_async_registerclient(void *_srpc, TCS_SuplaRegisterClient *registerclient) {
return srpc_async_call(_srpc, SUPLA_CS_CALL_REGISTER_CLIENT, (char*)registerclient, sizeof(TCS_SuplaRegisterClient));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_dcs_async_getversion(void *_srpc) {
return srpc_async_call(_srpc, SUPLA_DCS_CALL_GETVERSION, NULL, 0);
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sc_async_channel_value_update(void *_srpc, TSC_SuplaChannelValue *channel_value) {
return srpc_async_call(_srpc, SUPLA_SC_CALL_CHANNEL_VALUE_UPDATE, (char*)channel_value, sizeof(TSC_SuplaChannelValue));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_dcs_async_set_activity_timeout(void *_srpc, TDCS_SuplaSetActivityTimeout *dcs_set_activity_timeout) {
return srpc_async_call(_srpc, SUPLA_DCS_CALL_SET_ACTIVITY_TIMEOUT, (char*)dcs_set_activity_timeout, sizeof(TDCS_SuplaSetActivityTimeout));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_cs_async_get_next(void *_srpc) {
return srpc_async_call(_srpc, SUPLA_CS_CALL_GET_NEXT, NULL, 0);
}
_supla_int_t SRPC_ICACHE_FLASH srpc_sd_async_registerdevice_result(void *_srpc, TSD_SuplaRegisterDeviceResult *registerdevice_result) {
return srpc_async_call(_srpc, SUPLA_SD_CALL_REGISTER_DEVICE_RESULT, (char*)registerdevice_result, sizeof(TSD_SuplaRegisterDeviceResult));
}
_supla_int_t SRPC_ICACHE_FLASH srpc_cs_async_set_channel_value_b(void *_srpc, TCS_SuplaChannelNewValue_B *value) {
return srpc_async_call(_srpc, SUPLA_CS_CALL_CHANNEL_SET_VALUE_B, (char*)value, sizeof(TCS_SuplaChannelNewValue_B));
}
int srpc_dcs_async_getversion(void *_srpc) {
return srpc_async_call(_srpc, SUPLA_DCS_CALL_GETVERSION, NULL, 0);
}
