Welcome to Zeta’s documentation!¶

Getting started¶

This is the first step to do.

@startuml
Zeta -> World: Hello!
@enduml

Code documentation¶

This is the temporary code documentation.

zeta.zeta.Channel : public object

Represents a channel written on YAML file.

Public Functions

__init__()¶

__repr__(self)¶

Public Members

name¶

read_only¶

on_changed¶

size¶

persistent¶

sem¶

id¶

initial_value¶

message¶

message_obj¶

pub_services_obj¶

sub_services_obj¶

zeta.zeta.Config : public object

Public Functions

__init__()¶

Public Members

sector_count¶

storage_partition¶

storage_period¶

union data¶

#include <zeta.template.h>

Public Members

zt_data_int8_t s8¶

zt_data_uint8_t u8¶

zt_data_int16_t s16¶

zt_data_uint16_t u16¶

zt_data_int32_t s32¶

zt_data_uint32_t u32¶

zt_data_int64_t s64¶

zt_data_uint64_t u64¶

zt_data_bytes_t bytes¶

zeta.zeta_cli.FileFactory : public object

Represents a generic class responsible to generate a file-based
in a template and your respective substitutions.

Subclassed by HeaderFileFactory, SourceFileFactory, ZetaConf

Public Functions

__init__()¶

create_substitutions(self)¶

The function that will be implemented by classes inherited.

:returns: None
:rtype: None

generate_file(self)¶

Writes the output file with the respective substitutions
assigned in create_substitutions function.

:returns: None
:rtype: None

run(self)¶

Runs the routine responsible for assigns substitutions and
write the output file.

:returns: None
:rtype: None

Public Members

destination_file¶

template_file¶

zeta¶

substitutions¶

union flag_data¶

#include <zeta.template.h>

Define pendent options that a channel can have.

Public Members

uint8_t pend_persistent¶: Active represent that channel must be saved in flash by zeta_thread_nvs

uint8_t pend_callback¶: Active represent that services callbacks from subscribers must be called by zeta_thread

uint8_t on_changed¶: Active represent that the service callback will be called on change and not on update

uint8_t source_serial_isc¶: When active indicates the channel was changed by the serial isc (some host process) instead of a target service

struct flag_data::[anonymous] field¶

uint8_t data¶: Raw data

zeta.zeta_cli.HeaderFileFactory : public FileFactory

Represents a generic class for creation of header files that will
be used by Zeta.

Subclassed by ZetaHeader

Public Functions

__init__()¶

class zeta.zeta_isc.IPC¶

Public Functions

__init__()¶

create_channels(self)¶

digest_packet()¶

read_channel(self, cid)¶

set_channel(self, cid, msg)¶

Public Static Attributes

sem¶

channel_changed_queue¶

Private Static Attributes

__zeta¶

__channels¶

class zeta.zeta_isc.IPCChannel¶

Public Functions

__init__()¶

__repr__(self)¶

message_union_field(self)¶

create_struct()¶

Public Members

metadata¶

data¶

zeta.zeta_pkt.IPCHeader : public LittleEndianStructure

struct zt_isc_header {
    uint8_t channel : 8; /**!> 256 channels available*/
    uint8_t op : 3; /**!> 0: read, 1: write, 2: read response,
                          3: write response, 4: update */
    uint8_t status : 4;   /**!> 0: ok, 1: failed */
    uint8_t has_data : 1; /**!> 0: no data, 1: contains data */
};

Private Static Attributes

_pack_¶

_fields_¶

zeta.zeta_pkt.IPCHeaderDataInfo : public LittleEndianStructure

struct zt_isc_header_data_info {
    uint8_t crc : 8;  /**!> CCITT 8, polynom 0x07, initial value 0x00 */
    uint8_t size : 8; /**!> data size */
};

Private Static Attributes

_pack_¶

_fields_¶

zeta.zeta_pkt.IPCPacket : public LittleEndianStructure

Public Functions

__init__(self, args, kwargs)¶

set_data()¶

set_data_with_struct(self, struct)¶

clear_data(self)¶

from_bytes(cls, raw_data)¶

to_bytes(self)¶

data(self)¶

set_header()¶

set_data_info()¶

set_header_from_bytes()¶

set_data_info_from_bytes()¶

header_to_bytes(self)¶

__repr__(self)¶

struct_contents(self, struct)¶

struct_contents_set(self, struct)¶

