SingingCat  0
Data Fields
sc_firmware_api Struct Reference

these are the callbacks available. the firmware "api". provided to the app on startup More...

#include <user_app_info.h>

Data Fields

int(* atoi )(const char *s)
void(* com_add_arg )(struct command *com, const char *format,...)
 add an argument to the command using a format strings (see printf)
void(* com_add_varg )(struct command *com, const char *format, va_list args)
 add an argument to the command using vargs
struct command *(* com_alloc )()
 allocate a new command (for sending out)
int(* com_deliver_command )(struct command *com, cpkt_callback)
 queue a command for sending. This is asynchronous, transmission will be retried and re-routed as necessary. Do not modify the command buffer until it has been sent successfully. Use the callback to track progress
void(* com_free )(struct command *com)
 free a command
const char *(* com_get_arg )(const struct command *com, int index)
 extract an argument from a command by index. Note: The returned string is guaranted to be NUL-terminated, but the argument might itself contain NUL bytes. Use com_get_arg_size() to get the length of the returned argument unless you can guarantee the argument does not contain NUL-Bytes More...
int(* com_get_arg_size )(const struct command *com, int index)
 get size (in bytes) of an argument by index
struct command *(* com_get_data_reply )(struct command *com)
 allocate command suitable for sending as reply
const char *(* com_get_named_arg )(struct command *com, const char *name)
 extract an argument from a command by name (assuming argument is of the form key=value)
int(* com_get_named_arg_uint16 )(struct command *com, const char *name, uint16_t *result)
 0 == ok, otherwise error. if OK, value will be stored in "result"
int(* com_get_named_arg_uint32 )(struct command *com, const char *name, uint32_t *result)
 0 == ok, otherwise error. if OK, value will be stored in "result"
int(* com_send_command )(struct command *com)
int(* com_send_reply_with_args )(struct command *com, uint8_t flags, const char *format,...)
 send a reply together with arguments
void(* debugf )(const char *format,...)
 print a message on console/usb (only)
int(* get_config_flag )(int flag)
 get a userconfig flag (0..n)
void(* led_blink )(int colour, int brightness, int on, int off)
 set the led to a certain colour or blink. to set a solid colour set off==0
int(* mculib_adc_enable )(MCULIB_HANDLE handle, int pin)
int(* mculib_adc_get_resolution )(MCULIB_HANDLE handle, int pin)
int(* mculib_adc_read )(MCULIB_HANDLE handle, int pin, int *result)
int(* mculib_adc_read_once )(MCULIB_HANDLE handle, int pin, int *result)
long(* mculib_get_seconds_since_boot )(void)
 get number of seconds elapsed since boot or power-up this counter is usually ever-increasing and roughly 1sec.
uint8_t(* mculib_has_time_passed )(int secs_to_wait, long *ctr)
int(* mculib_pin_get )(MCULIB_HANDLE handle, int pinnum)
 get current pin level (high or low) this is a bit funny: 0 or 1 indicate the pin level. anything else is an error
int(* mculib_pin_in )(MCULIB_HANDLE handle, int pinnum, int speed, int mode)
 configure and enable an IO-Pin as input note: pinnum are sequential 0-99 are PAnn, 100-199 are PBnn, 200-299 are PCnn callback is optional. if non-null an IRQ will be enabled on this pin
int(* mculib_pin_in_callback )(MCULIB_HANDLE handle, pin_irq_callback pic)
 set a callback to be called whenever a pin irq is triggered
int(* mculib_pin_out )(MCULIB_HANDLE handle, int pinnum, int speed)
 configure and enable an IO-Pin as output note: pinnum are sequential 0-99 are PAnn, 100-199 are PBnn, 200-299 are PCnn
int(* mculib_pin_out_opendrain )(MCULIB_HANDLE handle, int pinnum, int speed)
 configure and enable an IO-Pin as output note: pinnum are sequential 0-99 are PAnn, 100-199 are PBnn, 200-299 are PCnn
int(* mculib_pin_release )(MCULIB_HANDLE handle, int pinnum)
 deconfigure a pin (MCULIB_HANDLE handle,used for a different purpose)
int(* mculib_pin_set )(MCULIB_HANDLE handle, int pinnum, int highlow)
 set IOPin to high or low
int(* mculib_serialport_callback )(MCULIB_HANDLE handle, serial_recv_callback cb)
 set callback for serialport receive irq
int(* mculib_serialport_disable )(MCULIB_HANDLE handle, int portnum)
int(* mculib_serialport_enable )(MCULIB_HANDLE handle, int portnum, int baudrate)
 configure a serial port with specified parameters num == 1..n (depending on mcu) baudrate == ... 8N1 no flow control
int(* mculib_serialport_write_char )(MCULIB_HANDLE handle, int portnum, uint8_t b)
 write to serial port
int(* mculib_serialport_write_string )(MCULIB_HANDLE handle, int port, const char *txt)
 write a string to serial port
int(* mculib_spi_disable )(MCULIB_HANDLE handle, int portnum)
 disable the spi port
int(* mculib_spi_master_enable3 )(MCULIB_HANDLE handle, int portnum, uint8_t wide, uint8_t clkpol, uint8_t cpha, uint8_t dir, uint32_t baud_in_khz)
 enable a spi port as master and set clkpol, cpha and width (wide=0 8bit, wide=1 16bit)(dir == 0=RW,1=RO,2=WO)
