mirrors/uv-k5-firmware-custom
0
Fork 0
mirror of https://github.com/OneOfEleven/uv-k5-firmware-custom.git synced 2025-06-20 06:58:39 +03:00
Code Issues Releases Activity

Initial commit

Browse Source
This commit is contained in:
OneOfEleven
2023-09-09 08:03:56 +01:00
parent 92305117f1
commit 54441e27d9
3388 changed files with 582553 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
external/CMSIS_5/CMSIS/Driver/VIO/Include/cmsis_vio.h vendored Normal file
View File

@ -0,0 +1,175 @@
/******************************************************************************
* @file cmsis_vio.h
* @brief CMSIS Virtual I/O header file
* @version V0.1.0
* @date 23. March 2020
******************************************************************************/
/*
* Copyright (c) 2019-2020 Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* 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
*
* 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.
*/
#ifndef __CMSIS_VIO_H
#define __CMSIS_VIO_H
#include <stdint.h>
/*******************************************************************************
* Generic I/O mapping recommended for CMSIS-VIO
* Note: not every I/O must be physically available
*/
// vioSetSignal: mask values
#define vioLED0 (1U << 0) ///< \ref vioSetSignal \a mask parameter: LED 0 (for 3-color: red)
#define vioLED1 (1U << 1) ///< \ref vioSetSignal \a mask parameter: LED 1 (for 3-color: green)
#define vioLED2 (1U << 2) ///< \ref vioSetSignal \a mask parameter: LED 2 (for 3-color: blue)
#define vioLED3 (1U << 3) ///< \ref vioSetSignal \a mask parameter: LED 3
#define vioLED4 (1U << 4) ///< \ref vioSetSignal \a mask parameter: LED 4
#define vioLED5 (1U << 5) ///< \ref vioSetSignal \a mask parameter: LED 5
#define vioLED6 (1U << 6) ///< \ref vioSetSignal \a mask parameter: LED 6
#define vioLED7 (1U << 7) ///< \ref vioSetSignal \a mask parameter: LED 7
// vioSetSignal: signal values
#define vioLEDon (0xFFU) ///< \ref vioSetSignal \a signal parameter: pattern to turn any LED on
#define vioLEDoff (0x00U) ///< \ref vioSetSignal \a signal parameter: pattern to turn any LED off
// vioGetSignal: mask values and return values
#define vioBUTTON0 (1U << 0) ///< \ref vioGetSignal \a mask parameter: Push button 0
#define vioBUTTON1 (1U << 1) ///< \ref vioGetSignal \a mask parameter: Push button 1
#define vioBUTTON2 (1U << 2) ///< \ref vioGetSignal \a mask parameter: Push button 2
#define vioBUTTON3 (1U << 3) ///< \ref vioGetSignal \a mask parameter: Push button 3
#define vioJOYup (1U << 4) ///< \ref vioGetSignal \a mask parameter: Joystick button: up
#define vioJOYdown (1U << 5) ///< \ref vioGetSignal \a mask parameter: Joystick button: down
#define vioJOYleft (1U << 6) ///< \ref vioGetSignal \a mask parameter: Joystick button: left
#define vioJOYright (1U << 7) ///< \ref vioGetSignal \a mask parameter: Joystick button: right
#define vioJOYselect (1U << 8) ///< \ref vioGetSignal \a mask parameter: Joystick button: select
#define vioJOYall (vioJOYup | \
vioJOYdown | \
vioJOYleft | \
vioJOYright | \
vioJOYselect) ///< \ref vioGetSignal \a mask Joystick button: all
// vioSetValue / vioGetValue: id values
#define vioAIN0 (0U) ///< \ref vioSetValue / \ref vioGetValue \a id parameter: Analog input value 0
#define vioAIN1 (1U) ///< \ref vioSetValue / \ref vioGetValue \a id parameter: Analog input value 1
#define vioAIN2 (2U) ///< \ref vioSetValue / \ref vioGetValue \a id parameter: Analog input value 2
#define vioAIN3 (3U) ///< \ref vioSetValue / \ref vioGetValue \a id parameter: Analog input value 3
#define vioAOUT0 (3U) ///< \ref vioSetValue / \ref vioGetValue \a id parameter: Analog output value 0
// vioSetXYZ / vioGetXZY: id values
#define vioMotionGyro (0U) ///< \ref vioSetXYZ / \ref vioGetXYZ \a id parameter: for Gyroscope
#define vioMotionAccelero (1U) ///< \ref vioSetXYZ / \ref vioGetXYZ \a id parameter: for Accelerometer
#define vioMotionMagneto (2U) ///< \ref vioSetXYZ / \ref vioGetXYZ \a id parameter: for Magnetometer
// vioPrint: levels
#define vioLevelNone (0U) ///< \ref vioPrint \a level parameter: None
#define vioLevelHeading (1U) ///< \ref vioPrint \a level parameter: Heading
#define vioLevelMessage (2U) ///< \ref vioPrint \a level parameter: Message
#define vioLevelError (3U) ///< \ref vioPrint \a level parameter: Error
/// 3-D vector value
typedef struct {
int32_t X; ///< X coordinate
int32_t Y; ///< Y coordinate
int32_t Z; ///< Z coordinate
} vioValueXYZ_t;
/// IPv4 Internet Address
typedef struct {
uint8_t addr[4]; ///< IPv4 address value used in \ref vioSetIPv4 / \ref vioGetIPv4
} vioAddrIPv4_t;
/// IPv6 Internet Address
typedef struct {
uint8_t addr[16]; ///< IPv6 address value used in \ref vioSetIPv6 / \ref vioGetIPv6
} vioAddrIPv6_t;
#ifdef __cplusplus
extern "C"
{
#endif
/// Initialize test input, output.
/// \return none.
void vioInit (void);
/// Print formated string to test terminal.
/// \param[in] level level (vioLevel...).
/// \param[in] format formated string to print.
/// \param[in] ... optional arguments (depending on format string).
/// \return number of characters written or -1 in case of error.
int32_t vioPrint (uint32_t level, const char *format, ...);
/// Set signal output.
/// \param[in] mask bit mask of signals to set.
/// \param[in] signal signal value to set.
/// \return none.
void vioSetSignal (uint32_t mask, uint32_t signal);
/// Get signal input.
/// \param[in] mask bit mask of signals to read.
/// \return signal value.
uint32_t vioGetSignal (uint32_t mask);
/// Set value output.
/// \param[in] id output identifier.
/// \param[in] value value to set.
/// \return none.
void vioSetValue (uint32_t id, int32_t value);
/// Get value input.
/// \param[in] id input identifier.
/// \return value retrieved from input.
int32_t vioGetValue (uint32_t id);
/// Set XYZ value output.
/// \param[in] id output identifier.
/// \param[in] valueXYZ XYZ data to set.
/// \return none.
void vioSetXYZ (uint32_t id, vioValueXYZ_t valueXYZ);
/// Get XYZ value input.
/// \param[in] id input identifier.
/// \return XYZ data retrieved from XYZ peripheral.
vioValueXYZ_t vioGetXYZ (uint32_t id);
/// Set IPv4 address output.
/// \param[in] id output identifier.
/// \param[in] addrIPv4 pointer to IPv4 address.
/// \return none.
void vioSetIPv4 (uint32_t id, vioAddrIPv4_t addrIPv4);
/// Get IPv4 address input.
/// \param[in] id input identifier.
/// \return IPv4 address retrieved from peripheral.
vioAddrIPv4_t vioGetIPv4 (uint32_t id);
/// Set IPv6 address output.
/// \param[in] id output identifier.
/// \param[in] addrIPv6 pointer to IPv6 address.
/// \return none.
void vioSetIPv6 (uint32_t id, vioAddrIPv6_t addrIPv6);
/// Get IPv6 address from peripheral.
/// \param[in] id input identifier.
/// \return IPv6 address retrieved from peripheral.
vioAddrIPv6_t vioGetIPv6 (uint32_t id);
#ifdef __cplusplus
}
#endif
#endif /* __CMSIS_VIO_H */