Public Static Attributes

OP_READ¶

OP_WRITE¶

OP_READ_RESPONSE¶

OP_WRITE_RESPONSE¶

OP_UPDATE¶

OP_DEBUG¶

DATA_UNAVALABLE¶

DATA_AVAILABLE¶

STATUS_OK¶

STATUS_FAILED¶

Private Members

__data¶

Private Static Attributes

_pack_¶

_fields_¶

class zeta.zeta.Message¶

This object represents the Message defined by the Zeta yaml file.

Public Functions

__init__()¶

__repr__(self)¶

Public Members

name¶

msg_format¶

class zeta.zeta_isc.SerialDataHandler¶

Public Functions

__init__(self)¶

append(self, data)¶

send_command()¶

digest(self)¶

run(self)¶

Public Members

iqueue¶

oqueue¶

Public Static Attributes

STATE_DIGEST_HEADER_OP¶

STATE_DIGEST_HEADER_DATA_INFO¶

STATE_DIGEST_BODY¶

Private Members

__buffer¶

__state¶

__current_pkt¶

zeta.zeta.Service : public object

Represents a service written on YAML file.

Public Functions

__init__()¶

Public Members

name¶

priority¶

stack_size¶

pub_channels_names¶

sub_channels_names¶

pub_channels_obj¶

sub_channels_obj¶

zeta.zeta_cli.SourceFileFactory : public FileFactory

Represents a generic class for creation of source files that will
be used by Zeta.

Subclassed by ZetaSource

Public Functions

__init__()¶

zeta.messages.TestStringMethods : public TestCase

Public Functions

test_primitives(self)¶

test_struct_simple(self)¶

test_union_simple(self)¶

test_bitarray_simple(self)¶

test_array_simple(self)¶

test_complex_message(self)¶

zeta.zeta.Zeta : public object

Represents the Zeta object that has access to services, channels
and config parameters specified in YAML file.

Public Functions

__init__()¶

Public Members

config¶

channels¶

services¶

messages¶

Private Functions

__check_service_channel_relation(self)¶

Checks if the use of !ref is correct or is used some
nonexistent channel.

:returns: None
:rtype: None
:raise ZetaCLIError: Channel name doesn't exists in channel list.

__check_channel_message_relation(self)¶

Checks if the use of !ref is correct or is used some
nonexistent channel.

:returns: None
:rtype: None
:raise ZetaCLIError: Channel name doesn't exists in channel list.

__process_file()¶

zeta.zeta_cli.ZetaCLI : public object

Represents the ZetaCLI and has all the callbacks that will be
called when the user type zeta on the terminal.

Public Functions

__init__(self)¶

ZetaCLI constructor.

:returns: None
:rtype: None

init(self)¶

Called when the user type "zeta init" and is responsible for
generates the minimum requirements in order to Zeta works
properly.

:returns: Exit code
:rtype: int
:raise ZetaCLIError: Error in zeta.cmake or zeta.yaml file path

version(self)¶

Called when the user type "zeta version" and is responsible
for sends out the ZetaCLI version.

:returns: Exit code
:rtype: int

check_files(self)¶

check_code(self, src_dir)¶

check(self)¶

Called when the user type "zeta check" and is responsible for
checks if the needed steps were made by user in order to Zeta
works properly.

:returns: Exit code
:rtype: int

services(self)¶

Called when the user type "zeta services" and is responsible
for generates files template-based with the services initialized.

:returns: Exit code
:rtype: int
:raise ZetaCLIError: Error opening or reading files

gen(self)¶

Generate all the internal files that represents Zeta system
like channels, Zeta threads, Zeta API, and others.

:returns: Exit code
:rtype: int

sniffer(self)¶

Generate all the internal files that represents Zeta system
like channels, Zeta threads, Zeta API, and others.

:returns: Exit code
:rtype: int

isc(self)¶

Starts a high level ISC on the host. It takes all the yaml file
details to run the proper environment.

:returns: Exit code
:rtype: int

zeta.zeta_errors.ZetaCLIError : public Exception

Base class for exceptions in ZetaCLI

Public Functions

__init__(self, message, errcode)¶

ZetaCLIError constructor.

:param message: Message to be displayed printing error
:param errcode: Error code
:returns: None
:rtype: None

handle(self)¶

Responsible for handling the raise call.

:returns: None
:rtype: None

__str__(self)¶

