int io16_get_port_monoflop(IO16 *io16, char port, uint8_t pin, uint8_t *ret_value, uint32_t *ret_time, uint32_t *ret_time_remaining) {
DevicePrivate *device_p = io16->p;
GetPortMonoflop_ request;
GetPortMonoflopResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), IO16_FUNCTION_GET_PORT_MONOFLOP, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
request.port = port;
request.pin = pin;
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_value = response.value;
*ret_time = leconvert_uint32_from(response.time);
*ret_time_remaining = leconvert_uint32_from(response.time_remaining);
return ret;
}
int industrial_quad_relay_get_monoflop(IndustrialQuadRelay *industrial_quad_relay, uint8_t pin, uint16_t *ret_value, uint32_t *ret_time, uint32_t *ret_time_remaining) {
DevicePrivate *device_p = industrial_quad_relay->p;
GetMonoflop_Request request;
GetMonoflop_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), INDUSTRIAL_QUAD_RELAY_FUNCTION_GET_MONOFLOP, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
request.pin = pin;
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_value = leconvert_uint16_from(response.value);
*ret_time = leconvert_uint32_from(response.time);
*ret_time_remaining = leconvert_uint32_from(response.time_remaining);
return ret;
}
int gps_get_coordinates(GPS *gps, uint32_t *ret_latitude, char *ret_ns, uint32_t *ret_longitude, char *ret_ew, uint16_t *ret_pdop, uint16_t *ret_hdop, uint16_t *ret_vdop, uint16_t *ret_epe) {
DevicePrivate *device_p = gps->p;
GetCoordinates_ request;
GetCoordinatesResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), GPS_FUNCTION_GET_COORDINATES, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_latitude = leconvert_uint32_from(response.latitude);
*ret_ns = response.ns;
*ret_longitude = leconvert_uint32_from(response.longitude);
*ret_ew = response.ew;
*ret_pdop = leconvert_uint16_from(response.pdop);
*ret_hdop = leconvert_uint16_from(response.hdop);
*ret_vdop = leconvert_uint16_from(response.vdop);
*ret_epe = leconvert_uint16_from(response.epe);
return ret;
}
int gps_get_motion(GPS *gps, uint32_t *ret_course, uint32_t *ret_speed) {
DevicePrivate *device_p = gps->p;
GetMotion_ request;
GetMotionResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), GPS_FUNCTION_GET_MOTION, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_course = leconvert_uint32_from(response.course);
*ret_speed = leconvert_uint32_from(response.speed);
return ret;
}
int gps_get_date_time(GPS *gps, uint32_t *ret_date, uint32_t *ret_time) {
DevicePrivate *device_p = gps->p;
GetDateTime_ request;
GetDateTimeResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), GPS_FUNCTION_GET_DATE_TIME, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_date = leconvert_uint32_from(response.date);
*ret_time = leconvert_uint32_from(response.time);
return ret;
}
int motion_detector_v2_get_spitfp_error_count(MotionDetectorV2 *motion_detector_v2, uint32_t *ret_error_count_ack_checksum, uint32_t *ret_error_count_message_checksum, uint32_t *ret_error_count_frame, uint32_t *ret_error_count_overflow) {
DevicePrivate *device_p = motion_detector_v2->p;
GetSPITFPErrorCount_Request request;
GetSPITFPErrorCount_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), MOTION_DETECTOR_V2_FUNCTION_GET_SPITFP_ERROR_COUNT, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_error_count_ack_checksum = leconvert_uint32_from(response.error_count_ack_checksum);
*ret_error_count_message_checksum = leconvert_uint32_from(response.error_count_message_checksum);
*ret_error_count_frame = leconvert_uint32_from(response.error_count_frame);
*ret_error_count_overflow = leconvert_uint32_from(response.error_count_overflow);
return ret;
}
int air_quality_get_spitfp_error_count(AirQuality *air_quality, uint32_t *ret_error_count_ack_checksum, uint32_t *ret_error_count_message_checksum, uint32_t *ret_error_count_frame, uint32_t *ret_error_count_overflow) {
DevicePrivate *device_p = air_quality->p;
GetSPITFPErrorCount_Request request;
GetSPITFPErrorCount_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), AIR_QUALITY_FUNCTION_GET_SPITFP_ERROR_COUNT, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_error_count_ack_checksum = leconvert_uint32_from(response.error_count_ack_checksum);
*ret_error_count_message_checksum = leconvert_uint32_from(response.error_count_message_checksum);
*ret_error_count_frame = leconvert_uint32_from(response.error_count_frame);
*ret_error_count_overflow = leconvert_uint32_from(response.error_count_overflow);
return ret;
}
int ambient_light_v2_get_illuminance_callback_threshold(AmbientLightV2 *ambient_light_v2, char *ret_option, uint32_t *ret_min, uint32_t *ret_max) {
DevicePrivate *device_p = ambient_light_v2->p;
GetIlluminanceCallbackThreshold_ request;
GetIlluminanceCallbackThresholdResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), AMBIENT_LIGHT_V2_FUNCTION_GET_ILLUMINANCE_CALLBACK_THRESHOLD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_option = response.option;
*ret_min = leconvert_uint32_from(response.min);
*ret_max = leconvert_uint32_from(response.max);
return ret;
}
static void gps_callback_wrapper_motion(DevicePrivate *device_p, Packet *packet) {
MotionCallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[GPS_CALLBACK_MOTION];
MotionCallback_ *callback = (MotionCallback_ *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[GPS_CALLBACK_MOTION];
if (callback_function == NULL) {
return;
}
callback->course = leconvert_uint32_from(callback->course);
callback->speed = leconvert_uint32_from(callback->speed);
callback_function(callback->course, callback->speed, user_data);
}
static void gps_callback_wrapper_date_time(DevicePrivate *device_p, Packet *packet) {
DateTimeCallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[GPS_CALLBACK_DATE_TIME];
DateTimeCallback_ *callback = (DateTimeCallback_ *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[GPS_CALLBACK_DATE_TIME];
if (callback_function == NULL) {
return;
}
callback->date = leconvert_uint32_from(callback->date);
callback->time = leconvert_uint32_from(callback->time);
callback_function(callback->date, callback->time, user_data);
}
int io16_get_edge_count(IO16 *io16, uint8_t pin, bool reset_counter, uint32_t *ret_count) {
DevicePrivate *device_p = io16->p;
GetEdgeCount_ request;
GetEdgeCountResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), IO16_FUNCTION_GET_EDGE_COUNT, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
request.pin = pin;
request.reset_counter = reset_counter;
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_count = leconvert_uint32_from(response.count);
return ret;
}
int humidity_v2_get_temperature_callback_configuration(HumidityV2 *humidity_v2, uint32_t *ret_period, bool *ret_value_has_to_change, char *ret_option, int16_t *ret_min, int16_t *ret_max) {
DevicePrivate *device_p = humidity_v2->p;
GetTemperatureCallbackConfiguration_Request request;
GetTemperatureCallbackConfiguration_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), HUMIDITY_V2_FUNCTION_GET_TEMPERATURE_CALLBACK_CONFIGURATION, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
*ret_value_has_to_change = response.value_has_to_change != 0;
*ret_option = response.option;
*ret_min = leconvert_int16_from(response.min);
*ret_max = leconvert_int16_from(response.max);
return ret;
}
int industrial_digital_in_4_get_edge_count(IndustrialDigitalIn4 *industrial_digital_in_4, uint8_t pin, bool reset_counter, uint32_t *ret_count) {
DevicePrivate *device_p = industrial_digital_in_4->p;
GetEdgeCount_ request;
GetEdgeCountResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), INDUSTRIAL_DIGITAL_IN_4_FUNCTION_GET_EDGE_COUNT, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
request.pin = pin;
request.reset_counter = reset_counter;
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_count = leconvert_uint32_from(response.count);
return ret;
}
int air_quality_get_air_pressure_callback_configuration(AirQuality *air_quality, uint32_t *ret_period, bool *ret_value_has_to_change, char *ret_option, int32_t *ret_min, int32_t *ret_max) {
DevicePrivate *device_p = air_quality->p;
GetAirPressureCallbackConfiguration_Request request;
GetAirPressureCallbackConfiguration_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), AIR_QUALITY_FUNCTION_GET_AIR_PRESSURE_CALLBACK_CONFIGURATION, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
*ret_value_has_to_change = response.value_has_to_change != 0;
*ret_option = response.option;
*ret_min = leconvert_int32_from(response.min);
*ret_max = leconvert_int32_from(response.max);
return ret;
}
static void gps_callback_wrapper_coordinates(DevicePrivate *device_p, Packet *packet) {
CoordinatesCallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[GPS_CALLBACK_COORDINATES];
CoordinatesCallback_ *callback = (CoordinatesCallback_ *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[GPS_CALLBACK_COORDINATES];
if (callback_function == NULL) {
return;
}
callback->latitude = leconvert_uint32_from(callback->latitude);
callback->longitude = leconvert_uint32_from(callback->longitude);
callback->pdop = leconvert_uint16_from(callback->pdop);
callback->hdop = leconvert_uint16_from(callback->hdop);
callback->vdop = leconvert_uint16_from(callback->vdop);
callback->epe = leconvert_uint16_from(callback->epe);
callback_function(callback->latitude, callback->ns, callback->longitude, callback->ew, callback->pdop, callback->hdop, callback->vdop, callback->epe, user_data);
}
static void ambient_light_v2_callback_wrapper_illuminance_reached(DevicePrivate *device_p, Packet *packet) {
IlluminanceReachedCallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[AMBIENT_LIGHT_V2_CALLBACK_ILLUMINANCE_REACHED];
IlluminanceReachedCallback_ *callback = (IlluminanceReachedCallback_ *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[AMBIENT_LIGHT_V2_CALLBACK_ILLUMINANCE_REACHED];
if (callback_function == NULL) {
return;
}
callback->illuminance = leconvert_uint32_from(callback->illuminance);
callback_function(callback->illuminance, user_data);
}
int uv_light_get_uv_light_callback_threshold(UVLight *uv_light, char *ret_option, uint32_t *ret_min, uint32_t *ret_max) {
DevicePrivate *device_p = uv_light->p;
GetUVLightCallbackThreshold_Request request;
GetUVLightCallbackThreshold_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), UV_LIGHT_FUNCTION_GET_UV_LIGHT_CALLBACK_THRESHOLD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_option = response.option;
*ret_min = leconvert_uint32_from(response.min);
*ret_max = leconvert_uint32_from(response.max);
return ret;
}
int solid_state_relay_get_monoflop(SolidStateRelay *solid_state_relay, bool *ret_state, uint32_t *ret_time, uint32_t *ret_time_remaining) {
DevicePrivate *device_p = solid_state_relay->p;
GetMonoflop_Request request;
GetMonoflop_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), SOLID_STATE_RELAY_FUNCTION_GET_MONOFLOP, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_state = response.state != 0;
*ret_time = leconvert_uint32_from(response.time);
*ret_time_remaining = leconvert_uint32_from(response.time_remaining);
return ret;
}
static void uv_light_callback_wrapper_uv_light_reached(DevicePrivate *device_p, Packet *packet) {
UVLightReached_CallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[DEVICE_NUM_FUNCTION_IDS + UV_LIGHT_CALLBACK_UV_LIGHT_REACHED];
UVLightReached_Callback *callback = (UVLightReached_Callback *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[DEVICE_NUM_FUNCTION_IDS + UV_LIGHT_CALLBACK_UV_LIGHT_REACHED];
if (callback_function == NULL) {
return;
}
callback->uv_light = leconvert_uint32_from(callback->uv_light);
callback_function(callback->uv_light, user_data);
}
int voltage_get_voltage_callback_period(Voltage *voltage, uint32_t *ret_period) {
DevicePrivate *device_p = voltage->p;
GetVoltageCallbackPeriod_Request request;
GetVoltageCallbackPeriod_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), VOLTAGE_FUNCTION_GET_VOLTAGE_CALLBACK_PERIOD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
return ret;
}
int motion_detector_v2_read_uid(MotionDetectorV2 *motion_detector_v2, uint32_t *ret_uid) {
DevicePrivate *device_p = motion_detector_v2->p;
ReadUID_Request request;
ReadUID_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), MOTION_DETECTOR_V2_FUNCTION_READ_UID, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_uid = leconvert_uint32_from(response.uid);
return ret;
}
int uv_light_get_uv_light(UVLight *uv_light, uint32_t *ret_uv_light) {
DevicePrivate *device_p = uv_light->p;
GetUVLight_Request request;
GetUVLight_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), UV_LIGHT_FUNCTION_GET_UV_LIGHT, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_uv_light = leconvert_uint32_from(response.uv_light);
return ret;
}
int uv_light_get_uv_light_callback_period(UVLight *uv_light, uint32_t *ret_period) {
DevicePrivate *device_p = uv_light->p;
GetUVLightCallbackPeriod_Request request;
GetUVLightCallbackPeriod_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), UV_LIGHT_FUNCTION_GET_UV_LIGHT_CALLBACK_PERIOD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
return ret;
}
int humidity_v2_read_uid(HumidityV2 *humidity_v2, uint32_t *ret_uid) {
DevicePrivate *device_p = humidity_v2->p;
ReadUID_Request request;
ReadUID_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), HUMIDITY_V2_FUNCTION_READ_UID, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_uid = leconvert_uint32_from(response.uid);
return ret;
}
int load_cell_get_weight_callback_period(LoadCell *load_cell, uint32_t *ret_period) {
DevicePrivate *device_p = load_cell->p;
GetWeightCallbackPeriod_Request request;
GetWeightCallbackPeriod_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), LOAD_CELL_FUNCTION_GET_WEIGHT_CALLBACK_PERIOD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
return ret;
}
int distance_us_get_distance_callback_period(DistanceUS *distance_us, uint32_t *ret_period) {
DevicePrivate *device_p = distance_us->p;
GetDistanceCallbackPeriod_Request request;
GetDistanceCallbackPeriod_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), DISTANCE_US_FUNCTION_GET_DISTANCE_CALLBACK_PERIOD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
return ret;
}
int co2_get_debounce_period(CO2 *co2, uint32_t *ret_debounce) {
DevicePrivate *device_p = co2->p;
GetDebouncePeriod_Request request;
GetDebouncePeriod_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), CO2_FUNCTION_GET_DEBOUNCE_PERIOD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_debounce = leconvert_uint32_from(response.debounce);
return ret;
}
int co2_get_co2_concentration_callback_period(CO2 *co2, uint32_t *ret_period) {
DevicePrivate *device_p = co2->p;
GetCO2ConcentrationCallbackPeriod_Request request;
GetCO2ConcentrationCallbackPeriod_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), CO2_FUNCTION_GET_CO2_CONCENTRATION_CALLBACK_PERIOD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
return ret;
}
int analog_in_v2_get_analog_value_callback_period(AnalogInV2 *analog_in_v2, uint32_t *ret_period) {
DevicePrivate *device_p = analog_in_v2->p;
GetAnalogValueCallbackPeriod_Request request;
GetAnalogValueCallbackPeriod_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), ANALOG_IN_V2_FUNCTION_GET_ANALOG_VALUE_CALLBACK_PERIOD, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_period = leconvert_uint32_from(response.period);
return ret;
}
int air_quality_read_uid(AirQuality *air_quality, uint32_t *ret_uid) {
DevicePrivate *device_p = air_quality->p;
ReadUID_Request request;
ReadUID_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), AIR_QUALITY_FUNCTION_READ_UID, device_p->ipcon_p, device_p);
if (ret < 0) {
return ret;
}
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
if (ret < 0) {
return ret;
}
*ret_uid = leconvert_uint32_from(response.uid);
return ret;
}
