- Generated by
1.12.0
|
socan 1.2.1
Linux SocketCAN higher level library
|
c header file for the simple CAN interface (sci) More...
#include <limits.h>Go to the source code of this file.
Macros | |
| #define | SCI_MAJOR_VERSION 3 |
| #define | SCI_MINOR_VERSION 0 |
| #define | SCI_VER (SCI_MAJOR_VERSION*100+SCI_MINOR_VERSION) |
| #define | SCI_IDENTIFIER "LINUX,SOCAN" |
| #define | SCI_PLUGPORT_START 128 |
| #define | SCI_MAX_PLUGPORTS 16 |
| #define | sci_object_type sci_Object_Type |
| #define | sci_return sci_Return |
| #define | sci_bitrate sci_Bitrate |
| #define | sci_errcode sci_Errcode |
| #define | sci_object sci_Object |
| #define | sci_struc sci_Struc |
| #define | SCI_M(err, str) |
| #define | SCI_ERRS |
| #define | SCI_NUM_ERRCODES (SCI_ERR_GENERAL+1) |
| #define | SCI_ERRCODE(sci_ret) |
| #define | SCI_ERR(errcode) |
Typedefs | |
| typedef enum sci_Object_Type | sci_Object_Type |
| typedef int | sci_Return |
| typedef enum sci_Bitrate_Constants | sci_Bitrate |
| typedef enum sci_Errcode_Constants | sci_Errcode |
| typedef struct sci_object_s | sci_Object |
| typedef void(* | sci_Plug_Func) (int l_len, char *l_data, int h_len, char *h_data) |
| typedef int(* | sci_Plug_Lencalc) (int h_len, int *l_len) |
| typedef struct sci_struc_s | sci_Struc |
Enumerations | |
| enum | sci_Object_Type { SCI_READ , SCI_WRITE , SCI_REMOTE_READ , SCI_REMOTE_WRITE } |
| enum | sci_Return_Constants { SCI_NOTHING =0 , SCI_OLD_DATA =1 , SCI_LOST =2 , SCI_TMOUT =4 , SCI_RESETTED =8 , SCI_INCONSISTENT =16 , SCI_EXISTS =32 , SCI_WAIT =64 , SCI_ERROR =INT_MIN } |
| enum | sci_Bitrate_Constants { SCI_1000KB , SCI_500KB , SCI_250KB , SCI_125KB , SCI_100KB , SCI_66KB , SCI_50KB , SCI_20KB } |
| enum | sci_Errcode_Constants { SCI_NO_ERR , SCI_PORT_ERR , SCI_ID_ERR , SCI_TYPE_ERR , SCI_BITRATE_ERR , SCI_SET_CALLB_ERR , SCI_MODE_ERR , SCI_LENGTH_ERR , SCI_ACCESS_ERR , SCI_TIMEOUT_ERR , SCI_TIMEOUT_VAL_ERR , SCI_OFF_BUS_ERR , SCI_BUS_ERR , SCI_AUTHORIZE_ERR , SCI_DVR_OPEN_ERR , SCI_DVR_ACCESS_ERR , SCI_HW_INIT_ERR , SCI_RESET_ERR , SCI_CHIP_CONF_ERR , SCI_ENV_ERR , SCI_PLUGPORT_ERR , SCI_PLUG_DEF_ERR , SCI_OBJ_UNDEF_ERR , SCI_ERR_GENERAL } |
Functions | |
| char * | sci_str_status (sci_Return flag) |
| void | sci_print_status (sci_Return flag) |
| char * | sci_str_err (sci_Errcode err) |
| void | sci_print_err (sci_Errcode err) |
| sci_Return | sci_open (sci_Struc **s_struc, const char *app_name, sci_Errcode *err) |
| sci_Return | sci_close (sci_Struc **s_struc) |
| sci_Return | sci_get_bitrate (sci_Struc *s_struc, unsigned short port, sci_Bitrate *bitrate) |
| sci_Return | sci_get_errcode (sci_Struc *s_struc, sci_Errcode *errcode) |
| sci_Return | sci_get_object (sci_Struc *s_struc, sci_Object **object, unsigned short port, int id) |
| void * | sci_get_user (sci_Object *object) |
| sci_Return | sci_get_info (sci_Struc *s_struc, sci_Object *object, unsigned short *port, int *id, int *length, int *timeout, sci_Object_Type *type) |
| sci_Return | sci_get_timestamp (sci_Struc *s_struc, sci_Object *object, unsigned long long *pstamp, int *pvalid, unsigned char *mode, unsigned char *irq_cnt) |
| sci_Return | sci_obj_dump_buf (char *buf, sci_Struc *s_struc, sci_Object *object) |
| sci_Return | sci_init_object (sci_Struc *s_struc, sci_Object **object, unsigned short port, int id, int length, int timeout, sci_Object_Type type, void *userp) |
| sci_Return | sci_delete_object (sci_Struc *s_struc, sci_Object **object) |
| sci_Return | sci_set_inhibit (sci_Struc *s_struc, sci_Object *object, unsigned long inhibit_time) |
| sci_Return | sci_read_now (sci_Struc *s_struc, sci_Object *object, char *data) |
| sci_Return | sci_read (sci_Struc *s_struc, sci_Object *object, char *data) |
| sci_Return | sci_write (sci_Struc *s_struc, sci_Object *object, char *data) |
| sci_Return | sci_write_inhibit (sci_Struc *s_struc, sci_Object *object, char *data, unsigned long *rest_time) |
| sci_Return | sci_set_callback (sci_Struc *s_struc, sci_Object *object, void *f) |
| sci_Return | sci_queue_read (sci_Struc *s_struc, sci_Object **object, char *data) |
| sci_Return | sci_def_plug_in (unsigned short plug_port, unsigned short real_port, sci_Plug_Func h2l, sci_Plug_Func l2h, sci_Plug_Lencalc lcalc, sci_Errcode *err) |
c header file for the simple CAN interface (sci)
socan - SocketCAN higher level library
Copyright 2025 Helmholtz-Zentrum Berlin für Materialien und Energie GmbH https://www.helmholtz-berlin.de
Author: Goetz Pfeiffer Goetz.nosp@m..Pfe.nosp@m.iffer.nosp@m.@hel.nosp@m.mholt.nosp@m.z-be.nosp@m.rlin..nosp@m.de
socan is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
socan is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with socan. If not, see https://www.gnu.org/licenses/.
This header, sci.h, contains all data types and functions of the simple CAN interface.
The library is based on socan, described at socan.h.
Definition in file sci.h.
| #define sci_bitrate sci_Bitrate |
| #define SCI_ERR | ( | errcode | ) |
| #define SCI_ERRCODE | ( | sci_ret | ) |
| #define sci_errcode sci_Errcode |
| #define SCI_ERRS |
| #define SCI_IDENTIFIER "LINUX,SOCAN" |
String describing the implementation of sci.
Although the interface the library provides is hardware-independent, the library itself contains hardware dependent code. In fact, the implementation of the library depends on the used computer-hardware, the operating system and on one or more drivers for CAN-interface cards. The SCI_IDENTIFIER-string provides information about the underlying hardware the library is adapted to. The identifier-string contains of sections, that are separated by commas. It has two sections, the first contains a string that describes the operating system, the following section describes the used CAN-card drivers.
"LINUX,SOCAN" means that this is a Linux platform and SCI is based on the socan object layer library.
| #define SCI_M | ( | err, | |
| str ) |
| #define SCI_MAJOR_VERSION 3 |
The major version number of SCI.
This is the major version-number of the SCI-library. The version of the library is composed of a major- and a minor-version number. Together, they form the complete version number e.g a major-number of 3 and a minor-number of 0 represent version 3.0 of the library.
| #define SCI_MAX_PLUGPORTS 16 |
| #define SCI_MINOR_VERSION 0 |
The minor version number of SCI.
This is the minor version-number of the SCI-library. The version of the library is composed of a major- and a minor-version number. Together, they form the complete version number e.g a major-number of 3 and a minor-number of 0 represent version 3.0 of the library.
| #define SCI_NUM_ERRCODES (SCI_ERR_GENERAL+1) |
| #define sci_object sci_Object |
| #define sci_object_type sci_Object_Type |
| #define SCI_PLUGPORT_START 128 |
The CAN port where plugins start.
This is the number of the first port that can be used as plug-port. A plug-port is comparable to real existing CAN ports but all data is converted by data-conversion functions (plug-ins) that are defined for that specific port. Once a plug-in has been defined, a new plug-port* is defined too. That plug-port can be used like any other (real-) port. An application that uses sci with that plug-port will not notice that all data-bytes are converted by the plug-in. Up to SCI_MAX_PLUGPORTS can be defined, the first plug-port is SCI_PLUGPORT_START. Plug-ins can be defined with the function sci_def_plug_in().
| #define sci_return sci_Return |
| #define sci_struc sci_Struc |
| #define SCI_VER (SCI_MAJOR_VERSION*100+SCI_MINOR_VERSION) |
| typedef enum sci_Bitrate_Constants sci_Bitrate |
Constants for CAN bitrates.
| typedef enum sci_Errcode_Constants sci_Errcode |
Error codes for functions.
If an error occurs, sci function set one of these error codes. The error is returned in the sci_Return return code and also in a variable associated with the sci_Struc handle which can be retrieved with function sci_get_errcode().
| typedef struct sci_object_s sci_Object |
Abstract data type of a CAN object.
It contains a user part, that can be used to store a user-defined pointer. The structure also contains internal data, but that data cannot be read or written to. Due to this unspecified internal data, whose size is unknown to the user, memory for sci-objects is only allocated by the library. A user program should only use pointers* to sci-objects but should never create variables of the type sci_Object itself. The data type sci_Object is in it's function similar to the FILE - structure that is used in C to handle files.
sci-objects are created with the sci_init_object() function; CAN-id, port, length and object-type are specified when the object is created. These properties cannot be modified later, if the CAN-id on that port shall have new properties, the existing sci-object has to be deleted with the sci_delete_object() function and created again with sci_init_object().
| typedef enum sci_Object_Type sci_Object_Type |
Type of a CAN object.
There are four possible types of a CAN object
| typedef void(* sci_Plug_Func) (int l_len, char *l_data, int h_len, char *h_data) |
Type of a plugin data conversion function
This is the prototype of a plug-in data-conversion function. 2 functions of that type are part of a plug-in. They perform data-conversion between the low-level format (raw-data from the CAN bus) and the high-level format (data that is passed to or from the application). Each data-conversion function gets a pointer to the low-level data, l_data, the length of the low-level data, l_len, a pointer to the high-level data, h_data, and a the length of the high-level data, h_len. The first conversion function, usually called h2l, should convert high-level to low-level data, the second function, usually called l2h, should convert low-level to high-level data.
| typedef int(* sci_Plug_Lencalc) (int h_len, int *l_len) |
| typedef struct sci_struc_s sci_Struc |
Abstract data type for sci handle.
This is the abstract type of the CAN resources. A pointer to a variable of this type is returned, when sci_open() is called. This pointer must be given for all other functions of this library. Different processes or threads must use different sci_Struc- parameters in their calls to the SCI-library. For this reason, the library can be called by different threads at a time an is by this, thread safe.
Note that the above definition does not represent the real structure of the sci-structure. All internal data, that this structure contains, is hidden from the user.
Error codes for functions.
If an error occurs, sci function set one of these error codes. The error is returned in the sci_Return return code and also in a variable associated with the sci_Struc handle which can be retrieved with function sci_get_errcode().
| enum sci_Object_Type |
Type of a CAN object.
There are four possible types of a CAN object
| Enumerator | |
|---|---|
| SCI_READ | read CAN object |
| SCI_WRITE | write CAN object |
| SCI_REMOTE_READ | remote-read CAN object |
| SCI_REMOTE_WRITE | remote-write CAN object |
| enum sci_Return_Constants |
Return codes for functions.
Most functions of sci return an integer that contains a combination of one or more of these flags. You have to check with bit-wise and '&' if a flag is set like in this example:
If an error occurred, the highest bit in the return code is set. You can check for an error like this:
Bits above bit 16 contain the sci error code (see sci_Errcode). You can use the macro SCI_ERRCODE to extract the error code:
You can get the embedded
|
extern |
Close the library.
This function is used (by a thread) to close the SCI-library. All CAN objects that were previously defined (by that thread) and the sci-structure, are deleted.
| [in,out] | s_struc | This is the address of a pointer that points to the sci-structure. After successful closing, the internal sci-structure is deleted and the given pointer is changed to a NULL pointer. |
SCI_NOTHING on success, SCI_ERROR in case of an error. In case of an error, the sci-structure remains defined and the pointer to that structure remains valid.
|
extern |
Define a plug-in for a CAN object.
This function defines an plug-in. Plug-ins do data-conversions of the data that is transmitted to and from CAN objects. The 2 data-formats between this conversion takes place are also called the low-level- (raw CAN-bus-data) and the high-level (sci-application data) format.
A plug-in consists of 3 functions, 2 of these functions perform the data-conversion in both directions and a third function calculates the length of the low-level data in dependence of the length of the high-level data. See also the description the data-types sci_Plug_Func and sci_Plug_Lencalc.
A plug-in also defines a plug-port. A plug-port can be used like a real CAN-bus port but each access to the plug-port (e.g. reading or writing to CAN objects that are defined for that port) involves the plug-in data-conversion functions. Each plug-port is connected with a real-port that represents the physical CAN-bus connection that is used when that plug-port* is accessed.
Note that this is one of the rare functions that do not have a sci_struc parameter. This function can be called without calling sci_open first. This also means that the plug-ins that one user process defines are valid for all other user processes. Currently, plug-ins cannot be deleted, once they have been defined for one plug-port. They remain valid as long as the sci-library or the program that is linked with the sci-library is loaded.
| [in] | plug_port | This is the plug-port for which the plug-in is defined. A plug-port must be in the range of SCI_PLUGPORT_START and SCI_PLUGPORT_START+SCI_MAX_PLUGPORTS-1. That plug-port can, after successful execution of sci_def_plug_in, used like any other port. |
| [in] | real_port | This is real-port that the plug-port is connected to. Each access of the plug-port will first involve the plug-in* data conversion and then access the real-port. |
| [in] | h2l | This is data-conversion function that converts the high-level data-format to the low-level data format. |
| [in] | l2h | This is data-conversion function that converts the low-level data-format to the high-level data format. |
| [in] | lcalc | This is the length-conversion function that calculates the length of the low-level data in dependence of the length of the high-level data. lcalc may return 0 when a certain high-level data-length cannot be converted by the plug-in functions. Note that each supported high-level data-length must correspond with just one low-level data-length. This low-level data-length is returned by the length-calculation function lcalc. |
| [out] | err | This is a pointer to a variable of the type sci_Errcode that is defined in the user program. If an error is detected, the error code is stored in that user-variable. |
|
extern |
Delete a sci object.
This function deletes an sci-object. It removes the internal sci_Object- structure and makes the CAN-id on the CAN interface available again. When this function is performed on duplicated objects, the other duplicated objects for the same CAN-object remains unchanged.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [out] | object | This is the address of a pointer to an sci-object. After successful execution of this function the pointer is set to NULL. |
SCI_NOTHING on success or an integer where the highest bit is set, so 'rc & SCI_ERROR' is not zero. In this case, you can retrieve the error code with 'SCI_ERRCODE(rc)' or by calling sci_get_errcode(). Possible error codes are:
|
extern |
Get the bit rate of a CAN port.
This function returns the bitrate that was set for a specific port. The port-parameter may be a real-port or a plug-port. The bitrate is returned in the bitrate parameter.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | port | This is port that is to be examined. This may also be a plug-port, in this case the bitrate of the corresponding real-port is returned. |
| [out] | bitrate | The current bitrate is returned via this parameter. Note that the type of this variable is not int but sci_Bitrate. |
SCI_NOTHING on success, SCI_ERROR in case of an error.
|
extern |
Get error code of the last error.
This function returns the last valid error-code for a thread. It is typically called immediately after another sci-function returned the SCI_ERROR flag. If another sci_function is called after the error but before sci_get_errcode(), the original error code is lost.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [out] | errcode | This is a pointer to a variable of the type sci_Errcode that is defined in the user program. The current error code for the current thread is written to that user-variable. |
|
extern |
Gather information on an an sci_Object.
This function returns the properties of a sci-object. With this function it is possible to get all properties of an object, that were specified with the call of sci_init_object, back.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | This is a pointer the sci-object that is to be examined. |
| [out] | port | This is a pointer to an integer-variable of the user program. The port-number of the object is written to that variable. |
| [out] | id | This is a pointer to an integer-variable of the user program. The CAN-id of the object is written to that variable. |
| [out] | length | This is a pointer to an integer-variable of the user program. The length of the object is written to that variable. |
| [out] | type | This is a pointer to a variable of the type sci_Object_Type that should be defined in the user program. The type of the sci-object is written to this variable. |
SCI_NOTHING on success or an integer where the highest bit is set, so 'rc & SCI_ERROR' is not zero. In this case, you can retrieve the error code with 'SCI_ERRCODE(rc)' or by calling sci_get_errcode(). Possible error codes are:
|
extern |
Get sci_Object for a given port and CAN object ID.
This function returns the sci_Object for a given port number and CAN object id.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [out] | object | This is the address of a pointer to an sci-object. After successful execution of this function the pointer points to the sci_Object. |
| [in] | port | This is the port-number of the CAN-object. |
| [in] | id | This is the CAN object ID. |
|
extern |
Get time stamp of a CAN object.
For read objects, this is the time when data arrived for this object. For write objects this is the time when data was written to the CAN bus for this object. The time stamp is measured in microseconds. The absolute value of the time stamp is compatible with the function gettimeofday as provided by libc. You would get a compatible time stamp like this:
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | This is a pointer the sci-object that is to be examined. |
| [out] | pstamp | This is a pointer to an integer-variable of type unsigned long long in the user program. The time stamp is is written to that variable. |
| [out] | pvalid | This implementation always returns 1 in this variable. Some implementations of sci can set this to 0, if the time stamp is invalid. |
| [out] | mode | This implementation always returns 0 here. |
| [out] | irq_cnt | This implementation always returns 0 here. |
SCI_NOTHING on success or an integer where the highest bit is set, so 'rc & SCI_ERROR' is not zero. In this case, you can retrieve the error code with 'SCI_ERRCODE(rc)' or by calling sci_get_errcode(). Possible error codes are:
|
extern |
|
extern |
Initialize a CAN object and return an sci_Object.
This function initializes a single CAN-object. A sci-object structure is created that is used by all other sci functions that work on single CAN-objects. Note that each sci-object contains a user part that can be used to store user-defined data for each object. See also the description of the type sci_Object.
If there was already an sci_Object defined for that CAN-id, sci_init_object() either returns an error if the object's properties do not exactly match the already defined object, or it duplicates the already existing object. A SCI_EXISTS-flag signals that an already existing sci-object was found.
A duplicate object has exactly the same properties as the original object. However, the user part of the sci-object structure is duplicated and is independent from the user-part of the original object. Both sci-objects, the old and the new one can then be used to read or to write to a certain CAN-object. There is, from the users point of view, no difference between the original and the duplicated object. Each object can be deleted separately without interference with the other one. There is only one point were a difference is made between duplicated objects, and that is function sci_queue_read(). When it returns a pointer to the sci-object where the data arrived, it always returns the first sci object that was initialized for the port and CAN object id.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [out] | object | This is the address of a pointer to an sci-object. After successful execution of this function the pointer points to the new created sci_Object. |
| [in] | port | This is the port-number of the CAN-object. |
| [in] | id | This is the CAN object ID. |
| [in] | length | This is a the length of the CAN-object. The object is defined with a certain length, that can range from 0 to 8 bytes. If data with a different number of bytes is received from the CAN bus, read-functions will return an SCI_LENGTH_ERR. |
| [in] | timeout | This is the timeout the object. The timeout is specified in milliseconds. The timeout is useful for sci-functions that would otherwise never return in case of an error. An example for such a function is sci_read, this function waits for new data, if no new data arrives, it returns after the given timeout. Note that there are some sci-functions that do not need and do not use timeouts specified for a given object, an example for this is sci_queue_read(). |
| [in] | type | This is the type of the object, there are basically 4 types of objects which can be distinguished as read or write, remote or not-remote objects. These types are described in with the sci_Object_Type in this documentation. |
| [in] | userp | This is an arbitrary pointer that is stored in the sci_Object. If you don't need this, just set this to NULL. |
SCI_NOTHING on success or an integer where the highest bit is set, so 'rc & SCI_ERROR' is not zero. In this case, you can retrieve the error code with 'SCI_ERRCODE(rc)' or by calling sci_get_errcode(). Possible error codes are:
|
extern |
Dump the CAN object to a string buffer.
Prints information about the object to a string buffer. The information includes the CAN-id, length, timeout, port and object type. The buffer buf must have room for 80 characters.
| [out] | buf | The address of an array of characters, at least 80 characters long. The information about the object is put into that buffer. |
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | This is a pointer the sci-object that is to be examined. |
SCI_NOTHING on success or an integer where the highest bit is set, so 'rc & SCI_ERROR' is not zero. In this case, you can retrieve the error code with 'SCI_ERRCODE(rc)' or by calling sci_get_errcode(). Possible error codes are:
|
extern |
Open the sci library and return a sci_Struc.
This is the open-function for the SCI-library. A process or thread can only use the other functions of the library, when it has once called sci_open.
Parameters and return-codes:
@param[out] s_struc This is the pointer to the created sci-structure. The
calling program gets a pointer to a new created internal
sci-structure. The user program should not read or write to
that structure. Since the internal details of this structure
are hidden and it's size is unknown to user, the user program
should not define variables of the type sci_Struc but only a
pointer* to a variable of this type.
@param[in] app_name This is a legacy parameter and ignored in this
implementation.
@param[out] err This is the only function in sci, where the error-code is
returned directly and has not to be requested with
sci_get_errcode(). The user program should have a variable of
the type sci_Errcode defined and provide a pointer to that
variable with the parameter err.
@returns This function returns either SCI_NOTHING in case of successful
execution or SCI_ERROR in case of an error. The error- code can
then be found the user's error-variable, provided by the err
parameter.
|
extern |
|
extern |
|
extern |
Perform a blocking read on many CAN objects.
sci_queue_read reads data from any event-object. This function waits until an event takes place and returns the corresponding object-pointer and the new data.
Here are some advantages of using sci_queue_read:
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | The address of an sci_Object pointer. |
| [out] | data | A pointer to the data buffer where the data is returned. The buffer must have a size of 8 bytes. |
|
extern |
Perform a blocking read on a CAN object.
This function reads data from a can-object, but it may wait for some time (see also sci_read_now()). This function can be applied to read and remote-read objects. It's function is different for each of the two object-types:
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | The sci_Object pointer. |
| [out] | data | A pointer to the data buffer where the data is returned. The buffer must have a size of 8 bytes. |
|
extern |
Perform non blocking read on a CAN object.
In general, this function reads data from a can-object without waiting. This function can be applied to read and remote-read objects. It simply returns the data that is in the data buffer of the CAN object. Note that when used with remote-read objects, this function does not send a remote frame ("RTR request"), if you want this, ise sci_read() instead.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | The sci_Object pointer. |
| [out] | data | A pointer to the data buffer where the data is returned. The buffer must have a size of 8 bytes. |
|
extern |
Prepare a CAN object for usage by sci_queue_read().
This function defines an event-object. These are needed if you want to use sci_queue_read() which waits until an event takes place and returns the corresponding object-pointer and the new data.
An event-object can only be defined once. This property cannot be removed later. However, event objects can be deleted with sci_delete_object(). Note that for duplicated objects (objects created with sci_dup_object() or sci_init_object(), defining one as event object means that all objects associated with the same CAN-can become an event-object.
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | The sci_Object pointer. |
| [in] | f | This is a legacy parameter and should be NULL. |
|
extern |
Set the inhibit time of an sci object.
This function sets the inhibit-time for a CAN-write object. The main application for inhibit-times is communication with slow CAN devices that are not able to process CAN object's at the maximum possible speed. For example with a 1 MBit/s CAN line, a CAN frame can be physically sent about every 130 microseconds. If the other CAN participant can only process one frame every 1000 microseconds, inhibit-times can be used to limit the rate of transmission. The inhibit-time is the minimal allowed time between two writes to a CAN-write object. This function should only be applied to ordinary CAN-write objects. The inhibit-time has only an effect when sci_write_inhibit() is used instead of sci_write() to write to the CAN object. In current implementations of sci the inhibit-time of a new created CAN object is 0 but an application should not rely on that. See also the description of sci_write_inhibit().
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | The sci_Object pointer. |
| [in] | inhibit_time | This is the inhibit-time for the CAN object. Note that the inhibit-time (in opposition to timeout-times) is specified in microseconds. |
SCI_NOTHING on success or an integer where the highest bit is set, so 'rc & SCI_ERROR' is not zero. In this case, you can retrieve the error code with 'SCI_ERRCODE(rc)' or by calling sci_get_errcode(). Possible error codes are:
|
extern |
Convert an error code to a constant string.
This function converts an error code from a sci_Errcode variable to a string. The string can be used to print an error code in a human readable form.
| [in] | err | The error code we want to print. |
|
extern |
Convert a status to a constant string.
This function converts a status code from a sci_Return variable to a string. The string can be used to print a return code in a human readable form.
| [in] | flag | The return code we want to convert to a string. |
|
extern |
Non-blocking write of a CAN object.
This function writes data to a sci-object. This function can be applied to write, remote-write and remote-read objects. It's function however is different for each object-type:
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | The sci_Object pointer. |
| [in] | data | A pointer to the data buffer where the data is read from. |
|
extern |
Non-blocking write of a CAN object with inhibit time.
This function is similar to sci_write(). It may return an SCI_WAIT status, in this case the user has to wait a time returned in parameter 'rest_time' until it can try again to write to the CAN object. The function takes account of the inhibit time which may have been set with function sci_set_inhibit() for the CAN object. The intention of an inhibit time is to guarantee that the time between two consecutive writes to the same CAN object is never less than the inhibit time.
The details depend on the type of the CAN object:
| [in] | s_struc | This is the sci-structure, created by sci_open() |
| [in] | object | The sci_Object pointer. |
| [in] | data | A pointer to the data buffer where the data is read from. |
| [out] | rest_time | A pointer to an unsigned long. The function returns the time to wait in this parameter in microseconds when the return code is SCI_WAIT. |
1.12.0