337
external/CMSIS_5/CMSIS/Driver/VIO/Source/vio.c vendored Normal file
View File

@ -0,0 +1,337 @@
/******************************************************************************
* @file vio.c
* @brief Virtual I/O implementation template
* @version V1.0.0
* @date 23. March 2020
******************************************************************************/
/*
* Copyright (c) 2019-2020 Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* 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
*
* 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.
*/
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "cmsis_vio.h"
#include "RTE_Components.h" // Component selection
#include CMSIS_device_header
#if !defined CMSIS_VOUT || !defined CMSIS_VIN
// Add user includes here:
#endif
// VIO input, output definitions
#define VIO_PRINT_MAX_SIZE 64U // maximum size of print memory
#define VIO_PRINTMEM_NUM 4U // number of print memories
#define VIO_VALUE_NUM 3U // number of values
#define VIO_VALUEXYZ_NUM 3U // number of XYZ values
#define VIO_IPV4_ADDRESS_NUM 2U // number of IPv4 addresses
#define VIO_IPV6_ADDRESS_NUM 2U // number of IPv6 addresses
// VIO input, output variables
__USED uint32_t vioSignalIn; // Memory for incoming signal
__USED uint32_t vioSignalOut; // Memory for outgoing signal
__USED char vioPrintMem[VIO_PRINTMEM_NUM][VIO_PRINT_MAX_SIZE]; // Memory for the last value for each level
__USED int32_t vioValue [VIO_VALUE_NUM]; // Memory for value used in vioGetValue/vioSetValue
__USED vioValueXYZ_t vioValueXYZ[VIO_VALUEXYZ_NUM]; // Memory for XYZ value for 3-D vector
__USED vioAddrIPv4_t vioAddrIPv4[VIO_IPV4_ADDRESS_NUM]; // Memory for IPv4 address value used in vioSetIPv4/vioGetIPv4
__USED vioAddrIPv6_t vioAddrIPv6[VIO_IPV6_ADDRESS_NUM]; // Memory for IPv6 address value used in vioSetIPv6/vioGetIPv6
#if !defined CMSIS_VOUT
// Add global user types, variables, functions here:
#endif
#if !defined CMSIS_VIN
// Add global user types, variables, functions here:
#endif
// Initialize test input, output.
void vioInit (void) {
#if !defined CMSIS_VOUT
// Add user variables here:
#endif
#if !defined CMSIS_VIN
// Add user variables here:
#endif
vioSignalIn = 0U;
vioSignalOut = 0U;
memset (vioPrintMem, 0, sizeof(vioPrintMem));
memset (vioValue, 0, sizeof(vioValue));
memset (vioValueXYZ, 0, sizeof(vioValueXYZ));
memset (vioAddrIPv4, 0, sizeof(vioAddrIPv4));
memset (vioAddrIPv6, 0, sizeof(vioAddrIPv6));
#if !defined CMSIS_VOUT
// Add user code here:
#endif
#if !defined CMSIS_VIN
// Add user code here:
#endif
}
// Print formated string to test terminal.
int32_t vioPrint (uint32_t level, const char *format, ...) {
va_list args;
int32_t ret;
#if !defined CMSIS_VOUT
// Add user variables here:
#endif
if (level > vioLevelError) {
return (-1);
}
if (level > VIO_PRINTMEM_NUM) {
return (-1);
}
va_start(args, format);
ret = vsnprintf((char *)vioPrintMem[level], sizeof(vioPrintMem[level]), format, args);
va_end(args);
#if !defined CMSIS_VOUT
// Add user code here:
#endif
return (ret);
}
// Set signal output.
void vioSetSignal (uint32_t mask, uint32_t signal) {
#if !defined CMSIS_VOUT
// Add user variables here:
#endif
vioSignalOut &= ~mask;
vioSignalOut |= mask & signal;
#if !defined CMSIS_VOUT
// Add user code here:
#endif
}
// Get signal input.
uint32_t vioGetSignal (uint32_t mask) {
uint32_t signal;
#if !defined CMSIS_VIN
// Add user variables here:
#endif
#if !defined CMSIS_VIN
// Add user code here:
// vioSignalIn = ...;
#endif
signal = vioSignalIn;
return (signal & mask);
}
// Set value output.
void vioSetValue (uint32_t id, int32_t value) {
uint32_t index = id;
#if !defined CMSIS_VOUT
// Add user variables here:
#endif
if (index >= VIO_VALUE_NUM) {
return; /* return in case of out-of-range index */
}
vioValue[index] = value;
#if !defined CMSIS_VOUT
// Add user code here:
#endif
}
// Get value input.
int32_t vioGetValue (uint32_t id) {
uint32_t index = id;
int32_t value = 0;
#if !defined CMSIS_VIN
// Add user variables here:
#endif
if (index >= VIO_VALUE_NUM) {
return value; /* return default in case of out-of-range index */
}
#if !defined CMSIS_VIN
// Add user code here:
// vioValue[index] = ...;
#endif
value = vioValue[index];
return value;
}
// Set XYZ value output.
void vioSetXYZ (uint32_t id, vioValueXYZ_t valueXYZ) {
uint32_t index = id;
#if !defined CMSIS_VOUT
// Add user variables here:
#endif
if (index >= VIO_VALUEXYZ_NUM) {
return; /* return in case of out-of-range index */
}
vioValueXYZ[index] = valueXYZ;
#if !defined CMSIS_VOUT
// Add user code here:
#endif
}
// Get XYZ value input.
vioValueXYZ_t vioGetXYZ (uint32_t id) {
uint32_t index = id;
vioValueXYZ_t valueXYZ = {0, 0, 0};
#if !defined CMSIS_VIN
// Add user variables here:
#endif
if (index >= VIO_VALUEXYZ_NUM) {
return valueXYZ; /* return default in case of out-of-range index */
}
#if !defined CMSIS_VIN
// Add user code here:
// vioValueXYZ[index] = ...;
#endif
valueXYZ = vioValueXYZ[index];
return valueXYZ;
}
// Set IPv4 address output.
void vioSetIPv4 (uint32_t id, vioAddrIPv4_t addrIPv4) {
uint32_t index = id;
#if !defined CMSIS_VOUT
// Add user variables here:
#endif
if (index >= VIO_IPV4_ADDRESS_NUM) {
return; /* return in case of out-of-range index */
}
vioAddrIPv4[index] = addrIPv4;
#if !defined CMSIS_VOUT
// Add user code here:
#endif
}
// Get IPv4 address input.
vioAddrIPv4_t vioGetIPv4 (uint32_t id) {
uint32_t index = id;
vioAddrIPv4_t addrIPv4 = {0U, 0U, 0U, 0U};
#if !defined CMSIS_VIN
// Add user variables here:
#endif
if (index >= VIO_IPV4_ADDRESS_NUM) {
return addrIPv4; /* return default in case of out-of-range index */
}
#if !defined CMSIS_VIN
// Add user code here:
// vioAddrIPv4[index] = ...;
#endif
addrIPv4 = vioAddrIPv4[index];
return addrIPv4;
}
// Set IPv6 address output.
void vioSetIPv6 (uint32_t id, vioAddrIPv6_t addrIPv6) {
uint32_t index = id;
#if !defined CMSIS_VOUT
// Add user variables here:
#endif
if (index >= VIO_IPV6_ADDRESS_NUM) {
return; /* return in case of out-of-range index */
}
vioAddrIPv6[index] = addrIPv6;
#if !defined CMSIS_VOUT
// Add user code here:
#endif
}
// Get IPv6 address input.
vioAddrIPv6_t vioGetIPv6 (uint32_t id) {
uint32_t index = id;
vioAddrIPv6_t addrIPv6 = {0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U,
0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U};
#if !defined CMSIS_VIN
// Add user variables here:
#endif
if (index >= VIO_IPV6_ADDRESS_NUM) {
return addrIPv6; /* return default in case of out-of-range index */
}
#if !defined CMSIS_VIN
// Add user code here:
// vioAddrIPv6[index] = ...;
#endif
addrIPv6 = vioAddrIPv6[index];
return addrIPv6;
}