int(* mculib_spi_read16_only )(MCULIB_HANDLE handle, int portnum, uint16_t *read)
 there are weird devices, like tli4970, which aren't really spi. they basically start sending as soon as CS is on
int(* mculib_spi_send_dma )(MCULIB_HANDLE handle, int portno, void *data, uint32_t size, uint32_t flags)
int(* mculib_spi_speed )(MCULIB_HANDLE handle, int portnum, long khz)
 set the spi speed (after it's open and running) returns new speed or 0 if failure
int(* mculib_spi_write_and_read )(MCULIB_HANDLE handle, int portnum, const uint16_t write, uint16_t *read)
 write a byte and read from spi if a transmission is already in progress it waits. this writes and waits for a complete transmission. then it reads and waits for a complete transmission. So it's somewhat slower than just writing note: If the spi is in 8bit mode, this will ONLY transmit and read 8 Bit!
int(* mculib_spi_write_only )(MCULIB_HANDLE handle, int portnum, const uint16_t write)
 write a byte, discard the read if a transmission is already in progress wait until transmission is done. this writes a byte to spi. It does not wait for completion, but returns immediately.
int(* mculib_timer_attach_pin_pwm )(MCULIB_HANDLE handle, int timer, int pin)
int(* mculib_timer_disable )(MCULIB_HANDLE handle, int timer)
int(* mculib_timer_enable_simple )(MCULIB_HANDLE handle, int timer, int freq, irq_callback callback)
int(* mculib_timer_set_pwm )(MCULIB_HANDLE handle, int timer, int pin, uint16_t dutycycle)
void(* memset )(void *buf, int c, int n)
void(* pin_pwm )(int MCULIBHANDLE, int pin, uint32_t newstate, int flags)
 pwm a pin (mosfets, and some other pins as well)
void(* printf )(const char *format,...)
 print a message on console and possibly forward to server into logfile as well (uses radio - expensive operation)
int(* proto_buf_to_struct )(void *buf, int bufsize, void *iter, void *out)
 decode a buffer containing a serialised proto into a struct
void(* proto_release )(void *buf)
 release a proto struct
int(* proto_struct_to_buf )(void *buf, int bufsize, void *iter, void *in)
 encode a struct to a buffer. returns number of bytes written. (-1 for error)
struct sensorruntime *(* sensor_get_runtime_by_index )(int idx)
 get a specific sensor runtime by index. index is a local (to this module) index
int(* sensor_register )(struct sensordev *sensor)
 register a new sensor. returns 0 if ok
void(* snprintf )(char *buf, int size, const char *format,...)
int(* strcmp )(const char *c1, const char *c2)
int(* strlen )(const char *txt)
void(* strncpy )(char *dst, const char *src, int size)
void(* time_bcd_to_timestruct )(uint32_t bcd_time, uint32_t bcd_date, struct sctime *out)
 convert BCDTime and BCDDate to timestruct
int(* time_get_diff )(struct sctime *time1, struct sctime *time2)
 calculate seconds between two time structs
int(* time_get_localtime_as_struct )(struct sctime *time)
 get the current time as time struct (return 0 if ok, otherwise error)
int(* timer_softirq )(uint32_t hertz, uint32_t opaque, void(*callback)(uint32_t))
 a very simple, not-very-accurate softirq callback. May be called multiple times returns 0 if ok, otherwise error
int(* unhandled_call1 )()
 safety call, terminates the app
int(* unhandled_call2 )()
 safety call, terminates the app
int(* unhandled_call3 )()
 safety call, terminates the app
int(* unhandled_call4 )()
 safety call, terminates the app
int(* unhandled_call5 )()
 safety call, terminates the app
int(* unhandled_call6 )()
 safety call, terminates the app
int(* unhandled_call7 )()
 safety call, terminates the app
int(* unhandled_call8 )()
 safety call, terminates the app
int(* userconfig_copy )(uint8_t *buf, uint16_t bufsize, uint16_t *actual_size)
 this copies the userconfig into a ram buffer, IF the version has been updated and IF the destination buffer is large enough. actual_size (if NOT NULL) will contain the actual size of bytes once this completes without an error RETURN VALUE: 0==ok, anything else is an error (same version is not an error)
uint32_t(* userconfig_size )()
 the userconfig: this is a little unstructured piece of flash set aside for configuration of userapps. note that this is updated at any time. If the userapp reads flash from interrupts the flash might change between invokations. if that is a problem the app should copy the contents into ram from the userloop. More...
uint32_t(* userconfig_version )()
 each time the config is updated, the version is incremented. in other words, unless the version is changed, the data remains the same
int(* userconfig_write )(uint8_t *buf, uint32_t size)
 this saves a buf as "userconfig" RETURN VALUE: 0==ok, anything else is an error (same version is not an error)
int version
void(* vsnprintf )(char *buf, int size, const char *format, va_list args)

Detailed Description

these are the callbacks available. the firmware "api". provided to the app on startup

Definition at line 27 of file user_app_info.h.

The documentation for this struct was generated from the following file: