From 4da559091678dddb4c0392459ce41f2fa0821f72 Mon Sep 17 00:00:00 2001 From: Romain Forlot Date: Thu, 2 Feb 2017 22:43:17 +0000 Subject: Adding header files to get implemented ! Change-Id: Ie4876b3c053988554a97868681b7b08f9c486111 Signed-off-by: Romain Forlot --- can-signals.h | 85 +++++++ can-utils.h | 328 ++++++++++++++++++++++++++ ll-can-binding.c | 660 ----------------------------------------------------- ll-can-binding.cpp | 660 +++++++++++++++++++++++++++++++++++++++++++++++++++++ timer.h | 32 +++ 5 files changed, 1105 insertions(+), 660 deletions(-) create mode 100644 can-signals.h create mode 100644 can-utils.h delete mode 100644 ll-can-binding.c create mode 100644 ll-can-binding.cpp create mode 100644 timer.h diff --git a/can-signals.h b/can-signals.h new file mode 100644 index 0000000..3cbbe20 --- /dev/null +++ b/can-signals.h @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include "can-utils.h" + +/** Public: Return the currently active CAN configuration. */ +CanMessageSet* getActiveMessageSet(); + +/** Public: Retrive a list of all possible CAN configurations. + * * + * * Returns a pointer to an array of all configurations. + * */ +CanMessageSet* getMessageSets(); + +/** Public: Return the length of the array returned by getMessageSets() */ +int getMessageSetCount(); + +/* Public: Return the number of CAN buses configured in the active + * * configuration. This is limited to 2, as the hardware controller only has 2 + * * CAN channels. + * */ +int getCanBusCount(); + +/* Public: Return an array of all CAN messages to be processed in the active + * * configuration. + * */ +CanMessageDefinition* getMessages(); + +/* Public: Return an array of all CAN signals to be processed in the active + * * configuration. + * */ +CanSignal* getSignals(); + +/* Public: Return an array of all OpenXC CAN commands enabled in the active + * * configuration that can write back to CAN with a custom handler. + * * + * * Commands not defined here are handled using a 1-1 mapping from the signals + * * list. + * */ +CanCommand* getCommands(); + +/* Public: Return the length of the array returned by getCommandCount(). */ +int getCommandCount(); + +/* Public: Return the length of the array returned by getSignals(). */ +int getSignalCount(); + +/* Public: Return the length of the array returned by getMessages(). */ +int getMessageCount(); + +/* Public: Return an array of the metadata for the 2 CAN buses you want to + * * monitor. The size of this array is fixed at 2. + * */ +CanBus* getCanBuses(); + +/* Public: Decode CAN signals from raw CAN messages, translate from engineering + * * units to something more human readable, and send the resulting value over USB + * * as an OpenXC-style JSON message. + * * + * * This is the main workhorse function of the VI. Every time a new + * * CAN message is received that matches one of the signals in the list returend + * * by getSignals(), this function is called with the message ID and 64-bit data + * * field. + * * + * * bus - The CAN bus this message was received on. + * * message - The received CAN message. + * */ +void decodeCanMessage(openxc::pipeline::Pipeline* pipeline, CanBus* bus, CanMessage* message); + diff --git a/can-utils.h b/can-utils.h new file mode 100644 index 0000000..7d00dd1 --- /dev/null +++ b/can-utils.h @@ -0,0 +1,328 @@ + +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include "timer.h" +#include "openxc.pb.h" + +// TODO actual max is 32 but dropped to 24 for memory considerations +#define MAX_ACCEPTANCE_FILTERS 24 +// TODO this takes up a ton of memory +#define MAX_DYNAMIC_MESSAGE_COUNT 12 + +#define CAN_MESSAGE_SIZE 8 + +#define CAN_ACTIVE_TIMEOUT_S 30 + +#define QUEUE_DECLARE(type, max_length) \ +static const int queue_##type##_max_length = max_length; \ +static const int queue_##type##_max_internal_length = max_length + 1; \ +typedef struct queue_##type##_s { \ + int head; \ + int tail; \ + type elements[max_length + 1]; \ +} queue_##type; \ +\ +bool queue_##type##_push(queue_##type* queue, type value); \ +\ +type queue_##type##_pop(queue_##type* queue); \ +\ +type queue_##type##_peek(queue_##type* queue); \ +void queue_##type##_init(queue_##type* queue); \ +int queue_##type##_length(queue_##type* queue); \ +int queue_##type##_available(queue_##type* queue); \ +bool queue_##type##_full(queue_##type* queue); \ +bool queue_##type##_empty(queue_##type* queue); \ +void queue_##type##_snapshot(queue_##type* queue, type* snapshot, int max); + +/* Public: The type signature for a CAN signal decoder. + * + * A SignalDecoder transforms a raw floating point CAN signal into a number, + * string or boolean. + * + * signal - The CAN signal that we are decoding. + * signals - The list of all signals. + * signalCount - The length of the signals array. + * pipeline - you may want to generate arbitrary additional messages for + * publishing. + * value - The CAN signal parsed from the message as a raw floating point + * value. + * send - An output parameter. If the decoding failed or the CAN signal should + * not send for some other reason, this should be flipped to false. + * + * Returns a decoded value in an openxc_DynamicField struct. + */ +typedef openxc_DynamicField (*SignalDecoder)(struct CanSignal* signal, + CanSignal* signals, int signalCount, + openxc::pipeline::Pipeline* pipeline, float value, bool* send); + +/* Public: The type signature for a CAN signal encoder. + * + * A SignalEncoder transforms a number, string or boolean into a raw floating + * point value that fits in the CAN signal. + * + * signal - The CAN signal to encode. + * value - The dynamic field to encode. + * send - An output parameter. If the encoding failed or the CAN signal should + * not be encoded for some other reason, this will be flipped to false. + */ +typedef uint64_t (*SignalEncoder)(struct CanSignal* signal, + openxc_DynamicField* value, bool* send); + +/* Public: The ID format for a CAN message. + * + * STANDARD - standard 11-bit CAN arbitration ID. + * EXTENDED - an extended frame, with a 29-bit arbitration ID. + */ +enum CanMessageFormat { + STANDARD, + EXTENDED, +}; +typedef enum CanMessageFormat CanMessageFormat; + +/* Public: A state encoded (SED) signal's mapping from numerical values to + * OpenXC state names. + * + * value - The integer value of the state on the CAN bus. + * name - The corresponding string name for the state in OpenXC. + */ +struct CanSignalState { + const int value; + const char* name; +}; +typedef struct CanSignalState CanSignalState; + +/* Public: A CAN signal to decode from the bus and output over USB. + * + * message - The message this signal is a part of. + * genericName - The name of the signal to be output over USB. + * bitPosition - The starting bit of the signal in its CAN message (assuming + * non-inverted bit numbering, i.e. the most significant bit of + * each byte is 0) + * bitSize - The width of the bit field in the CAN message. + * factor - The final value will be multiplied by this factor. Use 1 if you + * don't need a factor. + * offset - The final value will be added to this offset. Use 0 if you + * don't need an offset. + * minValue - The minimum value for the processed signal. + * maxValue - The maximum value for the processed signal. + * frequencyClock - A FrequencyClock struct to control the maximum frequency to + * process and send this signal. To process every value, set the + * clock's frequency to 0. + * sendSame - If true, will re-send even if the value hasn't changed. + * forceSendChanged - If true, regardless of the frequency, it will send the + * value if it has changed. + * states - An array of CanSignalState describing the mapping + * between numerical and string values for valid states. + * stateCount - The length of the states array. + * writable - True if the signal is allowed to be written from the USB host + * back to CAN. Defaults to false. + * decoder - An optional function to decode a signal from the bus to a human + * readable value. If NULL, the default numerical decoder is used. + * encoder - An optional function to encode a signal value to be written to + * CAN into a byte array. If NULL, the default numerical encoder + * is used. + * received - True if this signal has ever been received. + * lastValue - The last received value of the signal. If 'received' is false, + * this value is undefined. + */ +struct CanSignal { + struct CanMessageDefinition* message; + const char* genericName; + uint8_t bitPosition; + uint8_t bitSize; + float factor; + float offset; + float minValue; + float maxValue; + FrequencyClock frequencyClock; + bool sendSame; + bool forceSendChanged; + const CanSignalState* states; + uint8_t stateCount; + bool writable; + SignalDecoder decoder; + SignalEncoder encoder; + bool received; + float lastValue; +}; +typedef struct CanSignal CanSignal; + +/* Public: The definition of a CAN message. This includes a lot of metadata, so + * to save memory this struct should not be used for storing incoming and + * outgoing CAN messages. + * + * bus - A pointer to the bus this message is on. + * id - The ID of the message. + * format - the format of the message's ID. + * frequencyClock - an optional frequency clock to control the output of this + * message, if sent raw, or simply to mark the max frequency for custom + * handlers to retrieve. + * forceSendChanged - If true, regardless of the frequency, it will send CAN + * message if it has changed when using raw passthrough. + * lastValue - The last received value of the message. Defaults to undefined. + * This is required for the forceSendChanged functionality, as the stack + * needs to compare an incoming CAN message with the previous frame. + */ +struct CanMessageDefinition { + struct CanBus* bus; + uint32_t id; + CanMessageFormat format; + FrequencyClock frequencyClock; + bool forceSendChanged; + uint8_t lastValue[CAN_MESSAGE_SIZE]; +}; +typedef struct CanMessageDefinition CanMessageDefinition; + +/* A compact representation of a single CAN message, meant to be used in in/out + * buffers. + * + * id - The ID of the message. + * format - the format of the message's ID. + * data - The message's data field. + * length - the length of the data array (max 8). + */ +struct CanMessage { + uint32_t id; + CanMessageFormat format; + uint8_t data[CAN_MESSAGE_SIZE]; + uint8_t length; +}; +typedef struct CanMessage CanMessage; + +QUEUE_DECLARE(CanMessage, 8); + +/* Private: An entry in the list of acceptance filters for each CanBus. + * + * This struct is meant to be used with a LIST type from . + * + * filter - the value for the CAN acceptance filter. + * activeUserCount - The number of active consumers of this filter's messages. + * When 0, this filter can be removed. + * format - the format of the ID for the filter. +struct AcceptanceFilterListEntry { + uint32_t filter; + uint8_t activeUserCount; + CanMessageFormat format; + LIST_ENTRY(AcceptanceFilterListEntry) entries; +}; + */ + +/* Private: A type of list containing CAN acceptance filters. +LIST_HEAD(AcceptanceFilterList, AcceptanceFilterListEntry); + +struct CanMessageDefinitionListEntry { + CanMessageDefinition definition; + LIST_ENTRY(CanMessageDefinitionListEntry) entries; +}; +LIST_HEAD(CanMessageDefinitionList, CanMessageDefinitionListEntry); + */ + +/** Public: A parent wrapper for a particular set of CAN messages and associated + * CAN buses(e.g. a vehicle or program). + * + * index - A numerical ID for the message set, ideally the index in an array + * for fast lookup + * name - The name of the message set. + * busCount - The number of CAN buses defined for this message set. + * messageCount - The number of CAN messages (across all buses) defined for + * this message set. + * signalCount - The number of CAN signals (across all messages) defined for + * this message set. + * commandCount - The number of CanCommmands defined for this message set. + */ +typedef struct { + uint8_t index; + const char* name; + uint8_t busCount; + unsigned short messageCount; + unsigned short signalCount; + unsigned short commandCount; +} CanMessageSet; + +/* Public: The type signature for a function to handle a custom OpenXC command. + * + * name - the name of the received command. + * value - the value of the received command, in a DynamicField. The actual type + * may be a number, string or bool. + * event - an optional event from the received command, in a DynamicField. The + * actual type may be a number, string or bool. + * signals - The list of all signals. + * signalCount - The length of the signals array. + */ +typedef void (*CommandHandler)(const char* name, openxc_DynamicField* value, + openxc_DynamicField* event, CanSignal* signals, int signalCount); + +/* Public: The structure to represent a supported custom OpenXC command. + * + * For completely customized CAN commands without a 1-1 mapping between an + * OpenXC message from the host and a CAN signal, you can define the name of the + * command and a custom function to handle it in the VI. An example is + * the "turn_signal_status" command in OpenXC, which has a value of "left" or + * "right". The vehicle may have separate CAN signals for the left and right + * turn signals, so you will need to implement a custom command handler to send + * the correct signals. + * + * Command handlers are also useful if you want to trigger multiple CAN messages + * or signals from a signal OpenXC message. + * + * genericName - The name of the command. + * handler - An function to process the received command's data and perform some + * action. + */ +typedef struct { + const char* genericName; + CommandHandler handler; +} CanCommand; + +/* Pre initialize actions made before CAN bus initialization + * + * bus - A CanBus struct defining the bus's metadata + * writable - configure the controller in a writable mode. If false, it will be + * configured as "listen only" and will not allow writes or even CAN ACKs. + * buses - An array of all CAN buses. + * busCount - The length of the buses array. + */ +void pre_initialize(CanBus* bus, bool writable, CanBus* buses, const int busCount); + +/* Post-initialize actions made after CAN bus initialization and before the + * event loop connection. + * + * bus - A CanBus struct defining the bus's metadata + * writable - configure the controller in a writable mode. If false, it will be + * configured as "listen only" and will not allow writes or even CAN ACKs. + * buses - An array of all CAN buses. + * busCount - The length of the buses array. + */ +void post_initialize(CanBus* bus, bool writable, CanBus* buses, const int busCount); + +/* Public: Check if the device is connected to an active CAN bus, i.e. it's + * received a message in the recent past. + * + * Returns true if a message was received on the CAN bus within + * CAN_ACTIVE_TIMEOUT_S seconds. + */ +bool isBusActive(CanBus* bus); + +/* Public: Log transfer statistics about all active CAN buses to the debug log. + * + * buses - an array of active CAN buses. + * busCount - the length of the buses array. + */ +void logBusStatistics(CanBus* buses, const int busCount); diff --git a/ll-can-binding.c b/ll-can-binding.c deleted file mode 100644 index 8f96d7b..0000000 --- a/ll-can-binding.c +++ /dev/null @@ -1,660 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include -#include - -#include "ll-can-binding.h" -#include "obd2.h" - -/*************************************************************************/ -/*************************************************************************/ -/** **/ -/** **/ -/** SECTION: UTILITY FUNCTIONS **/ -/** **/ -/** **/ -/*************************************************************************/ -/*************************************************************************/ - -/* - * Retry a function 3 times - * - * param int function(): function that return an int wihtout any parameter - * - * return : 0 if ok, -1 if failed - * - */ -static int retry( int(*func)()) -{ - int i; - - for (i=0;i<4;i++) - { - if ( (*func)() >= 0) - { - return 0; - } - usleep(100000); - } - return -1; -} - -/* - * Test that socket is really opened - * - * param - * - * return : 0 or positive int if ok, negative value if failed - * - */ -static int socket_test() -{ - if (can_handler.socket < 0) - { - return -1; - } - return 0; -} - -/* - * Browse chained list and return the one with specified id - * - * param uint32_t id : can arbitration identifier - * - * return can_event - */ -static can_event *get_event_list_of_id(uint32_t id) -{ - can_event *current; - - /* create and return if lists not exists */ - if (!can_events_list) - { - can_events_list = (can_event*)calloc(1, sizeof(can_event)); - can_events_list->id = id; - return can_events_list; - } - - /* search for id */ - current = can_events_list; - while(current) - { - if (current->id == id) - return current; - if (!current->next) - { - current->next = (can_event*)calloc(1, sizeof(can_event)); - current->next->id = id; - return current->next; - } - current = current->next; - } - - return NULL; -} - -/* - * Take an id and return it into a char array - */ -static char* create_name(uint32_t id) -{ - char name[32]; - size_t nchar; - - nchar = (size_t)sprintf(name, "can_%u", id); - if (nchar > 0) - { - char *result = (char*)malloc(nchar + 1); - memcpy(result, name, nchar); - result[nchar] = 0; - return result; - } - - return NULL; -} - -/* - * Create json object that will be pushed through event_loop to any subscriber - * - * param : openxc_CanMessage structure complete with data to put into json - * object. - * - * return : json object - */ -static json_object* create_json_from_openxc_CanMessage(event *event) -{ - struct json_object *json; - - /* - * TODO: process the openxc_CanMessage struct. Should be a call to a - * decoder function relative to that msg - - openxc_CanMessage can_message; - can_message = event->can_message; - */ - - json = json_object_new_object(); - json_object_object_add(json, "name", json_object_new_string(event->name)); - - return json; -} - -/*************************************************************************/ -/*************************************************************************/ -/** **/ -/** **/ -/** SECTION: HANDLE CAN DEVICE **/ -/** **/ -/** **/ -/*************************************************************************/ -/*************************************************************************/ -/* - * open the can socket - */ -static int open_can_dev() -{ - const int canfd_on = 1; - struct ifreq ifr; - struct timeval timeout = {1,0}; - - DEBUG(interface, "open_can_dev: CAN Handler socket : %d", can_handler.socket); - if (can_handler.socket >= 0) - close(can_handler.socket); - - can_handler.socket = socket(PF_CAN, SOCK_RAW, CAN_RAW); - if (can_handler.socket < 0) - { - ERROR(interface, "open_can_dev: socket could not be created"); - } - else - { - /* Set timeout for read */ - setsockopt(can_handler.socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)); - /* try to switch the socket into CAN_FD mode */ - if (setsockopt(can_handler.socket, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)) < 0) - { - NOTICE(interface, "open_can_dev: Can not switch into CAN Extended frame format."); - can_handler.is_fdmode_on = false; - } else { - can_handler.is_fdmode_on = true; - } - - /* Attempts to open a socket to CAN bus */ - strcpy(ifr.ifr_name, can_handler.device); - if(ioctl(can_handler.socket, SIOCGIFINDEX, &ifr) < 0) - ERROR(interface, "open_can_dev: ioctl failed"); - else - { - can_handler.txAddress.can_family = AF_CAN; - can_handler.txAddress.can_ifindex = ifr.ifr_ifindex; - - /* And bind it to txAddress */ - if (bind(can_handler.socket, (struct sockaddr *)&can_handler.txAddress, sizeof(can_handler.txAddress)) < 0) - { - ERROR(interface, "open_can_dev: bind failed"); - } - else - { - fcntl(can_handler.socket, F_SETFL, O_NONBLOCK); - return 0; - } - } - close(can_handler.socket); - can_handler.socket = -1; - } - return -1; -} - -/* - * TODO : test that socket is really opened - */ -static int write_can() -{ - ssize_t nbytes; - int rc; - - rc = can_handler.socket; - if (rc >= 0) - { -/* - * TODO change old hvac write can frame to generic on_event - */ - nbytes = sendto(can_handler.socket, &canfd_frame, sizeof(struct canfd_frame), 0, - (struct sockaddr*)&can_handler.txAddress, sizeof(can_handler.txAddress)); - if (nbytes < 0) - { - ERROR(interface, "write_can: Sending CAN frame failed."); - } - } - else - { - ERROR(interface, "write_can: socket not initialized. Attempt to reopen can device socket."); - retry(open_can_dev); - } - return rc; -} - -/* - * Parse the CAN frame data payload as a CAN packet - * TODO: parse as an OpenXC Can Message. Don't translate as ASCII and put bytes - * directly into openxc_CanMessage - */ -static int parse_can_frame(openxc_CanMessage *can_message, struct canfd_frame *canfd_frame, int maxdlen) -{ - int i, len; - //size_t n_msg; - - len = (canfd_frame->len > maxdlen) ? maxdlen : canfd_frame->len; - - can_message->has_id = true; - if (canfd_frame->can_id & CAN_ERR_FLAG) - can_message->id = canfd_frame->can_id & (CAN_ERR_MASK|CAN_ERR_FLAG); - else if (canfd_frame->can_id & CAN_EFF_FLAG) - { - can_message->has_frame_format = true; - can_message->frame_format = openxc_CanMessage_FrameFormat_EXTENDED; - can_message->id = canfd_frame->can_id & CAN_EFF_MASK; - } else - { - can_message->has_frame_format = true; - can_message->frame_format = openxc_CanMessage_FrameFormat_STANDARD; - can_message->id = canfd_frame->can_id & CAN_SFF_MASK; - } - - /* Don't know what to do with that for now as we haven't - * len fields in openxc_CanMessage struct - - * standard CAN frames may have RTR enabled. There are no ERR frames with RTR - if (maxdlen == CAN_MAX_DLEN && canfd_frame->can_id & CAN_RTR_FLAG) - { - // print a given CAN 2.0B DLC if it's not zero - if (canfd_frame->len && canfd_frame->len <= CAN_MAX_DLC) - buf[offset++] = hex_asc_upper[canfd_frame->len & 0xF]; - - buf[offset] = 0; - return NULL; - } - */ - - /* Doesn't handle real canfd_frame for now - if (maxdlen == CANFD_MAX_DLEN) - { - // add CAN FD specific escape char and flags - canfd_frame->flags & 0xF; - } */ - - if (sizeof(canfd_frame->data) <= sizeof(can_message->data.bytes)) - { - for (i = 0; i < len; i++) - can_message->data.bytes[i] = canfd_frame->data[i]; - return 0; - } else if (sizeof(canfd_frame->data) <= CAN_MAX_DLEN) - { - ERROR(interface, "parse_can_frame: can_frame data too long to be stored into openxc_CanMessage data field"); - return -1; - /* TODO create as many as needed openxc_CanMessage into an array to store all data from canfd_frame - n_msg = CAN_MAX_DLEN / sizeof(canfd_frame->data.bytes); - for (i = 0; i < len; i++) - can_message->data.bytes[i] = canfd_frame->data[i]; */ - } else - { - ERROR(interface, "parse_can_frame: can_frame is really too long here. Size of data greater than canfd maximum 64bytes size. Is it a CAN message ?"); - return -2; - } - - /* You should not reach this return statement */ - return -3; -} - - -/* - * Read on CAN bus and return how much bytes has been read. - */ -static int read_can(openxc_CanMessage *can_message) -{ - ssize_t nbytes; - int maxdlen; - - /* Test that socket is really opened */ - if ( socket_test() < 0) - { - if (retry(open_can_dev) < 0) - { - ERROR(interface, "read_can: Socket unavailable"); - return -1; - } - } - - nbytes = read(can_handler.socket, &canfd_frame, CANFD_MTU); - - if (nbytes == CANFD_MTU) - { - DEBUG(interface, "read_can: Got an CAN FD frame with length %d", canfd_frame.len); - } - else if (nbytes == CAN_MTU) - { - DEBUG(interface, "read_can: Got a legacy CAN frame with length %d", canfd_frame.len); - } - else - { - if (errno == ENETDOWN) - ERROR(interface, "read_can: %s interface down", can_handler.device); - ERROR(interface, "read_can: Error reading CAN bus"); - return -2; - } - - /* CAN frame integrity check */ - if ((size_t)nbytes == CAN_MTU) - maxdlen = CAN_MAX_DLEN; - else if ((size_t)nbytes == CANFD_MTU) - maxdlen = CANFD_MAX_DLEN; - else - { - ERROR(interface, "read_can: CAN frame incomplete"); - return -3; - } - - if (parse_can_frame(can_message, &canfd_frame, maxdlen)) - { - ERROR(interface, "read_can: Can't parse the can frame. ID: %i, DLC: %i, DATA: %s", - canfd_frame.can_id, canfd_frame.len, canfd_frame.data); - return -4; - } - - return 0; -} -/*************************************************************************/ -/*************************************************************************/ -/** **/ -/** **/ -/** SECTION: MANAGING EVENTS **/ -/** **/ -/** **/ -/*************************************************************************/ -/*************************************************************************/ -static int on_event(sd_event_source *s, int fd, uint32_t revents, void *userdata); - -/* - * Get the event loop running. - * Will trigger on_event function on EPOLLIN event on socket - * - * Return 0 or positive value on success. Else negative value for failure. - */ -static int connect_to_event_loop() -{ - sd_event *event_loop; - sd_event_source *source; - int rc; - - if (can_handler.socket < 0) - { - return can_handler.socket; - } - - event_loop = afb_daemon_get_event_loop(interface->daemon); - rc = sd_event_add_io(event_loop, &source, can_handler.socket, EPOLLIN, on_event, NULL); - if (rc < 0) - { - close(can_handler.socket); - ERROR(interface, "Can't connect CAN bus %s to the event loop", can_handler.device); - } else - { - NOTICE(interface, "Connected CAN bus %s to the event loop", can_handler.device); - } - - return rc; -} -/* - * Send all events - */ -static void send_event() -{ - can_event *current; - event *events; - json_object *object; - - /* Browse can_events */ - current = can_events_list; - while(current) - { - /* Browse event for each can_events no matter what the id */ - events = current->events; - while(events) - { - object = create_json_from_openxc_CanMessage(events); - afb_event_push(events->afb_event, object); - events = events->next; - } - current = current->next; - } -} - -/* - * called on an event on the CAN bus - */ -static int on_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) -{ - openxc_CanMessage can_message; - - can_message = openxc_CanMessage_init_default; - - /* read available data */ - if ((revents & EPOLLIN) != 0) - { - read_can(&can_message); - send_event(); - } - - /* check if error or hangup */ - if ((revents & (EPOLLERR|EPOLLRDHUP|EPOLLHUP)) != 0) - { - sd_event_source_unref(s); - close(fd); - connect_to_event_loop(); - } - - return 0; -} - -/* - * get or create an event handler for the type - */ -static event *get_event(uint32_t id, enum type type) -{ - event *event_elt; - can_event *list; - - /* find the can list by id */ - list = get_event_list_of_id(id); - - /* make the new event */ - event_elt = (event*)calloc(1, sizeof(event)); - event_elt->next = event_elt; - list->events = event_elt; - event_elt->name = create_name(id); - event_elt->afb_event = afb_daemon_make_event(interface->daemon, event_elt->name); - - return event_elt; -} - -/*************************************************************************/ -/*************************************************************************/ -/** **/ -/** **/ -/** SECTION: BINDING VERBS IMPLEMENTATION **/ -/** **/ -/** **/ -/*************************************************************************/ -/*************************************************************************/ -/* - * Returns the type corresponding to the given name - */ -static enum type type_of_name(const char *name) -{ - enum type result; - if (name == NULL) - return type_DEFAULT; - for (result = 0 ; (size_t)result < type_size; result++) - if (strcmp(type_NAMES[result], name) == 0) - return result; - return type_INVALID; -} - -/* - * extract a valid type from the request - */ -static int get_type_for_req(struct afb_req req, enum type *type) -{ - if ((*type = type_of_name(afb_req_value(req, "type"))) != type_INVALID) - return 1; - afb_req_fail(req, "unknown-type", NULL); - return 0; -} - -static int subscribe_unsubscribe_sig(struct afb_req request, int subscribe, struct signal *sig) -{ - if (!afb_event_is_valid(sig->event)) { - if (!subscribe) - return 1; - sig->event = afb_daemon_make_event(afbitf->daemon, sig->name); - if (!afb_event_is_valid(sig->event)) { - return 0; - } - } - - if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, sig->event)) < 0) { - return 0; - } - - return 1; -} - -static int subscribe_unsubscribe_all(struct afb_req request, int subscribe) -{ - int i, n, e; - - n = sizeof OBD2_PIDS / sizeof * OBD2_PIDS; - e = 0; - for (i = 0 ; i < n ; i++) - e += !subscribe_unsubscribe_sig(request, subscribe, &OBD2_PIDS[i]); - return e == 0; -} - -static int subscribe_unsubscribe_name(struct afb_req request, int subscribe, const char *name) -{ - struct signal *sig; - - if (0 == strcmp(name, "*")) - return subscribe_unsubscribe_all(request, subscribe); - - sig = getsig(name); - if (sig == NULL) { - return 0; - } - - return subscribe_unsubscribe_sig(request, subscribe, sig); -} - -static void subscribe_unsubscribe(struct afb_req request, int subscribe) -{ - int ok, i, n; - struct json_object *args, *a, *x; - - /* makes the subscription/unsubscription */ - args = afb_req_json(request); - if (args == NULL || !json_object_object_get_ex(args, "event", &a)) { - ok = subscribe_unsubscribe_all(request, subscribe); - } else if (json_object_get_type(a) != json_type_array) { - ok = subscribe_unsubscribe_name(request, subscribe, json_object_get_string(a)); - } else { - n = json_object_array_length(a); - ok = 0; - for (i = 0 ; i < n ; i++) { - x = json_object_array_get_idx(a, i); - if (subscribe_unsubscribe_name(request, subscribe, json_object_get_string(x))) - ok++; - } - ok = (ok == n); - } - - /* send the report */ - if (ok) - afb_req_success(request, NULL, NULL); - else - afb_req_fail(request, "error", NULL); -} - -static void subscribe(struct afb_req request) -{ - subscribe_unsubscribe(request, 1); -} - -static void unsubscribe(struct afb_req request) -{ - subscribe_unsubscribe(request, 0); -} - -static const struct afb_verb_desc_v1 verbs[]= -{ - { .name= "subscribe", .session= AFB_SESSION_NONE, .callback= subscribe, .info= "subscribe to notification of CAN bus messages." }, - { .name= "unsubscribe", .session= AFB_SESSION_NONE, .callback= unsubscribe, .info= "unsubscribe a previous subscription." }, - {NULL} -}; - -static const struct afb_binding binding_desc = { - .type = AFB_BINDING_VERSION_1, - .v1 = { - .info = "CAN bus service", - .prefix = "can", - .verbs = verbs - } -}; - -const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) -{ - interface = itf; - - return &binding_desc; -} - -int afbBindingV1ServiceInit(struct afb_service service) -{ - /* Open CAN socket */ - retry(open_can_dev); - return connect_to_event_loop(); -} diff --git a/ll-can-binding.cpp b/ll-can-binding.cpp new file mode 100644 index 0000000..8f96d7b --- /dev/null +++ b/ll-can-binding.cpp @@ -0,0 +1,660 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#include "ll-can-binding.h" +#include "obd2.h" + +/*************************************************************************/ +/*************************************************************************/ +/** **/ +/** **/ +/** SECTION: UTILITY FUNCTIONS **/ +/** **/ +/** **/ +/*************************************************************************/ +/*************************************************************************/ + +/* + * Retry a function 3 times + * + * param int function(): function that return an int wihtout any parameter + * + * return : 0 if ok, -1 if failed + * + */ +static int retry( int(*func)()) +{ + int i; + + for (i=0;i<4;i++) + { + if ( (*func)() >= 0) + { + return 0; + } + usleep(100000); + } + return -1; +} + +/* + * Test that socket is really opened + * + * param + * + * return : 0 or positive int if ok, negative value if failed + * + */ +static int socket_test() +{ + if (can_handler.socket < 0) + { + return -1; + } + return 0; +} + +/* + * Browse chained list and return the one with specified id + * + * param uint32_t id : can arbitration identifier + * + * return can_event + */ +static can_event *get_event_list_of_id(uint32_t id) +{ + can_event *current; + + /* create and return if lists not exists */ + if (!can_events_list) + { + can_events_list = (can_event*)calloc(1, sizeof(can_event)); + can_events_list->id = id; + return can_events_list; + } + + /* search for id */ + current = can_events_list; + while(current) + { + if (current->id == id) + return current; + if (!current->next) + { + current->next = (can_event*)calloc(1, sizeof(can_event)); + current->next->id = id; + return current->next; + } + current = current->next; + } + + return NULL; +} + +/* + * Take an id and return it into a char array + */ +static char* create_name(uint32_t id) +{ + char name[32]; + size_t nchar; + + nchar = (size_t)sprintf(name, "can_%u", id); + if (nchar > 0) + { + char *result = (char*)malloc(nchar + 1); + memcpy(result, name, nchar); + result[nchar] = 0; + return result; + } + + return NULL; +} + +/* + * Create json object that will be pushed through event_loop to any subscriber + * + * param : openxc_CanMessage structure complete with data to put into json + * object. + * + * return : json object + */ +static json_object* create_json_from_openxc_CanMessage(event *event) +{ + struct json_object *json; + + /* + * TODO: process the openxc_CanMessage struct. Should be a call to a + * decoder function relative to that msg + + openxc_CanMessage can_message; + can_message = event->can_message; + */ + + json = json_object_new_object(); + json_object_object_add(json, "name", json_object_new_string(event->name)); + + return json; +} + +/*************************************************************************/ +/*************************************************************************/ +/** **/ +/** **/ +/** SECTION: HANDLE CAN DEVICE **/ +/** **/ +/** **/ +/*************************************************************************/ +/*************************************************************************/ +/* + * open the can socket + */ +static int open_can_dev() +{ + const int canfd_on = 1; + struct ifreq ifr; + struct timeval timeout = {1,0}; + + DEBUG(interface, "open_can_dev: CAN Handler socket : %d", can_handler.socket); + if (can_handler.socket >= 0) + close(can_handler.socket); + + can_handler.socket = socket(PF_CAN, SOCK_RAW, CAN_RAW); + if (can_handler.socket < 0) + { + ERROR(interface, "open_can_dev: socket could not be created"); + } + else + { + /* Set timeout for read */ + setsockopt(can_handler.socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)); + /* try to switch the socket into CAN_FD mode */ + if (setsockopt(can_handler.socket, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)) < 0) + { + NOTICE(interface, "open_can_dev: Can not switch into CAN Extended frame format."); + can_handler.is_fdmode_on = false; + } else { + can_handler.is_fdmode_on = true; + } + + /* Attempts to open a socket to CAN bus */ + strcpy(ifr.ifr_name, can_handler.device); + if(ioctl(can_handler.socket, SIOCGIFINDEX, &ifr) < 0) + ERROR(interface, "open_can_dev: ioctl failed"); + else + { + can_handler.txAddress.can_family = AF_CAN; + can_handler.txAddress.can_ifindex = ifr.ifr_ifindex; + + /* And bind it to txAddress */ + if (bind(can_handler.socket, (struct sockaddr *)&can_handler.txAddress, sizeof(can_handler.txAddress)) < 0) + { + ERROR(interface, "open_can_dev: bind failed"); + } + else + { + fcntl(can_handler.socket, F_SETFL, O_NONBLOCK); + return 0; + } + } + close(can_handler.socket); + can_handler.socket = -1; + } + return -1; +} + +/* + * TODO : test that socket is really opened + */ +static int write_can() +{ + ssize_t nbytes; + int rc; + + rc = can_handler.socket; + if (rc >= 0) + { +/* + * TODO change old hvac write can frame to generic on_event + */ + nbytes = sendto(can_handler.socket, &canfd_frame, sizeof(struct canfd_frame), 0, + (struct sockaddr*)&can_handler.txAddress, sizeof(can_handler.txAddress)); + if (nbytes < 0) + { + ERROR(interface, "write_can: Sending CAN frame failed."); + } + } + else + { + ERROR(interface, "write_can: socket not initialized. Attempt to reopen can device socket."); + retry(open_can_dev); + } + return rc; +} + +/* + * Parse the CAN frame data payload as a CAN packet + * TODO: parse as an OpenXC Can Message. Don't translate as ASCII and put bytes + * directly into openxc_CanMessage + */ +static int parse_can_frame(openxc_CanMessage *can_message, struct canfd_frame *canfd_frame, int maxdlen) +{ + int i, len; + //size_t n_msg; + + len = (canfd_frame->len > maxdlen) ? maxdlen : canfd_frame->len; + + can_message->has_id = true; + if (canfd_frame->can_id & CAN_ERR_FLAG) + can_message->id = canfd_frame->can_id & (CAN_ERR_MASK|CAN_ERR_FLAG); + else if (canfd_frame->can_id & CAN_EFF_FLAG) + { + can_message->has_frame_format = true; + can_message->frame_format = openxc_CanMessage_FrameFormat_EXTENDED; + can_message->id = canfd_frame->can_id & CAN_EFF_MASK; + } else + { + can_message->has_frame_format = true; + can_message->frame_format = openxc_CanMessage_FrameFormat_STANDARD; + can_message->id = canfd_frame->can_id & CAN_SFF_MASK; + } + + /* Don't know what to do with that for now as we haven't + * len fields in openxc_CanMessage struct + + * standard CAN frames may have RTR enabled. There are no ERR frames with RTR + if (maxdlen == CAN_MAX_DLEN && canfd_frame->can_id & CAN_RTR_FLAG) + { + // print a given CAN 2.0B DLC if it's not zero + if (canfd_frame->len && canfd_frame->len <= CAN_MAX_DLC) + buf[offset++] = hex_asc_upper[canfd_frame->len & 0xF]; + + buf[offset] = 0; + return NULL; + } + */ + + /* Doesn't handle real canfd_frame for now + if (maxdlen == CANFD_MAX_DLEN) + { + // add CAN FD specific escape char and flags + canfd_frame->flags & 0xF; + } */ + + if (sizeof(canfd_frame->data) <= sizeof(can_message->data.bytes)) + { + for (i = 0; i < len; i++) + can_message->data.bytes[i] = canfd_frame->data[i]; + return 0; + } else if (sizeof(canfd_frame->data) <= CAN_MAX_DLEN) + { + ERROR(interface, "parse_can_frame: can_frame data too long to be stored into openxc_CanMessage data field"); + return -1; + /* TODO create as many as needed openxc_CanMessage into an array to store all data from canfd_frame + n_msg = CAN_MAX_DLEN / sizeof(canfd_frame->data.bytes); + for (i = 0; i < len; i++) + can_message->data.bytes[i] = canfd_frame->data[i]; */ + } else + { + ERROR(interface, "parse_can_frame: can_frame is really too long here. Size of data greater than canfd maximum 64bytes size. Is it a CAN message ?"); + return -2; + } + + /* You should not reach this return statement */ + return -3; +} + + +/* + * Read on CAN bus and return how much bytes has been read. + */ +static int read_can(openxc_CanMessage *can_message) +{ + ssize_t nbytes; + int maxdlen; + + /* Test that socket is really opened */ + if ( socket_test() < 0) + { + if (retry(open_can_dev) < 0) + { + ERROR(interface, "read_can: Socket unavailable"); + return -1; + } + } + + nbytes = read(can_handler.socket, &canfd_frame, CANFD_MTU); + + if (nbytes == CANFD_MTU) + { + DEBUG(interface, "read_can: Got an CAN FD frame with length %d", canfd_frame.len); + } + else if (nbytes == CAN_MTU) + { + DEBUG(interface, "read_can: Got a legacy CAN frame with length %d", canfd_frame.len); + } + else + { + if (errno == ENETDOWN) + ERROR(interface, "read_can: %s interface down", can_handler.device); + ERROR(interface, "read_can: Error reading CAN bus"); + return -2; + } + + /* CAN frame integrity check */ + if ((size_t)nbytes == CAN_MTU) + maxdlen = CAN_MAX_DLEN; + else if ((size_t)nbytes == CANFD_MTU) + maxdlen = CANFD_MAX_DLEN; + else + { + ERROR(interface, "read_can: CAN frame incomplete"); + return -3; + } + + if (parse_can_frame(can_message, &canfd_frame, maxdlen)) + { + ERROR(interface, "read_can: Can't parse the can frame. ID: %i, DLC: %i, DATA: %s", + canfd_frame.can_id, canfd_frame.len, canfd_frame.data); + return -4; + } + + return 0; +} +/*************************************************************************/ +/*************************************************************************/ +/** **/ +/** **/ +/** SECTION: MANAGING EVENTS **/ +/** **/ +/** **/ +/*************************************************************************/ +/*************************************************************************/ +static int on_event(sd_event_source *s, int fd, uint32_t revents, void *userdata); + +/* + * Get the event loop running. + * Will trigger on_event function on EPOLLIN event on socket + * + * Return 0 or positive value on success. Else negative value for failure. + */ +static int connect_to_event_loop() +{ + sd_event *event_loop; + sd_event_source *source; + int rc; + + if (can_handler.socket < 0) + { + return can_handler.socket; + } + + event_loop = afb_daemon_get_event_loop(interface->daemon); + rc = sd_event_add_io(event_loop, &source, can_handler.socket, EPOLLIN, on_event, NULL); + if (rc < 0) + { + close(can_handler.socket); + ERROR(interface, "Can't connect CAN bus %s to the event loop", can_handler.device); + } else + { + NOTICE(interface, "Connected CAN bus %s to the event loop", can_handler.device); + } + + return rc; +} +/* + * Send all events + */ +static void send_event() +{ + can_event *current; + event *events; + json_object *object; + + /* Browse can_events */ + current = can_events_list; + while(current) + { + /* Browse event for each can_events no matter what the id */ + events = current->events; + while(events) + { + object = create_json_from_openxc_CanMessage(events); + afb_event_push(events->afb_event, object); + events = events->next; + } + current = current->next; + } +} + +/* + * called on an event on the CAN bus + */ +static int on_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) +{ + openxc_CanMessage can_message; + + can_message = openxc_CanMessage_init_default; + + /* read available data */ + if ((revents & EPOLLIN) != 0) + { + read_can(&can_message); + send_event(); + } + + /* check if error or hangup */ + if ((revents & (EPOLLERR|EPOLLRDHUP|EPOLLHUP)) != 0) + { + sd_event_source_unref(s); + close(fd); + connect_to_event_loop(); + } + + return 0; +} + +/* + * get or create an event handler for the type + */ +static event *get_event(uint32_t id, enum type type) +{ + event *event_elt; + can_event *list; + + /* find the can list by id */ + list = get_event_list_of_id(id); + + /* make the new event */ + event_elt = (event*)calloc(1, sizeof(event)); + event_elt->next = event_elt; + list->events = event_elt; + event_elt->name = create_name(id); + event_elt->afb_event = afb_daemon_make_event(interface->daemon, event_elt->name); + + return event_elt; +} + +/*************************************************************************/ +/*************************************************************************/ +/** **/ +/** **/ +/** SECTION: BINDING VERBS IMPLEMENTATION **/ +/** **/ +/** **/ +/*************************************************************************/ +/*************************************************************************/ +/* + * Returns the type corresponding to the given name + */ +static enum type type_of_name(const char *name) +{ + enum type result; + if (name == NULL) + return type_DEFAULT; + for (result = 0 ; (size_t)result < type_size; result++) + if (strcmp(type_NAMES[result], name) == 0) + return result; + return type_INVALID; +} + +/* + * extract a valid type from the request + */ +static int get_type_for_req(struct afb_req req, enum type *type) +{ + if ((*type = type_of_name(afb_req_value(req, "type"))) != type_INVALID) + return 1; + afb_req_fail(req, "unknown-type", NULL); + return 0; +} + +static int subscribe_unsubscribe_sig(struct afb_req request, int subscribe, struct signal *sig) +{ + if (!afb_event_is_valid(sig->event)) { + if (!subscribe) + return 1; + sig->event = afb_daemon_make_event(afbitf->daemon, sig->name); + if (!afb_event_is_valid(sig->event)) { + return 0; + } + } + + if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, sig->event)) < 0) { + return 0; + } + + return 1; +} + +static int subscribe_unsubscribe_all(struct afb_req request, int subscribe) +{ + int i, n, e; + + n = sizeof OBD2_PIDS / sizeof * OBD2_PIDS; + e = 0; + for (i = 0 ; i < n ; i++) + e += !subscribe_unsubscribe_sig(request, subscribe, &OBD2_PIDS[i]); + return e == 0; +} + +static int subscribe_unsubscribe_name(struct afb_req request, int subscribe, const char *name) +{ + struct signal *sig; + + if (0 == strcmp(name, "*")) + return subscribe_unsubscribe_all(request, subscribe); + + sig = getsig(name); + if (sig == NULL) { + return 0; + } + + return subscribe_unsubscribe_sig(request, subscribe, sig); +} + +static void subscribe_unsubscribe(struct afb_req request, int subscribe) +{ + int ok, i, n; + struct json_object *args, *a, *x; + + /* makes the subscription/unsubscription */ + args = afb_req_json(request); + if (args == NULL || !json_object_object_get_ex(args, "event", &a)) { + ok = subscribe_unsubscribe_all(request, subscribe); + } else if (json_object_get_type(a) != json_type_array) { + ok = subscribe_unsubscribe_name(request, subscribe, json_object_get_string(a)); + } else { + n = json_object_array_length(a); + ok = 0; + for (i = 0 ; i < n ; i++) { + x = json_object_array_get_idx(a, i); + if (subscribe_unsubscribe_name(request, subscribe, json_object_get_string(x))) + ok++; + } + ok = (ok == n); + } + + /* send the report */ + if (ok) + afb_req_success(request, NULL, NULL); + else + afb_req_fail(request, "error", NULL); +} + +static void subscribe(struct afb_req request) +{ + subscribe_unsubscribe(request, 1); +} + +static void unsubscribe(struct afb_req request) +{ + subscribe_unsubscribe(request, 0); +} + +static const struct afb_verb_desc_v1 verbs[]= +{ + { .name= "subscribe", .session= AFB_SESSION_NONE, .callback= subscribe, .info= "subscribe to notification of CAN bus messages." }, + { .name= "unsubscribe", .session= AFB_SESSION_NONE, .callback= unsubscribe, .info= "unsubscribe a previous subscription." }, + {NULL} +}; + +static const struct afb_binding binding_desc = { + .type = AFB_BINDING_VERSION_1, + .v1 = { + .info = "CAN bus service", + .prefix = "can", + .verbs = verbs + } +}; + +const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) +{ + interface = itf; + + return &binding_desc; +} + +int afbBindingV1ServiceInit(struct afb_service service) +{ + /* Open CAN socket */ + retry(open_can_dev); + return connect_to_event_loop(); +} diff --git a/timer.h b/timer.h new file mode 100644 index 0000000..2aaebce --- /dev/null +++ b/timer.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +typedef unsigned long (*TimeFunction)(); + +/* Public: A frequency counting clock. + * * + * * frequency - the clock freuquency in Hz. + * * lastTime - the last time (in milliseconds since startup) that the clock + * * ticked. + * */ +typedef struct { + float frequency; + unsigned long lastTick; + TimeFunction timeFunction; +} FrequencyClock; -- cgit 1.2.3-korg