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; }