Merge branch 'master' of https://github.com/tvdzwan/hyperion
Former-commit-id: 4763dcd03897ee85df068d9f7dc4a5954cbb1a4f
This commit is contained in:
johan
commit
62291adb52
|
|
@ -1,3 +1,5 @@
|
|||
/*.user
|
||||
/build
|
||||
/build-x86
|
||||
.DS_Store
|
||||
|
||||
|
|
|
|||
|
|
@ -16,6 +16,9 @@ message(STATUS "ENABLE_SPIDEV = " ${ENABLE_SPIDEV})
|
|||
option(ENABLE_V4L2 "Enable the V4L2 grabber" ON)
|
||||
message(STATUS "ENABLE_V4L2 = " ${ENABLE_V4L2})
|
||||
|
||||
option(ENABLE_TINKERFORGE "Enable the TINKERFORGE device" OFF)
|
||||
message(STATUS "ENABLE_TINKERFORGE = " ${ENABLE_TINKERFORGE})
|
||||
|
||||
# Createt the configuration file
|
||||
# configure a header file to pass some of the CMake settings
|
||||
# to the source code
|
||||
|
|
@ -62,6 +65,10 @@ set(CMAKE_FIND_LIBRARY_SUFFIXES_OLD)
|
|||
find_package(libusb-1.0 REQUIRED)
|
||||
find_package(Threads REQUIRED)
|
||||
|
||||
if (ENABLE_TINKERFORGE)
|
||||
#find_package(libtinkerforge-1.0 REQUIRED)
|
||||
endif (ENABLE_TINKERFORGE)
|
||||
|
||||
include(${QT_USE_FILE})
|
||||
add_definitions(${QT_DEFINITIONS})
|
||||
# TODO[TvdZ]: This linking directory should only be added if we are cross compiling
|
||||
|
|
|
|||
|
|
@ -8,3 +8,6 @@
|
|||
|
||||
// Define to enable the spi-device
|
||||
#cmakedefine ENABLE_SPIDEV
|
||||
|
||||
// Define to enable the spi-device
|
||||
#cmakedefine ENABLE_TINKERFORGE
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
|
||||
add_subdirectory(jsoncpp)
|
||||
add_subdirectory(getoptPlusPlus)
|
||||
add_subdirectory(serial)
|
||||
add_subdirectory(hidapi)
|
||||
add_subdirectory(jsoncpp)
|
||||
add_subdirectory(serial)
|
||||
add_subdirectory(tinkerforge)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,14 @@
|
|||
project(tinkerforge)
|
||||
|
||||
# define the current source/header path
|
||||
set(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/dependencies/include/tinkerforge)
|
||||
set(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/dependencies/build/tinkerforge)
|
||||
|
||||
include_directories(${CURRENT_HEADER_DIR})
|
||||
|
||||
add_library(tinkerforge
|
||||
${CURRENT_HEADER_DIR}/bricklet_led_strip.h
|
||||
${CURRENT_HEADER_DIR}/ip_connection.h
|
||||
|
||||
${CURRENT_SOURCE_DIR}/bricklet_led_strip.c
|
||||
${CURRENT_SOURCE_DIR}/ip_connection.c)
|
||||
|
|
@ -0,0 +1,373 @@
|
|||
/* ***********************************************************
|
||||
* This file was automatically generated on 2013-12-19. *
|
||||
* *
|
||||
* Bindings Version 2.0.13 *
|
||||
* *
|
||||
* If you have a bugfix for this file and want to commit it, *
|
||||
* please fix the bug in the generator. You can find a link *
|
||||
* to the generator git on tinkerforge.com *
|
||||
*************************************************************/
|
||||
|
||||
|
||||
#define IPCON_EXPOSE_INTERNALS
|
||||
|
||||
#include "bricklet_led_strip.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
|
||||
typedef void (*FrameRenderedCallbackFunction)(uint16_t, void *);
|
||||
|
||||
#if defined _MSC_VER || defined __BORLANDC__
|
||||
#pragma pack(push)
|
||||
#pragma pack(1)
|
||||
#define ATTRIBUTE_PACKED
|
||||
#elif defined __GNUC__
|
||||
#ifdef _WIN32
|
||||
// workaround struct packing bug in GCC 4.7 on Windows
|
||||
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
|
||||
#define ATTRIBUTE_PACKED __attribute__((gcc_struct, packed))
|
||||
#else
|
||||
#define ATTRIBUTE_PACKED __attribute__((packed))
|
||||
#endif
|
||||
#else
|
||||
#error unknown compiler, do not know how to enable struct packing
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint16_t index;
|
||||
uint8_t length;
|
||||
uint8_t r[16];
|
||||
uint8_t g[16];
|
||||
uint8_t b[16];
|
||||
} ATTRIBUTE_PACKED SetRGBValues_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint16_t index;
|
||||
uint8_t length;
|
||||
} ATTRIBUTE_PACKED GetRGBValues_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint8_t r[16];
|
||||
uint8_t g[16];
|
||||
uint8_t b[16];
|
||||
} ATTRIBUTE_PACKED GetRGBValuesResponse_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint16_t duration;
|
||||
} ATTRIBUTE_PACKED SetFrameDuration_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
} ATTRIBUTE_PACKED GetFrameDuration_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint16_t duration;
|
||||
} ATTRIBUTE_PACKED GetFrameDurationResponse_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
} ATTRIBUTE_PACKED GetSupplyVoltage_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint16_t voltage;
|
||||
} ATTRIBUTE_PACKED GetSupplyVoltageResponse_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint16_t length;
|
||||
} ATTRIBUTE_PACKED FrameRenderedCallback_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint32_t frequency;
|
||||
} ATTRIBUTE_PACKED SetClockFrequency_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
} ATTRIBUTE_PACKED GetClockFrequency_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint32_t frequency;
|
||||
} ATTRIBUTE_PACKED GetClockFrequencyResponse_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
} ATTRIBUTE_PACKED GetIdentity_;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
char uid[8];
|
||||
char connected_uid[8];
|
||||
char position;
|
||||
uint8_t hardware_version[3];
|
||||
uint8_t firmware_version[3];
|
||||
uint16_t device_identifier;
|
||||
} ATTRIBUTE_PACKED GetIdentityResponse_;
|
||||
|
||||
#if defined _MSC_VER || defined __BORLANDC__
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
#undef ATTRIBUTE_PACKED
|
||||
|
||||
static void led_strip_callback_wrapper_frame_rendered(DevicePrivate *device_p, Packet *packet) {
|
||||
FrameRenderedCallbackFunction callback_function;
|
||||
void *user_data = device_p->registered_callback_user_data[LED_STRIP_CALLBACK_FRAME_RENDERED];
|
||||
FrameRenderedCallback_ *callback = (FrameRenderedCallback_ *)packet;
|
||||
*(void **)(&callback_function) = device_p->registered_callbacks[LED_STRIP_CALLBACK_FRAME_RENDERED];
|
||||
|
||||
if (callback_function == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
callback->length = leconvert_uint16_from(callback->length);
|
||||
|
||||
callback_function(callback->length, user_data);
|
||||
}
|
||||
|
||||
void led_strip_create(LEDStrip *led_strip, const char *uid, IPConnection *ipcon) {
|
||||
DevicePrivate *device_p;
|
||||
|
||||
device_create(led_strip, uid, ipcon->p, 2, 0, 1);
|
||||
|
||||
device_p = led_strip->p;
|
||||
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_SET_RGB_VALUES] = DEVICE_RESPONSE_EXPECTED_FALSE;
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_GET_RGB_VALUES] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_SET_FRAME_DURATION] = DEVICE_RESPONSE_EXPECTED_FALSE;
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_GET_FRAME_DURATION] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_GET_SUPPLY_VOLTAGE] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
|
||||
device_p->response_expected[LED_STRIP_CALLBACK_FRAME_RENDERED] = DEVICE_RESPONSE_EXPECTED_ALWAYS_FALSE;
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_SET_CLOCK_FREQUENCY] = DEVICE_RESPONSE_EXPECTED_FALSE;
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_GET_CLOCK_FREQUENCY] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
|
||||
device_p->response_expected[LED_STRIP_FUNCTION_GET_IDENTITY] = DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE;
|
||||
|
||||
device_p->callback_wrappers[LED_STRIP_CALLBACK_FRAME_RENDERED] = led_strip_callback_wrapper_frame_rendered;
|
||||
}
|
||||
|
||||
void led_strip_destroy(LEDStrip *led_strip) {
|
||||
device_destroy(led_strip);
|
||||
}
|
||||
|
||||
int led_strip_get_response_expected(LEDStrip *led_strip, uint8_t function_id, bool *ret_response_expected) {
|
||||
return device_get_response_expected(led_strip->p, function_id, ret_response_expected);
|
||||
}
|
||||
|
||||
int led_strip_set_response_expected(LEDStrip *led_strip, uint8_t function_id, bool response_expected) {
|
||||
return device_set_response_expected(led_strip->p, function_id, response_expected);
|
||||
}
|
||||
|
||||
int led_strip_set_response_expected_all(LEDStrip *led_strip, bool response_expected) {
|
||||
return device_set_response_expected_all(led_strip->p, response_expected);
|
||||
}
|
||||
|
||||
void led_strip_register_callback(LEDStrip *led_strip, uint8_t id, void *callback, void *user_data) {
|
||||
device_register_callback(led_strip->p, id, callback, user_data);
|
||||
}
|
||||
|
||||
int led_strip_get_api_version(LEDStrip *led_strip, uint8_t ret_api_version[3]) {
|
||||
return device_get_api_version(led_strip->p, ret_api_version);
|
||||
}
|
||||
|
||||
int led_strip_set_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t r[16], uint8_t g[16], uint8_t b[16]) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
SetRGBValues_ request;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_RGB_VALUES, device_p->ipcon_p, device_p);
|
||||
|
||||
if (ret < 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
request.index = leconvert_uint16_to(index);
|
||||
request.length = length;
|
||||
memcpy(request.r, r, 16 * sizeof(uint8_t));
|
||||
memcpy(request.g, g, 16 * sizeof(uint8_t));
|
||||
memcpy(request.b, b, 16 * sizeof(uint8_t));
|
||||
|
||||
ret = device_send_request(device_p, (Packet *)&request, NULL);
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int led_strip_get_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t ret_r[16], uint8_t ret_g[16], uint8_t ret_b[16]) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
GetRGBValues_ request;
|
||||
GetRGBValuesResponse_ response;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_RGB_VALUES, device_p->ipcon_p, device_p);
|
||||
|
||||
if (ret < 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
request.index = leconvert_uint16_to(index);
|
||||
request.length = length;
|
||||
|
||||
ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response);
|
||||
|
||||
if (ret < 0) {
|
||||
return ret;
|
||||
}
|
||||
memcpy(ret_r, response.r, 16 * sizeof(uint8_t));
|
||||
memcpy(ret_g, response.g, 16 * sizeof(uint8_t));
|
||||
memcpy(ret_b, response.b, 16 * sizeof(uint8_t));
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int led_strip_set_frame_duration(LEDStrip *led_strip, uint16_t duration) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
SetFrameDuration_ request;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_FRAME_DURATION, device_p->ipcon_p, device_p);
|
||||
|
||||
if (ret < 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
request.duration = leconvert_uint16_to(duration);
|
||||
|
||||
ret = device_send_request(device_p, (Packet *)&request, NULL);
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int led_strip_get_frame_duration(LEDStrip *led_strip, uint16_t *ret_duration) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
GetFrameDuration_ request;
|
||||
GetFrameDurationResponse_ response;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_FRAME_DURATION, 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_duration = leconvert_uint16_from(response.duration);
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int led_strip_get_supply_voltage(LEDStrip *led_strip, uint16_t *ret_voltage) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
GetSupplyVoltage_ request;
|
||||
GetSupplyVoltageResponse_ response;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_SUPPLY_VOLTAGE, 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_voltage = leconvert_uint16_from(response.voltage);
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int led_strip_set_clock_frequency(LEDStrip *led_strip, uint32_t frequency) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
SetClockFrequency_ request;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_SET_CLOCK_FREQUENCY, device_p->ipcon_p, device_p);
|
||||
|
||||
if (ret < 0) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
request.frequency = leconvert_uint32_to(frequency);
|
||||
|
||||
ret = device_send_request(device_p, (Packet *)&request, NULL);
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int led_strip_get_clock_frequency(LEDStrip *led_strip, uint32_t *ret_frequency) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
GetClockFrequency_ request;
|
||||
GetClockFrequencyResponse_ response;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_CLOCK_FREQUENCY, 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_frequency = leconvert_uint32_from(response.frequency);
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int led_strip_get_identity(LEDStrip *led_strip, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier) {
|
||||
DevicePrivate *device_p = led_strip->p;
|
||||
GetIdentity_ request;
|
||||
GetIdentityResponse_ response;
|
||||
int ret;
|
||||
|
||||
ret = packet_header_create(&request.header, sizeof(request), LED_STRIP_FUNCTION_GET_IDENTITY, 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;
|
||||
}
|
||||
strncpy(ret_uid, response.uid, 8);
|
||||
strncpy(ret_connected_uid, response.connected_uid, 8);
|
||||
*ret_position = response.position;
|
||||
memcpy(ret_hardware_version, response.hardware_version, 3 * sizeof(uint8_t));
|
||||
memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t));
|
||||
*ret_device_identifier = leconvert_uint16_from(response.device_identifier);
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,301 @@
|
|||
/* ***********************************************************
|
||||
* This file was automatically generated on 2013-12-19. *
|
||||
* *
|
||||
* Bindings Version 2.0.13 *
|
||||
* *
|
||||
* If you have a bugfix for this file and want to commit it, *
|
||||
* please fix the bug in the generator. You can find a link *
|
||||
* to the generator git on tinkerforge.com *
|
||||
*************************************************************/
|
||||
|
||||
#ifndef BRICKLET_LED_STRIP_H
|
||||
#define BRICKLET_LED_STRIP_H
|
||||
|
||||
#include "ip_connection.h"
|
||||
|
||||
/**
|
||||
* \defgroup BrickletLEDStrip LEDStrip Bricklet
|
||||
*/
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Device to control up to 320 RGB LEDs
|
||||
*/
|
||||
typedef Device LEDStrip;
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_SET_RGB_VALUES 1
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_GET_RGB_VALUES 2
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_SET_FRAME_DURATION 3
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_GET_FRAME_DURATION 4
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_GET_SUPPLY_VOLTAGE 5
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_SET_CLOCK_FREQUENCY 7
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_GET_CLOCK_FREQUENCY 8
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*/
|
||||
#define LED_STRIP_FUNCTION_GET_IDENTITY 255
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Signature: \code void callback(uint16_t length, void *user_data) \endcode
|
||||
*
|
||||
* This callback is triggered directly after a new frame is rendered.
|
||||
*
|
||||
* You should send the data for the next frame directly after this callback
|
||||
* was triggered.
|
||||
*
|
||||
* For an explanation of the general approach see {@link led_strip_set_rgb_values}.
|
||||
*/
|
||||
#define LED_STRIP_CALLBACK_FRAME_RENDERED 6
|
||||
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* This constant is used to identify a LEDStrip Bricklet.
|
||||
*
|
||||
* The {@link led_strip_get_identity} function and the
|
||||
* {@link IPCON_CALLBACK_ENUMERATE} callback of the IP Connection have a
|
||||
* \c device_identifier parameter to specify the Brick's or Bricklet's type.
|
||||
*/
|
||||
#define LED_STRIP_DEVICE_IDENTIFIER 231
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Creates the device object \c led_strip with the unique device ID \c uid and adds
|
||||
* it to the IPConnection \c ipcon.
|
||||
*/
|
||||
void led_strip_create(LEDStrip *led_strip, const char *uid, IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Removes the device object \c led_strip from its IPConnection and destroys it.
|
||||
* The device object cannot be used anymore afterwards.
|
||||
*/
|
||||
void led_strip_destroy(LEDStrip *led_strip);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Returns the response expected flag for the function specified by the
|
||||
* \c function_id parameter. It is *true* if the function is expected to
|
||||
* send a response, *false* otherwise.
|
||||
*
|
||||
* For getter functions this is enabled by default and cannot be disabled,
|
||||
* because those functions will always send a response. For callback
|
||||
* configuration functions it is enabled by default too, but can be disabled
|
||||
* via the led_strip_set_response_expected function. For setter functions it is
|
||||
* disabled by default and can be enabled.
|
||||
*
|
||||
* Enabling the response expected flag for a setter function allows to
|
||||
* detect timeouts and other error conditions calls of this setter as well.
|
||||
* The device will then send a response for this purpose. If this flag is
|
||||
* disabled for a setter function then no response is send and errors are
|
||||
* silently ignored, because they cannot be detected.
|
||||
*/
|
||||
int led_strip_get_response_expected(LEDStrip *led_strip, uint8_t function_id, bool *ret_response_expected);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Changes the response expected flag of the function specified by the
|
||||
* \c function_id parameter. This flag can only be changed for setter
|
||||
* (default value: *false*) and callback configuration functions
|
||||
* (default value: *true*). For getter functions it is always enabled and
|
||||
* callbacks it is always disabled.
|
||||
*
|
||||
* Enabling the response expected flag for a setter function allows to detect
|
||||
* timeouts and other error conditions calls of this setter as well. The device
|
||||
* will then send a response for this purpose. If this flag is disabled for a
|
||||
* setter function then no response is send and errors are silently ignored,
|
||||
* because they cannot be detected.
|
||||
*/
|
||||
int led_strip_set_response_expected(LEDStrip *led_strip, uint8_t function_id, bool response_expected);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Changes the response expected flag for all setter and callback configuration
|
||||
* functions of this device at once.
|
||||
*/
|
||||
int led_strip_set_response_expected_all(LEDStrip *led_strip, bool response_expected);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Registers a callback with ID \c id to the function \c callback. The
|
||||
* \c user_data will be given as a parameter of the callback.
|
||||
*/
|
||||
void led_strip_register_callback(LEDStrip *led_strip, uint8_t id, void *callback, void *user_data);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Returns the API version (major, minor, release) of the bindings for this
|
||||
* device.
|
||||
*/
|
||||
int led_strip_get_api_version(LEDStrip *led_strip, uint8_t ret_api_version[3]);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Sets the *rgb* values for the LEDs with the given *length* starting
|
||||
* from *index*.
|
||||
*
|
||||
* The maximum length is 16, the index goes from 0 to 319 and the rgb values
|
||||
* have 8 bits each.
|
||||
*
|
||||
* Example: If you set
|
||||
*
|
||||
* * index to 5,
|
||||
* * length to 3,
|
||||
* * r to [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
||||
* * g to [0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] and
|
||||
* * b to [0, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
|
||||
*
|
||||
* the LED with index 5 will be red, 6 will be green and 7 will be blue.
|
||||
*
|
||||
* The colors will be transfered to actual LEDs when the next
|
||||
* frame duration ends, see {@link led_strip_set_frame_duration}.
|
||||
*
|
||||
* Generic approach:
|
||||
*
|
||||
* * Set the frame duration to a value that represents
|
||||
* the number of frames per second you want to achieve.
|
||||
* * Set all of the LED colors for one frame.
|
||||
* * Wait for the {@link LED_STRIP_CALLBACK_FRAME_RENDERED} callback.
|
||||
* * Set all of the LED colors for next frame.
|
||||
* * Wait for the {@link LED_STRIP_CALLBACK_FRAME_RENDERED} callback.
|
||||
* * and so on.
|
||||
*
|
||||
* This approach ensures that you can change the LED colors with
|
||||
* a fixed frame rate.
|
||||
*
|
||||
* The actual number of controllable LEDs depends on the number of free
|
||||
* Bricklet ports. See :ref:`here <led_strip_bricklet_ram_constraints>` for more
|
||||
* information. A call of {@link led_strip_set_rgb_values} with index + length above the
|
||||
* bounds is ignored completely.
|
||||
*/
|
||||
int led_strip_set_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t r[16], uint8_t g[16], uint8_t b[16]);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Returns the rgb with the given *length* starting from the
|
||||
* given *index*.
|
||||
*
|
||||
* The values are the last values that were set by {@link led_strip_set_rgb_values}.
|
||||
*/
|
||||
int led_strip_get_rgb_values(LEDStrip *led_strip, uint16_t index, uint8_t length, uint8_t ret_r[16], uint8_t ret_g[16], uint8_t ret_b[16]);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Sets the frame duration in ms.
|
||||
*
|
||||
* Example: If you want to achieve 20 frames per second, you should
|
||||
* set the frame duration to 50ms (50ms * 20 = 1 second).
|
||||
*
|
||||
* For an explanation of the general approach see {@link led_strip_set_rgb_values}.
|
||||
*
|
||||
* Default value: 100ms (10 frames per second).
|
||||
*/
|
||||
int led_strip_set_frame_duration(LEDStrip *led_strip, uint16_t duration);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Returns the frame duration as set by {@link led_strip_set_frame_duration}.
|
||||
*/
|
||||
int led_strip_get_frame_duration(LEDStrip *led_strip, uint16_t *ret_duration);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Returns the current supply voltage of the LEDs. The voltage is given in mV.
|
||||
*/
|
||||
int led_strip_get_supply_voltage(LEDStrip *led_strip, uint16_t *ret_voltage);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Sets the frequency of the clock in Hz. The range is 10000Hz (10kHz) up to
|
||||
* 2000000Hz (2MHz).
|
||||
*
|
||||
* The Bricklet will choose the nearest achievable frequency, which may
|
||||
* be off by a few Hz. You can get the exact frequency that is used by
|
||||
* calling {@link led_strip_get_clock_frequency}.
|
||||
*
|
||||
* If you have problems with flickering LEDs, they may be bits flipping. You
|
||||
* can fix this by either making the connection between the LEDs and the
|
||||
* Bricklet shorter or by reducing the frequency.
|
||||
*
|
||||
* With a decreasing frequency your maximum frames per second will decrease
|
||||
* too.
|
||||
*
|
||||
* The default value is 1.66MHz.
|
||||
*
|
||||
* \note
|
||||
* The frequency in firmware version 2.0.0 is fixed at 2MHz.
|
||||
*
|
||||
* .. versionadded:: 2.0.1~(Plugin)
|
||||
*/
|
||||
int led_strip_set_clock_frequency(LEDStrip *led_strip, uint32_t frequency);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Returns the currently used clock frequency.
|
||||
*
|
||||
* .. versionadded:: 2.0.1~(Plugin)
|
||||
*/
|
||||
int led_strip_get_clock_frequency(LEDStrip *led_strip, uint32_t *ret_frequency);
|
||||
|
||||
/**
|
||||
* \ingroup BrickletLEDStrip
|
||||
*
|
||||
* Returns the UID, the UID where the Bricklet is connected to,
|
||||
* the position, the hardware and firmware version as well as the
|
||||
* device identifier.
|
||||
*
|
||||
* The position can be 'a', 'b', 'c' or 'd'.
|
||||
*
|
||||
* The device identifiers can be found :ref:`here <device_identifier>`.
|
||||
*
|
||||
* .. versionadded:: 2.0.0~(Plugin)
|
||||
*/
|
||||
int led_strip_get_identity(LEDStrip *led_strip, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier);
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,630 @@
|
|||
/*
|
||||
* Copyright (C) 2012-2013 Matthias Bolte <matthias@tinkerforge.com>
|
||||
* Copyright (C) 2011 Olaf Lüke <olaf@tinkerforge.com>
|
||||
*
|
||||
* Redistribution and use in source and binary forms of this file,
|
||||
* with or without modification, are permitted.
|
||||
*/
|
||||
|
||||
#ifndef IP_CONNECTION_H
|
||||
#define IP_CONNECTION_H
|
||||
|
||||
/**
|
||||
* \defgroup IPConnection IP Connection
|
||||
*/
|
||||
|
||||
#ifndef __STDC_LIMIT_MACROS
|
||||
#define __STDC_LIMIT_MACROS
|
||||
#endif
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#if !defined __cplusplus && defined __GNUC__
|
||||
#include <stdbool.h>
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <pthread.h>
|
||||
#include <semaphore.h>
|
||||
#endif
|
||||
|
||||
enum {
|
||||
E_OK = 0,
|
||||
E_TIMEOUT = -1,
|
||||
E_NO_STREAM_SOCKET = -2,
|
||||
E_HOSTNAME_INVALID = -3,
|
||||
E_NO_CONNECT = -4,
|
||||
E_NO_THREAD = -5,
|
||||
E_NOT_ADDED = -6, // unused since v2.0
|
||||
E_ALREADY_CONNECTED = -7,
|
||||
E_NOT_CONNECTED = -8,
|
||||
E_INVALID_PARAMETER = -9, // error response from device
|
||||
E_NOT_SUPPORTED = -10, // error response from device
|
||||
E_UNKNOWN_ERROR_CODE = -11 // error response from device
|
||||
};
|
||||
|
||||
#ifdef IPCON_EXPOSE_INTERNALS
|
||||
|
||||
typedef struct _Socket Socket;
|
||||
|
||||
typedef struct {
|
||||
#ifdef _WIN32
|
||||
CRITICAL_SECTION handle;
|
||||
#else
|
||||
pthread_mutex_t handle;
|
||||
#endif
|
||||
} Mutex;
|
||||
|
||||
void mutex_create(Mutex *mutex);
|
||||
|
||||
void mutex_destroy(Mutex *mutex);
|
||||
|
||||
void mutex_lock(Mutex *mutex);
|
||||
|
||||
void mutex_unlock(Mutex *mutex);
|
||||
|
||||
typedef struct {
|
||||
#ifdef _WIN32
|
||||
HANDLE handle;
|
||||
#else
|
||||
pthread_cond_t condition;
|
||||
pthread_mutex_t mutex;
|
||||
bool flag;
|
||||
#endif
|
||||
} Event;
|
||||
|
||||
typedef struct {
|
||||
#ifdef _WIN32
|
||||
HANDLE handle;
|
||||
#else
|
||||
sem_t object;
|
||||
sem_t *pointer;
|
||||
#endif
|
||||
} Semaphore;
|
||||
|
||||
typedef void (*ThreadFunction)(void *opaque);
|
||||
|
||||
typedef struct {
|
||||
#ifdef _WIN32
|
||||
HANDLE handle;
|
||||
DWORD id;
|
||||
#else
|
||||
pthread_t handle;
|
||||
#endif
|
||||
ThreadFunction function;
|
||||
void *opaque;
|
||||
} Thread;
|
||||
|
||||
typedef struct {
|
||||
Mutex mutex;
|
||||
int used;
|
||||
int allocated;
|
||||
uint32_t *keys;
|
||||
void **values;
|
||||
} Table;
|
||||
|
||||
typedef struct _QueueItem {
|
||||
struct _QueueItem *next;
|
||||
int kind;
|
||||
void *data;
|
||||
int length;
|
||||
} QueueItem;
|
||||
|
||||
typedef struct {
|
||||
Mutex mutex;
|
||||
Semaphore semaphore;
|
||||
QueueItem *head;
|
||||
QueueItem *tail;
|
||||
} Queue;
|
||||
|
||||
#if defined _MSC_VER || defined __BORLANDC__
|
||||
#pragma pack(push)
|
||||
#pragma pack(1)
|
||||
#define ATTRIBUTE_PACKED
|
||||
#elif defined __GNUC__
|
||||
#ifdef _WIN32
|
||||
// workaround struct packing bug in GCC 4.7 on Windows
|
||||
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52991
|
||||
#define ATTRIBUTE_PACKED __attribute__((gcc_struct, packed))
|
||||
#else
|
||||
#define ATTRIBUTE_PACKED __attribute__((packed))
|
||||
#endif
|
||||
#else
|
||||
#error unknown compiler, do not know how to enable struct packing
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint32_t uid;
|
||||
uint8_t length;
|
||||
uint8_t function_id;
|
||||
uint8_t sequence_number_and_options;
|
||||
uint8_t error_code_and_future_use;
|
||||
} ATTRIBUTE_PACKED PacketHeader;
|
||||
|
||||
typedef struct {
|
||||
PacketHeader header;
|
||||
uint8_t payload[64];
|
||||
uint8_t optional_data[8];
|
||||
} ATTRIBUTE_PACKED Packet;
|
||||
|
||||
#if defined _MSC_VER || defined __BORLANDC__
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
#undef ATTRIBUTE_PACKED
|
||||
|
||||
#endif // IPCON_EXPOSE_INTERNALS
|
||||
|
||||
typedef struct _IPConnection IPConnection;
|
||||
typedef struct _IPConnectionPrivate IPConnectionPrivate;
|
||||
typedef struct _Device Device;
|
||||
typedef struct _DevicePrivate DevicePrivate;
|
||||
|
||||
#ifdef IPCON_EXPOSE_INTERNALS
|
||||
|
||||
typedef struct _CallbackContext CallbackContext;
|
||||
|
||||
#endif
|
||||
|
||||
typedef void (*EnumerateCallbackFunction)(const char *uid,
|
||||
const char *connected_uid,
|
||||
char position,
|
||||
uint8_t hardware_version[3],
|
||||
uint8_t firmware_version[3],
|
||||
uint16_t device_identifier,
|
||||
uint8_t enumeration_type,
|
||||
void *user_data);
|
||||
typedef void (*ConnectedCallbackFunction)(uint8_t connect_reason,
|
||||
void *user_data);
|
||||
typedef void (*DisconnectedCallbackFunction)(uint8_t disconnect_reason,
|
||||
void *user_data);
|
||||
|
||||
#ifdef IPCON_EXPOSE_INTERNALS
|
||||
|
||||
typedef void (*CallbackWrapperFunction)(DevicePrivate *device_p, Packet *packet);
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
struct _Device {
|
||||
DevicePrivate *p;
|
||||
};
|
||||
|
||||
#ifdef IPCON_EXPOSE_INTERNALS
|
||||
|
||||
#define DEVICE_NUM_FUNCTION_IDS 256
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
struct _DevicePrivate {
|
||||
uint32_t uid;
|
||||
|
||||
IPConnectionPrivate *ipcon_p;
|
||||
|
||||
uint8_t api_version[3];
|
||||
|
||||
Mutex request_mutex;
|
||||
|
||||
uint8_t expected_response_function_id; // protected by request_mutex
|
||||
uint8_t expected_response_sequence_number; // protected by request_mutex
|
||||
Mutex response_mutex;
|
||||
Packet response_packet; // protected by response_mutex
|
||||
Event response_event;
|
||||
int response_expected[DEVICE_NUM_FUNCTION_IDS];
|
||||
|
||||
void *registered_callbacks[DEVICE_NUM_FUNCTION_IDS];
|
||||
void *registered_callback_user_data[DEVICE_NUM_FUNCTION_IDS];
|
||||
CallbackWrapperFunction callback_wrappers[DEVICE_NUM_FUNCTION_IDS];
|
||||
};
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
enum {
|
||||
DEVICE_RESPONSE_EXPECTED_INVALID_FUNCTION_ID = 0,
|
||||
DEVICE_RESPONSE_EXPECTED_ALWAYS_TRUE, // getter
|
||||
DEVICE_RESPONSE_EXPECTED_ALWAYS_FALSE, // callback
|
||||
DEVICE_RESPONSE_EXPECTED_TRUE, // setter
|
||||
DEVICE_RESPONSE_EXPECTED_FALSE // setter, default
|
||||
};
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
void device_create(Device *device, const char *uid,
|
||||
IPConnectionPrivate *ipcon_p, uint8_t api_version_major,
|
||||
uint8_t api_version_minor, uint8_t api_version_release);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
void device_destroy(Device *device);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int device_get_response_expected(DevicePrivate *device_p, uint8_t function_id,
|
||||
bool *ret_response_expected);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int device_set_response_expected(DevicePrivate *device_p, uint8_t function_id,
|
||||
bool response_expected);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int device_set_response_expected_all(DevicePrivate *device_p, bool response_expected);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
void device_register_callback(DevicePrivate *device_p, uint8_t id, void *callback,
|
||||
void *user_data);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int device_get_api_version(DevicePrivate *device_p, uint8_t ret_api_version[3]);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int device_send_request(DevicePrivate *device_p, Packet *request, Packet *response);
|
||||
|
||||
#endif // IPCON_EXPOSE_INTERNALS
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Possible IDs for ipcon_register_callback.
|
||||
*/
|
||||
enum {
|
||||
IPCON_CALLBACK_ENUMERATE = 253,
|
||||
IPCON_CALLBACK_CONNECTED = 0,
|
||||
IPCON_CALLBACK_DISCONNECTED = 1
|
||||
};
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Possible values for enumeration_type parameter of EnumerateCallback.
|
||||
*/
|
||||
enum {
|
||||
IPCON_ENUMERATION_TYPE_AVAILABLE = 0,
|
||||
IPCON_ENUMERATION_TYPE_CONNECTED = 1,
|
||||
IPCON_ENUMERATION_TYPE_DISCONNECTED = 2
|
||||
};
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Possible values for connect_reason parameter of ConnectedCallback.
|
||||
*/
|
||||
enum {
|
||||
IPCON_CONNECT_REASON_REQUEST = 0,
|
||||
IPCON_CONNECT_REASON_AUTO_RECONNECT = 1
|
||||
};
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Possible values for disconnect_reason parameter of DisconnectedCallback.
|
||||
*/
|
||||
enum {
|
||||
IPCON_DISCONNECT_REASON_REQUEST = 0,
|
||||
IPCON_DISCONNECT_REASON_ERROR = 1,
|
||||
IPCON_DISCONNECT_REASON_SHUTDOWN = 2
|
||||
};
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Possible return values of ipcon_get_connection_state.
|
||||
*/
|
||||
enum {
|
||||
IPCON_CONNECTION_STATE_DISCONNECTED = 0,
|
||||
IPCON_CONNECTION_STATE_CONNECTED = 1,
|
||||
IPCON_CONNECTION_STATE_PENDING = 2 // auto-reconnect in progress
|
||||
};
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
struct _IPConnection {
|
||||
IPConnectionPrivate *p;
|
||||
};
|
||||
|
||||
#ifdef IPCON_EXPOSE_INTERNALS
|
||||
|
||||
#define IPCON_NUM_CALLBACK_IDS 256
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
struct _IPConnectionPrivate {
|
||||
#ifdef _WIN32
|
||||
bool wsa_startup_done; // protected by socket_mutex
|
||||
#endif
|
||||
|
||||
char *host;
|
||||
uint16_t port;
|
||||
|
||||
uint32_t timeout; // in msec
|
||||
|
||||
bool auto_reconnect;
|
||||
bool auto_reconnect_allowed;
|
||||
bool auto_reconnect_pending;
|
||||
|
||||
Mutex sequence_number_mutex;
|
||||
uint8_t next_sequence_number; // protected by sequence_number_mutex
|
||||
|
||||
Table devices;
|
||||
|
||||
void *registered_callbacks[IPCON_NUM_CALLBACK_IDS];
|
||||
void *registered_callback_user_data[IPCON_NUM_CALLBACK_IDS];
|
||||
|
||||
Mutex socket_mutex;
|
||||
Socket *socket; // protected by socket_mutex
|
||||
uint64_t socket_id; // protected by socket_mutex
|
||||
|
||||
bool receive_flag;
|
||||
Thread receive_thread; // protected by socket_mutex
|
||||
|
||||
CallbackContext *callback;
|
||||
|
||||
bool disconnect_probe_flag;
|
||||
Thread disconnect_probe_thread; // protected by socket_mutex
|
||||
Event disconnect_probe_event;
|
||||
|
||||
Semaphore wait;
|
||||
};
|
||||
|
||||
#endif // IPCON_EXPOSE_INTERNALS
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Creates an IP Connection object that can be used to enumerate the available
|
||||
* devices. It is also required for the constructor of Bricks and Bricklets.
|
||||
*/
|
||||
void ipcon_create(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Destroys the IP Connection object. Calls ipcon_disconnect internally.
|
||||
* The connection to the Brick Daemon gets closed and the threads of the
|
||||
* IP Connection are terminated.
|
||||
*/
|
||||
void ipcon_destroy(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Creates a TCP/IP connection to the given \c host and c\ port. The host and
|
||||
* port can point to a Brick Daemon or to a WIFI/Ethernet Extension.
|
||||
*
|
||||
* Devices can only be controlled when the connection was established
|
||||
* successfully.
|
||||
*
|
||||
* Blocks until the connection is established and returns an error code if
|
||||
* there is no Brick Daemon or WIFI/Ethernet Extension listening at the given
|
||||
* host and port.
|
||||
*/
|
||||
int ipcon_connect(IPConnection *ipcon, const char *host, uint16_t port);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Disconnects the TCP/IP connection from the Brick Daemon or the WIFI/Ethernet
|
||||
* Extension.
|
||||
*/
|
||||
int ipcon_disconnect(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Can return the following states:
|
||||
*
|
||||
* - IPCON_CONNECTION_STATE_DISCONNECTED: No connection is established.
|
||||
* - IPCON_CONNECTION_STATE_CONNECTED: A connection to the Brick Daemon or
|
||||
* the WIFI/Ethernet Extension is established.
|
||||
* - IPCON_CONNECTION_STATE_PENDING: IP Connection is currently trying to
|
||||
* connect.
|
||||
*/
|
||||
int ipcon_get_connection_state(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Enables or disables auto-reconnect. If auto-reconnect is enabled,
|
||||
* the IP Connection will try to reconnect to the previously given
|
||||
* host and port, if the connection is lost.
|
||||
*
|
||||
* Default value is *true*.
|
||||
*/
|
||||
void ipcon_set_auto_reconnect(IPConnection *ipcon, bool auto_reconnect);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Returns *true* if auto-reconnect is enabled, *false* otherwise.
|
||||
*/
|
||||
bool ipcon_get_auto_reconnect(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Sets the timeout in milliseconds for getters and for setters for which the
|
||||
* response expected flag is activated.
|
||||
*
|
||||
* Default timeout is 2500.
|
||||
*/
|
||||
void ipcon_set_timeout(IPConnection *ipcon, uint32_t timeout);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Returns the timeout as set by ipcon_set_timeout.
|
||||
*/
|
||||
uint32_t ipcon_get_timeout(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Broadcasts an enumerate request. All devices will respond with an enumerate
|
||||
* callback.
|
||||
*/
|
||||
int ipcon_enumerate(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Stops the current thread until ipcon_unwait is called.
|
||||
*
|
||||
* This is useful if you rely solely on callbacks for events, if you want
|
||||
* to wait for a specific callback or if the IP Connection was created in
|
||||
* a thread.
|
||||
*
|
||||
* ipcon_wait and ipcon_unwait act in the same way as "acquire" and "release"
|
||||
* of a semaphore.
|
||||
*/
|
||||
void ipcon_wait(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Unwaits the thread previously stopped by ipcon_wait.
|
||||
*
|
||||
* ipcon_wait and ipcon_unwait act in the same way as "acquire" and "release"
|
||||
* of a semaphore.
|
||||
*/
|
||||
void ipcon_unwait(IPConnection *ipcon);
|
||||
|
||||
/**
|
||||
* \ingroup IPConnection
|
||||
*
|
||||
* Registers a callback for a given ID.
|
||||
*/
|
||||
void ipcon_register_callback(IPConnection *ipcon, uint8_t id,
|
||||
void *callback, void *user_data);
|
||||
|
||||
#ifdef IPCON_EXPOSE_INTERNALS
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int packet_header_create(PacketHeader *header, uint8_t length,
|
||||
uint8_t function_id, IPConnectionPrivate *ipcon_p,
|
||||
DevicePrivate *device_p);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint8_t packet_header_get_sequence_number(PacketHeader *header);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
void packet_header_set_sequence_number(PacketHeader *header,
|
||||
uint8_t sequence_number);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint8_t packet_header_get_response_expected(PacketHeader *header);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
void packet_header_set_response_expected(PacketHeader *header,
|
||||
uint8_t response_expected);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint8_t packet_header_get_error_code(PacketHeader *header);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int16_t leconvert_int16_to(int16_t native);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint16_t leconvert_uint16_to(uint16_t native);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int32_t leconvert_int32_to(int32_t native);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint32_t leconvert_uint32_to(uint32_t native);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int64_t leconvert_int64_to(int64_t native);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint64_t leconvert_uint64_to(uint64_t native);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
float leconvert_float_to(float native);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int16_t leconvert_int16_from(int16_t little);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint16_t leconvert_uint16_from(uint16_t little);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int32_t leconvert_int32_from(int32_t little);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint32_t leconvert_uint32_from(uint32_t little);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
int64_t leconvert_int64_from(int64_t little);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
uint64_t leconvert_uint64_from(uint64_t little);
|
||||
|
||||
/**
|
||||
* \internal
|
||||
*/
|
||||
float leconvert_float_from(float little);
|
||||
|
||||
#endif // IPCON_EXPOSE_INTERNALS
|
||||
|
||||
#endif
|
||||
Binary file not shown.
|
|
@ -8,8 +8,8 @@ find_package(libusb-1.0 REQUIRED)
|
|||
find_package(Threads REQUIRED)
|
||||
|
||||
include_directories(
|
||||
../../include/hidapi
|
||||
${LIBUSB_1_INCLUDE_DIRS}) # for Lightpack device
|
||||
../../include/hidapi
|
||||
${LIBUSB_1_INCLUDE_DIRS}) # for Lightpack device
|
||||
|
||||
# Group the headers that go through the MOC compiler
|
||||
SET(Leddevice_QT_HEADERS
|
||||
|
|
@ -65,6 +65,17 @@ if(ENABLE_SPIDEV)
|
|||
)
|
||||
endif(ENABLE_SPIDEV)
|
||||
|
||||
if(ENABLE_TINKERFORGE)
|
||||
SET(Leddevice_HEADERS
|
||||
${Leddevice_HEADERS}
|
||||
${CURRENT_SOURCE_DIR}/LedDeviceTinkerforge.h
|
||||
)
|
||||
SET(Leddevice_SOURCES
|
||||
${Leddevice_SOURCES}
|
||||
${CURRENT_SOURCE_DIR}/LedDeviceTinkerforge.cpp
|
||||
)
|
||||
endif(ENABLE_TINKERFORGE)
|
||||
|
||||
|
||||
QT4_WRAP_CPP(Leddevice_HEADERS_MOC ${Leddevice_QT_HEADERS})
|
||||
|
||||
|
|
@ -76,12 +87,17 @@ add_library(leddevice
|
|||
)
|
||||
|
||||
target_link_libraries(leddevice
|
||||
hyperion-utils
|
||||
serialport
|
||||
${LIBUSB_1_LIBRARIES} #apt-get install libusb-1.0-0-dev
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
${QT_LIBRARIES}
|
||||
hyperion-utils
|
||||
serialport
|
||||
${LIBUSB_1_LIBRARIES} #apt-get install libusb-1.0-0-dev
|
||||
${CMAKE_THREAD_LIBS_INIT}
|
||||
${QT_LIBRARIES}
|
||||
)
|
||||
|
||||
if(ENABLE_TINKERFORGE)
|
||||
target_link_libraries(leddevice tinkerforge)
|
||||
endif()
|
||||
|
||||
if(APPLE)
|
||||
target_link_libraries(leddevice hidapi-mac)
|
||||
else()
|
||||
|
|
|
|||
|
|
@ -16,6 +16,10 @@
|
|||
#include "LedDeviceWs2801.h"
|
||||
#endif
|
||||
|
||||
#ifdef ENABLE_TINKERFORGE
|
||||
#include "LedDeviceTinkerforge.h"
|
||||
#endif
|
||||
|
||||
#include "LedDeviceAdalight.h"
|
||||
#include "LedDeviceLightpack.h"
|
||||
#include "LedDeviceMultiLightpack.h"
|
||||
|
|
@ -85,6 +89,20 @@ LedDevice * LedDeviceFactory::construct(const Json::Value & deviceConfig)
|
|||
|
||||
device = deviceWs2801;
|
||||
}
|
||||
#endif
|
||||
#ifdef ENABLE_TINKERFORGE
|
||||
else if (type=="tinkerforge")
|
||||
{
|
||||
const std::string host = deviceConfig.get("output", "127.0.0.1").asString();
|
||||
const uint16_t port = deviceConfig.get("port", 4223).asInt();
|
||||
const std::string uid = deviceConfig["uid"].asString();
|
||||
const unsigned rate = deviceConfig["rate"].asInt();
|
||||
|
||||
LedDeviceTinkerforge* deviceTinkerforge = new LedDeviceTinkerforge(host, port, uid, rate);
|
||||
deviceTinkerforge->open();
|
||||
|
||||
device = deviceTinkerforge;
|
||||
}
|
||||
#endif
|
||||
else if (type == "lightpack")
|
||||
{
|
||||
|
|
|
|||
|
|
@ -0,0 +1,143 @@
|
|||
|
||||
// STL includes
|
||||
#include <cerrno>
|
||||
#include <cstring>
|
||||
|
||||
// Local LedDevice includes
|
||||
#include "LedDeviceTinkerforge.h"
|
||||
|
||||
static const unsigned MAX_NUM_LEDS = 320;
|
||||
static const unsigned MAX_NUM_LEDS_SETTABLE = 16;
|
||||
|
||||
LedDeviceTinkerforge::LedDeviceTinkerforge(const std::string & host, uint16_t port, const std::string & uid, const unsigned interval) :
|
||||
LedDevice(),
|
||||
_host(host),
|
||||
_port(port),
|
||||
_uid(uid),
|
||||
_interval(interval),
|
||||
_ipConnection(nullptr),
|
||||
_ledStrip(nullptr),
|
||||
_colorChannelSize(0)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
LedDeviceTinkerforge::~LedDeviceTinkerforge()
|
||||
{
|
||||
// Close the device (if it is opened)
|
||||
if (_ipConnection != nullptr && _ledStrip != nullptr)
|
||||
{
|
||||
switchOff();
|
||||
}
|
||||
|
||||
// Clean up claimed resources
|
||||
delete _ipConnection;
|
||||
delete _ledStrip;
|
||||
}
|
||||
|
||||
int LedDeviceTinkerforge::open()
|
||||
{
|
||||
// Check if connection is already createds
|
||||
if (_ipConnection != nullptr)
|
||||
{
|
||||
std::cout << "Attempt to open existing connection; close before opening" << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Initialise a new connection
|
||||
_ipConnection = new IPConnection;
|
||||
ipcon_create(_ipConnection);
|
||||
|
||||
int connectionStatus = ipcon_connect(_ipConnection, _host.c_str(), _port);
|
||||
if (connectionStatus < 0)
|
||||
{
|
||||
std::cerr << "Attempt to connect to master brick (" << _host << ":" << _port << ") failed with status " << connectionStatus << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Create the 'LedStrip'
|
||||
_ledStrip = new LEDStrip;
|
||||
led_strip_create(_ledStrip, _uid.c_str(), _ipConnection);
|
||||
|
||||
int frameStatus = led_strip_set_frame_duration(_ledStrip, _interval);
|
||||
if (frameStatus < 0)
|
||||
{
|
||||
std::cerr << "Attempt to connect to led strip bricklet (led_strip_set_frame_duration()) failed with status " << frameStatus << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int LedDeviceTinkerforge::write(const std::vector<ColorRgb> &ledValues)
|
||||
{
|
||||
unsigned nrLedValues = ledValues.size();
|
||||
|
||||
if (nrLedValues > MAX_NUM_LEDS)
|
||||
{
|
||||
std::cerr << "Invalid attempt to write led values. Not more than " << MAX_NUM_LEDS << " leds are allowed." << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (_colorChannelSize < nrLedValues)
|
||||
{
|
||||
_redChannel.resize(nrLedValues, uint8_t(0));
|
||||
_greenChannel.resize(nrLedValues, uint8_t(0));
|
||||
_blueChannel.resize(nrLedValues, uint8_t(0));
|
||||
}
|
||||
_colorChannelSize = nrLedValues;
|
||||
|
||||
auto redIt = _redChannel.begin();
|
||||
auto greenIt = _greenChannel.begin();
|
||||
auto blueIt = _blueChannel.begin();
|
||||
|
||||
for (const ColorRgb &ledValue : ledValues)
|
||||
{
|
||||
*redIt = ledValue.red;
|
||||
++redIt;
|
||||
*greenIt = ledValue.green;
|
||||
++greenIt;
|
||||
*blueIt = ledValue.blue;
|
||||
++blueIt;
|
||||
}
|
||||
|
||||
return transferLedData(_ledStrip, 0, _colorChannelSize, _redChannel.data(), _greenChannel.data(), _blueChannel.data());
|
||||
}
|
||||
|
||||
int LedDeviceTinkerforge::switchOff()
|
||||
{
|
||||
std::fill(_redChannel.begin(), _redChannel.end(), 0);
|
||||
std::fill(_greenChannel.begin(), _greenChannel.end(), 0);
|
||||
std::fill(_blueChannel.begin(), _blueChannel.end(), 0);
|
||||
|
||||
return transferLedData(_ledStrip, 0, _colorChannelSize, _redChannel.data(), _greenChannel.data(), _blueChannel.data());
|
||||
}
|
||||
|
||||
int LedDeviceTinkerforge::transferLedData(LEDStrip *ledStrip, unsigned index, unsigned length, uint8_t *redChannel, uint8_t *greenChannel, uint8_t *blueChannel)
|
||||
{
|
||||
if (length == 0 || index >= length || length > MAX_NUM_LEDS)
|
||||
{
|
||||
return E_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
uint8_t reds[MAX_NUM_LEDS_SETTABLE];
|
||||
uint8_t greens[MAX_NUM_LEDS_SETTABLE];
|
||||
uint8_t blues[MAX_NUM_LEDS_SETTABLE];
|
||||
|
||||
for (unsigned i=index; i<length; i+=MAX_NUM_LEDS_SETTABLE)
|
||||
{
|
||||
const unsigned copyLength = (i + MAX_NUM_LEDS_SETTABLE > length) ? length - i : MAX_NUM_LEDS_SETTABLE;
|
||||
memcpy(reds, redChannel + i, copyLength);
|
||||
memcpy(greens, greenChannel + i, copyLength);
|
||||
memcpy(blues, blueChannel + i, copyLength);
|
||||
|
||||
const int status = led_strip_set_rgb_values(ledStrip, i, copyLength, reds, greens, blues);
|
||||
if (status != E_OK)
|
||||
{
|
||||
std::cerr << "Setting led values failed with status " << status << std::endl;
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
return E_OK;
|
||||
}
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
// STL includes
|
||||
#include <cstdio>
|
||||
|
||||
// Hyperion-Leddevice includes
|
||||
#include <leddevice/LedDevice.h>
|
||||
|
||||
|
||||
extern "C" {
|
||||
#include <tinkerforge/ip_connection.h>
|
||||
#include <tinkerforge/bricklet_led_strip.h>
|
||||
}
|
||||
|
||||
class LedDeviceTinkerforge : public LedDevice
|
||||
{
|
||||
public:
|
||||
|
||||
LedDeviceTinkerforge(const std::string &host, uint16_t port, const std::string &uid, const unsigned interval);
|
||||
|
||||
virtual ~LedDeviceTinkerforge();
|
||||
|
||||
///
|
||||
/// Attempts to open a connection to the master bricklet and the led strip bricklet.
|
||||
///
|
||||
/// @return Zero on succes else negative
|
||||
///
|
||||
int open();
|
||||
|
||||
///
|
||||
/// Writes the colors to the led strip bricklet
|
||||
///
|
||||
/// @param ledValues The color value for each led
|
||||
///
|
||||
/// @return Zero on success else negative
|
||||
///
|
||||
virtual int write(const std::vector<ColorRgb> &ledValues);
|
||||
|
||||
///
|
||||
/// Switches off the leds
|
||||
///
|
||||
/// @return Zero on success else negative
|
||||
///
|
||||
virtual int switchOff();
|
||||
|
||||
private:
|
||||
///
|
||||
/// Writes the data to the led strip blicklet
|
||||
int transferLedData(LEDStrip *ledstrip, unsigned int index, unsigned int length, uint8_t *redChannel, uint8_t *greenChannel, uint8_t *blueChannel);
|
||||
|
||||
/// The host of the master brick
|
||||
const std::string _host;
|
||||
|
||||
/// The port of the master brick
|
||||
const uint16_t _port;
|
||||
|
||||
/// The uid of the led strip bricklet
|
||||
const std::string _uid;
|
||||
|
||||
/// The interval/rate
|
||||
const unsigned _interval;
|
||||
|
||||
/// ip connection handle
|
||||
IPConnection *_ipConnection;
|
||||
|
||||
/// led strip handle
|
||||
LEDStrip *_ledStrip;
|
||||
|
||||
/// buffer for red channel led data
|
||||
std::vector<uint8_t> _redChannel;
|
||||
|
||||
/// buffer for red channel led data
|
||||
std::vector<uint8_t> _greenChannel;
|
||||
|
||||
/// buffer for red channel led data
|
||||
std::vector<uint8_t> _blueChannel;
|
||||
|
||||
/// buffer size of the color channels
|
||||
unsigned int _colorChannelSize;
|
||||
|
||||
};
|
||||
Loading…
Reference in New Issue