208
external/CMSIS_5/CMSIS/Driver/VIO/Source/vio_memory.c vendored Normal file
View File

@ -0,0 +1,208 @@
/******************************************************************************
* @file vio_memory.c
* @brief Virtual I/O implementation using memory only
* @version V1.0.0
* @date 23. March 2020
******************************************************************************/
/*
* Copyright (c) 2019-2020 Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* 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
*
* 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.
*/
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "cmsis_vio.h"
#include "RTE_Components.h" // Component selection
#include CMSIS_device_header
// VIO input, output definitions
#define VIO_PRINT_MAX_SIZE 64U // maximum size of print memory
#define VIO_PRINTMEM_NUM 4U // number of print memories
#ifndef VIO_VALUE_NUM
#define VIO_VALUE_NUM 3U // number of values
#endif
#ifndef VIO_VALUEXYZ_NUM
#define VIO_VALUEXYZ_NUM 3U // number of XYZ values
#endif
#ifndef VIO_IPV4_ADDRESS_NUM
#define VIO_IPV4_ADDRESS_NUM 2U // number of IPv4 addresses
#endif
#ifndef VIO_IPV6_ADDRESS_NUM
#define VIO_IPV6_ADDRESS_NUM 2U // number of IPv6 addresses
#endif
// VIO input, output variables
__USED uint32_t vioSignalIn;
__USED uint32_t vioSignalOut;
__USED char vioPrintMem[VIO_PRINTMEM_NUM][VIO_PRINT_MAX_SIZE];
__USED int32_t vioValue [VIO_VALUE_NUM];
__USED vioValueXYZ_t vioValueXYZ[VIO_VALUEXYZ_NUM];
__USED vioAddrIPv4_t vioAddrIPv4[VIO_IPV4_ADDRESS_NUM];
__USED vioAddrIPv6_t vioAddrIPv6[VIO_IPV6_ADDRESS_NUM];
// Initialize test input, output.
void vioInit (void) {
vioSignalIn = 0U;
vioSignalOut = 0U;
memset (vioPrintMem, 0, sizeof(vioPrintMem));
memset (vioValue, 0, sizeof(vioValue));
memset (vioValueXYZ, 0, sizeof(vioValueXYZ));
memset (vioAddrIPv4, 0, sizeof(vioAddrIPv4));
memset (vioAddrIPv6, 0, sizeof(vioAddrIPv6));
}
// Print formated string to test terminal.
int32_t vioPrint (uint32_t level, const char *format, ...) {
va_list args;
int32_t ret;
if (level > vioLevelError) {
return (-1);
}
if (level > VIO_PRINTMEM_NUM) {
return (-1);
}
va_start(args, format);
ret = vsnprintf((char *)vioPrintMem[level], sizeof(vioPrintMem[level]), format, args);
va_end(args);
return (ret);
}
// Set signal output.
void vioSetSignal (uint32_t mask, uint32_t signal) {
vioSignalOut &= ~mask;
vioSignalOut |= mask & signal;
}
// Get signal input.
uint32_t vioGetSignal (uint32_t mask) {
uint32_t signal;
signal = vioSignalIn;
return (signal & mask);
}
// Set value output.
void vioSetValue (uint32_t id, int32_t value) {
uint32_t index = id;
if (index >= VIO_VALUE_NUM) {
return; /* return in case of out-of-range index */
}
vioValue[index] = value;
}
// Get value input.
int32_t vioGetValue (uint32_t id) {
uint32_t index = id;
int32_t value = 0;
if (index >= VIO_VALUE_NUM) {
return value; /* return default in case of out-of-range index */
}
value = vioValue[index];
return value;
}
// Set XYZ value output.
void vioSetXYZ (uint32_t id, vioValueXYZ_t valueXYZ) {
uint32_t index = id;
if (index >= VIO_VALUEXYZ_NUM) {
return; /* return in case of out-of-range index */
}
vioValueXYZ[index] = valueXYZ;
}
// Get XYZ value input.
vioValueXYZ_t vioGetXYZ (uint32_t id) {
uint32_t index = id;
vioValueXYZ_t valueXYZ = {0, 0, 0};
if (index >= VIO_VALUEXYZ_NUM) {
return valueXYZ; /* return default in case of out-of-range index */
}
valueXYZ = vioValueXYZ[index];
return valueXYZ;
}
// Set IPv4 address output.
void vioSetIPv4 (uint32_t id, vioAddrIPv4_t addrIPv4) {
uint32_t index = id;
if (index >= VIO_IPV4_ADDRESS_NUM) {
return; /* return in case of out-of-range index */
}
vioAddrIPv4[index] = addrIPv4;
}
// Get IPv4 address input.
vioAddrIPv4_t vioGetIPv4 (uint32_t id) {
uint32_t index = id;
vioAddrIPv4_t addrIPv4 = {0U, 0U, 0U, 0U};
if (index >= VIO_IPV4_ADDRESS_NUM) {
return addrIPv4; /* return default in case of out-of-range index */
}
addrIPv4 = vioAddrIPv4[index];
return addrIPv4;
}
// Set IPv6 address output.
void vioSetIPv6 (uint32_t id, vioAddrIPv6_t addrIPv6) {
uint32_t index = id;
if (index >= VIO_IPV6_ADDRESS_NUM) {
return; /* return in case of out-of-range index */
}
vioAddrIPv6[index] = addrIPv6;
}
// Get IPv6 address input.
vioAddrIPv6_t vioGetIPv6 (uint32_t id) {
uint32_t index = id;
vioAddrIPv6_t addrIPv6 = {0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U,
0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U};
if (index >= VIO_IPV6_ADDRESS_NUM) {
return addrIPv6; /* return default in case of out-of-range index */
}
addrIPv6 = vioAddrIPv6[index];
return addrIPv6;
}