Public Members

errcode¶

message¶

zeta.sniffer.ZetaCLIEventListWalker : public ListWalker

Represents the event list. It is used by the ListBox to show
the events occurred.

Public Functions

__init__()¶

create_table(self, title='[0/0]')¶

Create the event table.

:param title: the table's title
:returns: the table container (LineBox)
:rtype: urwid.LineBox

__len__(self)¶

Len operator overloading

:returns: the table number of lines
:rtype: int

append(self, item)¶

Append method overloading

:param item: dictionary with the data of the new item to be added
:returns: None
:rtype: None

create_data_viewer(self)¶

Create data detail viewer.

:returns: the data viewer
:rtype: urwid.Text

__getitem__(self, index)¶

Get item operator overloading

:param index: index of the desired element
:returns: the element at index
:rtype: urwid.Columns

set_modified_callback(self, callback)¶

This function inherited from MonitoredList is not
implemented in SimpleFocusListWalker.
Use connect_signal(list_walker, "modified", ...) instead.

set_focus(self, position)¶

Set focus position.

next_position(self, position)¶

Return position after start_from.

prev_position(self, position)¶

Return position before start_from.

positions(self, reverse=False)¶

Optional method for returning an iterable of positions.

Public Members

event_list¶

table_rows¶

focus¶

table_title¶

data_viewer¶

Private Functions

__create_table_header(self)¶

Create the table header.

:param event_list: list of event items
:returns: table header
:rtype: urwid.AttrMap

zeta.zeta_cli.ZetaConf : public FileFactory

Public Functions

__init__()¶

create_substitutions(self)¶

zeta.zeta_cli.ZetaHeader : public HeaderFileFactory

Represents a class that generates the zeta.h file and has the
goal to assigns all the substitutions needed to Zeta works
properly.

Public Functions

__init__()¶

create_substitutions(self)¶

Responsible for assigns the needed substitutions to be
written on the output file.

:returns: None
:rtype: None

Public Members

services_reference¶

max_channel_size¶

class zeta.messages.ZetaMessage¶

Represents the Message to zeta. It holds the messages' information for
code generation

Public Functions

__init__()¶

__repr__(self)¶

digest_type(self)¶

Digests the mtype and mounts the necessary data to the code
generation.

:returns: None
:rtype: None

code(self)¶

Generates the code for the message.

:returns: the code generated that represents the message
:rtype: str

Public Members

name¶

size¶

level¶

description¶

parent¶

mtype_obj¶

mtype_base_type¶

mtype¶

fields¶

zeta.sniffer.ZetaSerialMonitor : public Protocol

Class that handles the serial connection and updates
the interface data related to the income information.

Public Functions

__init__()¶

connection_made(self, transport)¶

Method called when an connection is made

digest_isc_message(self, msg)¶

Digest the incoming encoded message to extract the message
information.

data_received(self, data)¶

Method called when an a new data is available to be read.

:param data: bytes received at the serial.
:returns: None
:rtype: None

connection_lost(self, exc)¶

Method called when the connection is lost

pause_writing(self)¶

Method called when the writing is paused

resume_writing(self)¶

Method called when the writing is resumed

send(self)¶

Send four newline-terminated messages, one byte at a time.

Public Members

event_list¶

logging_ui¶

line_buffer¶

zeta¶

transport¶

class zeta.sniffer.ZetaSniffer¶

Class that encapsulates the sniffer execution function.

Public Functions

run(self, serial_port='', baudrate=115200)¶

Function used to execute the sniffer. It opens the serial at the
specified baud rate passed as argument.

:param serial_port: the serial port description. For example "/dev/ttyUSB0".
:param baudrate: the communication frequency. For example 115200.
:returns: None
:rtype: None

zeta.zeta_cli.ZetaSource : public SourceFileFactory

Represents a class that generates the zeta.c file and has the
goal to assigns all the substitutions needed to Zeta works
properly.

Public Functions

__init__()¶

gen_sems(self)¶

Responsible for assigns the channel semaphores.

:returns: None
:rtype: None

gen_creation(self)¶

Responsible for creates all the channels that will be used by
Zeta.

:returns: None
:rtype: None

gen_nvs_config(self)¶

Responsible for assigns the nvs config.

:returns: None
:rtype: None

create_substitutions(self)¶

Responsible for assigns the needed substitutions to be written
on the output file.

:returns: None
:rtype: None

Public Members

channels_creation¶

channels_sems¶

sector_size¶

sector_count¶

storage_offset¶

set_publishers¶

set_subscribers¶

arrays_init¶

services_array_init¶

run_services¶

storage_partition¶

zeta.zeta.ZetaYamlLoader : public SafeLoader

Modifies the SafeLoader object and generates a correct
dictionary-based in the YAML file.

Public Functions

__init__(self, stream)¶

YamlRefloader constructor.

:param stream: default param used for yaml.SafeLoader
:returns: None
:rtype: None

ref(self, node)¶

Handles ref statements in YAML file and generate a valid
reference

:param node: Ref statement with the reference name
:returns: Reference name
:rtype: str

include(self, node)¶

Handles include statements in YAML file and generate a
valid reference

:param node: Include statement with the reference name
:returns: Content of the file passed by include
:rtype: dict

struct zt_channel¶

#include <zeta.template.h>

Define Zeta channel type.

Public Members

const char *name¶: Channel name

uint8_t *data¶: Channel raw data

uint8_t read_only¶

uint8_t size¶: Channel size

uint8_t persistent¶: Persistent type

zt_channel_e id¶: Channel Id

union flag_data flag¶: Options

struct k_sem *sem¶: Preserve shared-memory

zt_service_t **publishers¶: Publishers

zt_service_t **subscribers¶: Subscribers

struct zt_data_bytes_t¶

#include <zeta.template.h>

Public Members

size_t size¶

uint8_t value[]¶

struct zt_data_int16_t¶

#include <zeta.template.h>

Public Members

size_t size¶

int16_t value¶

struct zt_data_int32_t¶

#include <zeta.template.h>

Public Members

size_t size¶

int32_t value¶

struct zt_data_int64_t¶

#include <zeta.template.h>

Public Members

size_t size¶

int64_t value¶

struct zt_data_int8_t¶

#include <zeta.template.h>

Public Members

size_t size¶

int8_t value¶

struct zt_data_uint16_t¶

#include <zeta.template.h>

Public Members

size_t size¶

uint16_t value¶

struct zt_data_uint32_t¶

#include <zeta.template.h>

Public Members

size_t size¶

uint32_t value¶

struct zt_data_uint64_t¶

#include <zeta.template.h>

Public Members

size_t size¶

uint64_t value¶

struct zt_data_uint8_t¶

#include <zeta.template.h>

Public Members

size_t size¶

uint8_t value¶

struct zt_isc_net_pkt¶

Public Members

struct zt_isc_net_pkt_header header¶

struct zt_isc_net_pkt_header_message_info message_info¶

uint8_t *message¶

struct zt_isc_net_pkt_header¶

Public Members

uint8_t channel¶

uint8_t op¶: !> 256 channels available

uint8_t status¶: !> 0: read, 1: write, 2: read response, 3: write response, 4: update

uint8_t has_data¶: !> 0: ok, 1: failed

struct zt_isc_net_pkt_header_message_info¶

Public Members

uint8_t crc¶

uint8_t size¶: !> CCITT 8, polynom 0x07, initial value 0x00

struct zt_isc_packet¶

#include <zeta.template.h>

Public Members

uint32_t id¶

uint8_t service_id¶

uint8_t channel_id¶

uint8_t op¶

uint8_t size¶

uint8_t message[$max_channel_size]¶

zeta.zeta_isc.ZT_MSG : public Union

All the messages defined by the config file will be filled up here

struct zt_service¶

#include <zeta.template.h>

Define Zeta service type.

Public Members

zt_service_e id¶: Service ID

const char *name¶: Service name

struct k_thread thread¶: Service RTOS thread

zt_callback_f cb¶: Service callback

k_thread_entry_t entry_point¶: Service thread function (entry point)

k_thread_stack_t *stack¶: Service thread stack

size_t stack_size¶: Service thread stack size

module zeta¶

module __main__¶

module zeta._version¶

Variables

str¶

module zeta.messages¶

Variables

MsgType = namedtuple('MsgCode', "statement separator begin end sizable")¶

module sniffer¶

module zeta.zeta¶

Variables

ZETA_MODULE_DIR = "."¶

ZETA_TEMPLATES_DIR = "."¶

PROJECT_DIR = "."¶

ZETA_DIR = "."¶

ZETA_SRC_DIR = "."¶