78
external/CMSIS_5/CMSIS/Driver/VIO/cmsis_vio.scvd vendored Normal file
View File

@ -0,0 +1,78 @@
<?xml version="1.0" encoding="utf-8"?>
<component_viewer schemaVersion="1.2.0" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance" xs:noNamespaceSchemaLocation="Component_Viewer.xsd">
<component name="CMSIS-Driver VIO" version="1.0.0"/>
<typedefs>
<typedef name="vioPrintMem_t" size="64">
<member name="mem" type="uint8_t" size="64" offset="0"/>
</typedef>
<typedef name="vioValueXYZ_t" size="12">
<member name="X" type="int32_t" offset="0"/>
<member name="Y" type="int32_t" offset="4"/>
<member name="Z" type="int32_t" offset="8"/>
</typedef>
<typedef name="vioAddrIPv4_t" size="4">
<member name="addr" type="uint8_t" size="4" offset="0"/>
</typedef>
<typedef name="vioAddrIPv6_t" size="16">
<member name="addr" type="uint8_t" size="16" offset="0"/>
</typedef>
</typedefs>
<objects>
<object name="VIO Object">
<var name="i" type="int32_t" value="0"/>
<read name="SignalIn" type="uint32_t" symbol="vioSignalIn"/>
<read name="SignalOut" type="uint32_t" symbol="vioSignalOut"/>
<readlist name="PrintMem" type="vioPrintMem_t" symbol="vioPrintMem" count="4"/>
<read name="Value" type="int32_t" symbol="vioValue" size="__size_of(&quot;vioValue&quot;)"/>
<readlist name="ValueXYZ" type="vioValueXYZ_t" symbol="vioValueXYZ" count="__size_of(&quot;vioValueXYZ&quot;)"/>
<readlist name="IPv4Address" type="vioAddrIPv4_t" symbol="vioAddrIPv4" count="__size_of(&quot;vioAddrIPv4&quot;)"/>
<readlist name="IPv6Address" type="vioAddrIPv6_t" symbol="vioAddrIPv6" count="__size_of(&quot;vioAddrIPv6&quot;)"/>
<out name="CMSIS-Driver VIO">
<item property="Signal Bits (Input)" value="%x[SignalIn]"/>
<item property="Signal Bits (Output)" value="%x[SignalOut]"/>
<item property="Print Memory Array">
<list name="i" start="0" limit="PrintMem._count">
<item property="Print Memory[%d[i]]" value="%t[PrintMem[i].mem]"/>
</list>
</item>
<item property="Value Array">
<list name="i" start="0" limit="Value._count">
<item property="Value[%d[i]]" value="%d[Value[i]]"/>
</list>
</item>
<item property="ValueXYZ Array">
<list name="i" start="0" limit="ValueXYZ._count">
<item property="ValueXYZ[%d[i]]" value="X: %d[ValueXYZ[i].X] Y: %d[ValueXYZ[i].Y] Z: %d[ValueXYZ[i].Z]"/>
</list>
</item>
<item property="IP4 Address Array">
<list name="i" start="0" limit="IPv4Address._count">
<item property="IP4 Address[%d[i]]" value="%I[IPv4Address[i].addr]"/>
</list>
</item>
<item property="IP6 Address Array">
<list name="i" start="0" limit="IPv6Address._count">
<item property="IP6 Address[%d[i]]" value="%J[IPv6Address[i].addr]"/>
</list>
</item>
</out>
</object>
</objects>
</component_viewer>