ZETA_INCLUDE_DIR = "."¶

module zeta.zeta_cli¶

Functions

run()¶

Variables

ZETA_MODULE_DIR = "."¶

ZETA_TEMPLATES_DIR = "."¶

PROJECT_DIR = str(Path(".").resolve())¶

ZETA_DIR = "."¶

ZETA_SRC_DIR = "."¶

ZETA_INCLUDE_DIR = "."¶

OK_COLORED = "\033[0;42m \033[1;97mOK \033[0m"¶

FAIL_COLORED = "\033[0;41m \033[1;97mFAIL \033[0m"¶

WARNING_COLORED = "\033[1;43m \033[1;97mWARNING \033[0m"¶

module zeta.zeta_errors¶

Variables

EZTFILE = 1¶

EZTFIELD = 2¶

EZTCHECKFAILED = 3¶

EZTINVREF = 4¶

EZTUNEXP = 10¶

module zeta.zeta_isc¶

Functions

repr(self)¶

create_base_message()¶

uart_write_handler()¶

uart_read_handler()¶

struct_contents(struct)¶

struct_contents_set(struct, raw_data)¶

callback_handler()¶

pub_read_handler()¶

isc_run()¶

Variables

ipc = None¶

context = Context.instance()¶

target_attached = False¶

module zeta_pkt¶

file __init__.py

file __main__.py

file _version.py

file messages.py

file sniffer.py

file zeta.template.c

#include “zeta.h”#include <drivers/flash.h>#include <fs/nvs.h>#include <logging/log.h>#include <storage/flash_map.h>#include <string.h>#include <zephyr.h>#include “zt_serial_ipc.h”#include “devicetree_fixups.h”

Defines

NVS_SECTOR_COUNT¶

NVS_STORAGE_PARTITION¶

Functions

LOG_MODULE_REGISTER(zeta, CONFIG_ZETA_LOG_LEVEL)¶

static void __zt_monitor_thread(void)¶

K_THREAD_DEFINE (zt_monitor_thread_id, ZT_MONITOR_THREAD_STACK_SIZE, __zt_monitor_thread, NULL, NULL, NULL, ZT_MONITOR_THREAD_PRIORITY, 0, 0)

K_MSGQ_DEFINE (zt_channels_changed_msgq, sizeof(uint8_t), 30, 4)

const char *zt_channel_name(zt_channel_e id, int *error)¶

Return the channel name.

Parameters

id – Channel Id
error – Handle possible errors

Returns

Channel name

size_t zt_channel_size(zt_channel_e id, int *error)¶

Return the channel size.

Parameters

id – Channel Id
error – Handle possible errors

Returns

Channel size

int zt_chan_read(zt_channel_e id, zt_data_t *channel_data)¶

Read channel value.

Parameters

id – Channel Id
channel_data – pointer to a zt_data_t where the data will be retrieved.

Returns -ENODATA

The channel was not found

Returns -EFAULT

Channel value is NULL

Returns -EPERM

Channel hasn’t read function implemented

Returns -EINVAL

Size passed is different to channel size

Returns

Error code

int zt_chan_pub(zt_channel_e id, zt_data_t *channel_data)¶

Publish channel value.

Parameters

id – Channel Id
channel_data – pointer to a zt_data_t where the data is.

Returns -ENODATA

The channel was not found

Returns -EACCESS

Current thread hasn’t permission to publish this channel

Returns -EFAULT

Channel value is NULL

Returns -EPERM

Channel is read only

Returns -EINVAL

Size passed is different to channel size

Returns -EAGAIN

Valid function returns false

Returns

Error code

file zeta.template.h

#include <stddef.h>#include <zephyr.h>#include <zephyr/types.h>

Defines

ZT_MONITOR_THREAD_STACK_SIZE¶: Stack size that is used in Zeta thread that manages channels callback calls.

ZT_STORAGE_SLEEP_TIME¶: Storage sleep time.

ZT_MONITOR_THREAD_PRIORITY¶: Channels thread priority.

ZT_SERVICE_DECLARE(_name, _task, _cb)¶

Declare a zeta service.

Parameters

_name – Service name
_task – Task pointer function
_cb – Callback to be called when some subscribed channel change

ZT_SERVICE_RUN(_name)¶

Run a zeta service.

Parameters

_name – Service name

ZT_VARIABLE_REF_SIZE(x)¶

Read variable reference and size easily \ to use in Zeta API. \ .

\

Parameters

x – variable name \ \

ZT_CHECK_VAL(_p, _e, _err, ...)¶

Check if _v value is equal to _c, otherwise _err will be returned and a message will be sent to LOG.

Parameters

_v – Value
_c – Condition
_err – Error code

ZT_CHECK(_p, _err, ...)¶

Check if _v is true, otherwise _err will be returned and a message will be sent to LOG.

Parameters

_v – Value
_err – Error code

Returns

ZT_DATA_S8(data)¶

ZT_DATA_U8(data)¶

ZT_DATA_S16(data)¶

ZT_DATA_U16(data)¶

ZT_DATA_S32(data)¶

ZT_DATA_U32(data)¶

ZT_DATA_S64(data)¶

ZT_DATA_U64(data)¶

ZT_DATA_BYTES(_size, data, ...)¶

Typedefs

typedef union data zt_data_t¶

typedef void (*zt_callback_f)(zt_channel_e id)¶

zeta_callback_f define the callback function type of Zeta.

Parameters: id – Channel Id.

typedef struct zt_service zt_service_t¶

typedef struct zt_isc_packet zt_isc_packet_t¶

typedef struct zt_channel zt_channel_t¶

Functions

struct zt_isc_packet __attribute__ ((packed))

size_t zt_channel_size(zt_channel_e id, int *error)

Return the channel size.

Parameters

id – Channel Id
error – Handle possible errors

Returns

Channel size

const char *zt_channel_name(zt_channel_e id, int *error)

Return the channel name.

Parameters

id – Channel Id
error – Handle possible errors

Returns

Channel name

int zt_chan_read(zt_channel_e id, zt_data_t *channel_data)

Read channel value.

Parameters

id – Channel Id
channel_data – pointer to a zt_data_t where the data will be retrieved.

Returns -ENODATA

The channel was not found

Returns -EFAULT

Channel value is NULL

Returns -EPERM

Channel hasn’t read function implemented

Returns -EINVAL

Size passed is different to channel size

Returns

Error code

int zt_chan_pub(zt_channel_e id, zt_data_t *channel_data)

Publish channel value.

Parameters

id – Channel Id
channel_data – pointer to a zt_data_t where the data is.

Returns -ENODATA

The channel was not found

Returns -EACCESS

Current thread hasn’t permission to publish this channel

Returns -EFAULT

Channel value is NULL

Returns -EPERM

Channel is read only

Returns -EINVAL

Size passed is different to channel size

Returns -EAGAIN

Valid function returns false

Returns

Error code

Variables

uint32_t id¶

uint8_t service_id¶

uint8_t channel_id¶

uint8_t op¶

uint8_t size¶

uint8_t message[$max_channel_size]¶

union flag_data __attribute__

file zt_serial_ipc.h

#include <zephyr.h>#include “zeta.h”

Defines

ZT_SERIAL_IPC_RX_THREAD_STACK_SIZE¶

ZT_SERIAL_RX_THREAD_PRIORITY¶

ZT_SERIAL_IPC_TX_THREAD_STACK_SIZE¶

ZT_SERIAL_TX_THREAD_PRIORITY¶

Functions

int zt_serial_ipc_send_update_to_host(zt_channel_e id)¶

k_tid_t zt_serial_ipc_thread()¶

file zt_uart.h

#include <device.h>#include <zephyr.h>

Functions

int uart_open(char *dev_label)¶

int uart_write(uint8_t *data, size_t size)¶

int uart_write_str(char *str)¶

int uart_write_byte(uint8_t *byte)¶

struct k_msgq *uart_get_input_msgq()¶

struct k_msgq *uart_get_output_msgq()¶

file zt_serial_ipc.c

#include “zt_serial_ipc.h”#include <string.h>#include <sys/crc.h>#include <sys/printk.h>#include <zephyr.h>#include <zt_uart.h>#include “devicetree.h”#include “kernel.h”#include “zeta.h”

Defines

UART_DEVICE_NAME¶: SPDX-License-Identifier: Apache-2.0

MAX_MESSAGE_LENGTH¶

ZT_ISC_PKT_ASSERT_EQ(actual, expected, ret)¶

ZT_ISC_PKT_ASSERT(cond, ret)¶

SELF_TEST_INIT()¶

SELF_TEST_ASSERT(cond)¶

SELF_TEST_FINISH()¶

NUMBER_OF_CHANNELS¶

ZT_ISC_NET_PKT_WITH_MSG_SIZE(_size)¶

Enums

enum zt_isc_net_pkt_op_t¶

Values:

enumerator OP_READ¶

enumerator OP_WRITE¶

enumerator OP_READ_RESPONSE¶

enumerator OP_WRITE_RESPONSE¶

enumerator OP_UPDATE¶

enumerator OP_DEBUG¶

enum pkt_data_availability_t¶

Values:

enumerator DATA_UNAVALABLE¶

enumerator DATA_AVAILABLE¶

enum pkt_status_t¶

Values:

enumerator STATUS_OK¶

enumerator STATUS_FAILED¶

Functions

K_MSGQ_DEFINE (__channel_updated_queue, 1, 16, 1)

void zt_isc_net_pkt_clear(struct zt_isc_net_pkt *self)¶

void zt_isc_net_pkt_send(struct zt_isc_net_pkt *self)¶

int zt_isc_net_pkt_set_message(struct zt_isc_net_pkt *self, char *message, size_t message_size)¶

void zt_isc_net_pkt_calc_crc(struct zt_isc_net_pkt *self)¶

uint8_t zt_isc_net_pkt_header_is_valid(struct zt_isc_net_pkt_header *header)¶

uint8_t zt_isc_net_pkt_message_is_valid(struct zt_isc_net_pkt *pkt)¶

int digest_byte(uint8_t data, struct zt_isc_net_pkt *pkt)¶

uint64_t digest_byte_test()¶

int zt_serial_ipc_send_update_to_host(zt_channel_e id)

void __zt_serial_ipc_tx_thread(void)¶

k_tid_t zt_serial_ipc_thread()

void __zt_serial_ipc_rx_thread(void)¶

K_THREAD_DEFINE (zt_serial_ipc_rx_id, ZT_SERIAL_IPC_RX_THREAD_STACK_SIZE, __zt_serial_ipc_rx_thread, NULL, NULL, NULL, ZT_SERIAL_RX_THREAD_PRIORITY, 0, 0)

K_THREAD_DEFINE (zt_serial_ipc_tx_id, ZT_SERIAL_IPC_TX_THREAD_STACK_SIZE, __zt_serial_ipc_tx_thread, NULL, NULL, NULL, ZT_SERIAL_TX_THREAD_PRIORITY, 0, 0)

Variables

static k_tid_t __current_rx_thread¶

file zt_uart.c

#include “zt_uart.h”#include <drivers/uart.h>#include <zephyr.h>

Functions

K_MSGQ_DEFINE (__input_msgq, sizeof(uint8_t), 512, 1)

K_MSGQ_DEFINE (__output_msgq, sizeof(uint8_t), 512, 1)

static void uart_fifo_callback(const struct device *dev, void *user_data)¶

struct k_msgq *uart_get_input_msgq()

struct k_msgq *uart_get_output_msgq()

int uart_open(char *dev_label)

int uart_write(uint8_t *data, size_t size)

int uart_write_str(char *str)

int uart_write_byte(uint8_t *byte)

Variables

static const struct device *__uart_dev = 0¶

const struct uart_config uart_cfg = {.baudrate = 115200,.parity = UART_CFG_PARITY_NONE,.stop_bits = UART_CFG_STOP_BITS_1,.data_bits = UART_CFG_DATA_BITS_8,.flow_ctrl = UART_CFG_FLOW_CTRL_NONE}

file zeta.py

file zeta_cli.py

file zeta_errors.py

file zeta_isc.py

file zeta_pkt.py

dir /home/docs/checkouts/readthedocs.org/user_builds/zeta-middleware/checkouts/latest/zeta/templates/zeta/include

dir /home/docs/checkouts/readthedocs.org/user_builds/zeta-middleware/checkouts/latest/zeta/templates/zeta/src

dir /home/docs/checkouts/readthedocs.org/user_builds/zeta-middleware/checkouts/latest/zeta/templates

dir /home/docs/checkouts/readthedocs.org/user_builds/zeta-middleware/checkouts/latest/zeta/templates/zeta

dir /home/docs/checkouts/readthedocs.org/user_builds/zeta-middleware/checkouts/latest/zeta

License¶

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Welcome to Zeta’s documentation!¶

Getting started¶

Code documentation¶

License¶

Indices and tables¶