fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-10-14 16:43:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

restore UAVCAN bootloader support

Browse Source 
- essentially reverting #7878 minus the obsolete board support
This commit is contained in:
Daniel Agar
2020-04-19 16:10:09 -04:00
committed by GitHub
parent 7c533e5a53
commit a3ad710623
30 changed files with 6658 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
platforms/nuttx/src/canbootloader/include/bitminip.h
+51
View File
@@ -0,0 +1,51 @@
/****************************************************************************
*
* Copyright (c) 2012-2015 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/*
* @file board.h
*
* bootloader board interface
* This file contains the common interfaces that all boards
* have to supply
*/
#pragma once
#define BIT(pos) (1ull<<(pos))
#define BIT_MASK(length) (BIT(length)-1)
#define BITFEILD_MASK(lsb_pos, length) ( BIT_MASK(length) << (lsb_pos))
#define BITFEILD_ISOLATE(x, lsb_pos, length) ((x) & (BITFEILD_MASK((lsb_pos), (length))))
#define BITFEILD_EXCLUDE(x, lsb_pos, length) ((x) & ~(BITFEILD_MASK((lsb_pos), (length))))
#define BITFEILD_GET(y, lsb_pos, length) (((y)>>(lsb_pos)) & BIT_MASK(length))
#define BITFEILD_SET(y, x, lsb_pos, length) ( y= ((y) & ~BF_MASK(lsb_pos, length)) | BITFEILD_ISOLATE(x, lsb_pos, length))
platforms/nuttx/src/canbootloader/include/blsched.h
+59
View File
@@ -0,0 +1,59 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
/****************************************************************************
* Name: sched_yield()
*
* Description:
* This function should be called in situation were the cpu may be
* busy for a long time without interrupts or the ability to run code
* to insure that the timer based process will be run.
*
*
* Input Parameters:
* None
*
* Returned value:
* None
*
****************************************************************************/
#if defined(OPT_USE_YIELD)
void bl_sched_yield(void);
#else
# define bl_sched_yield()
#endif
platforms/nuttx/src/canbootloader/include/board.h
+129
View File
@@ -0,0 +1,129 @@
/****************************************************************************
*
* Copyright (c) 2012-2015 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/*
* @file board.h
*
* bootloader board interface
* This file contains the common interfaces that all boards
* have to supply
*/
#pragma once
#include "uavcan.h"
#include <nuttx/compiler.h>
#include <stdint.h>
typedef enum {
off,
reset,
autobaud_start,
autobaud_end,
allocation_start,
allocation_end,
fw_update_start,
fw_update_erase_fail,
fw_update_invalid_response,
fw_update_timeout,
fw_update_invalid_crc,
jump_to_app,
} uiindication_t;
#ifndef __ASSEMBLY__
/************************************************************************************
* Name: stm32_boarddeinitialize
*
* Description:
* This function is called by the bootloader code priore to booting
* the application. Is should place the HW into an benign initialized state.
*
************************************************************************************/
void stm32_boarddeinitialize(void);
/****************************************************************************
* Name: board_get_product_name
*
* Description:
* Called to retrive the product name. The retuned alue is a assumed
* to be written to a pascal style string that will be length prefixed
* and not null terminated
*
* Input Parameters:
* product_name - A pointer to a buffer to write the name.
* maxlen - The imum number of chatater that can be written
*
* Returned Value:
* The length of charaacters written to the buffer.
*
****************************************************************************/
uint8_t board_get_product_name(uint8_t *product_name, size_t maxlen);
/****************************************************************************
* Name: board_get_hardware_version
*
* Description:
* Called to retrieve the hardware version information. The function
* will first initialize the the callers struct to all zeros.
*
* Input Parameters:
* hw_version - A pointer to a uavcan_hardwareversion_t.
*
* Returned Value:
* Length of the unique_id
*
****************************************************************************/
size_t board_get_hardware_version(uavcan_HardwareVersion_t *hw_version);
/****************************************************************************
* Name: board_indicate
*
* Description:
* Provides User feedback to indicate the state of the bootloader
* on board specific hardware.
*
* Input Parameters:
* indication - A member of the uiindication_t
*
* Returned Value:
* None
*
****************************************************************************/
void board_indicate(uiindication_t indication);
#endif /* __ASSEMBLY__ */
platforms/nuttx/src/canbootloader/include/board_common.h
+77
View File
@@ -0,0 +1,77 @@
/****************************************************************************
*
* Copyright (C) 2016 PX4 Development Team. All rights reserved.
* Author: David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file board_common.h
*
* Provide the the common board interfaces
*/
#pragma once
/* Defined the types used for board UUID and MFG UID
*
* A type suitable for holding the byte format of the UUID
*
* The original PX4 stm32 (legacy) based implementation **displayed** the
* UUID as: ABCD EFGH IJKL
* Where:
* A was bit 31 and D was bit 0
* E was bit 63 and H was bit 32
* I was bit 95 and L was bit 64
*
* Since the string was used by some manufactures to identify the units
* it must be preserved.
*
* For new targets moving forward we will use
* IJKL EFGH ABCD
*/
/* A type suitable for defining the 8 bit format of the MFG UID
* This is always returned as MSD @ index 0 -LSD @ index PX4_CPU_MFGUID_BYTE_LENGTH-1
*/
typedef uint8_t mfguid_t[PX4_CPU_MFGUID_BYTE_LENGTH];
/************************************************************************************
* Name: board_get_mfguid
*
* Description:
* All boards either provide a way to retrieve a manafactuers Uniqe ID or
* define BOARD_OVERRIDE_MFGUID.
* The MFGUID is returned as an array of bytes in
* MSD @ index 0 - LSD @ index PX4_CPU_MFGUID_BYTE_LENGTH-1
*
************************************************************************************/
int board_get_mfguid(mfguid_t mfgid);
platforms/nuttx/src/canbootloader/include/boot_app_shared.h
+216
View File
@@ -0,0 +1,216 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
#include <nuttx/compiler.h>
__BEGIN_DECLS
/* Define the signature for the Application descriptor as 'APDesc' and a
* revision number of 00 used in app_descriptor_t
*/
#define APP_DESCRIPTOR_SIGNATURE_ID 'A','P','D','e','s','c'
#define APP_DESCRIPTOR_SIGNATURE_REV '0','0'
#define APP_DESCRIPTOR_SIGNATURE APP_DESCRIPTOR_SIGNATURE_ID, APP_DESCRIPTOR_SIGNATURE_REV
/* N.B. the .ld file must emit this sections */
# define boot_app_shared_section __attribute__((section(".app_descriptor")))
/* eRole defines the role of the bootloader_app_shared_t structure */
typedef enum eRole {
Invalid,
App,
BootLoader
} eRole_t;
/****************************************************************************
*
* Bootloader and Application shared structure.
*
* The data in this structure is passed in SRAM or the the CAN filter
* registers from bootloader to application and application to bootloader.
*
* Do not assume any mapping or location for the passing of this data
* that is done in the read and write routines and is abstracted by design.
*
* For reference, the following is performed based on eRole in API calls
* defined below:
*
* The application must write BOOTLOADER_COMMON_APP_SIGNATURE to the
* signature field when passing data to the bootloader; when the
* bootloader passes data to the application, it must write
* BOOTLOADER_COMMON_BOOTLOADER_SIGNATURE to the signature field.
*
* The CRC is calculated over the structure from signature to the
* last byte. The resulting values are then copied to the CAN filter
* registers by bootloader_app_shared_read and
* bootloader_app_shared_write.
*
****************************************************************************/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
typedef begin_packed_struct struct bootloader_app_shared_t {
union {
uint64_t ull;
uint32_t ul[2];
uint8_t valid;
} crc;
uint32_t signature;
uint32_t bus_speed;
uint32_t node_id;
} end_packed_struct bootloader_app_shared_t;
#pragma GCC diagnostic pop
/****************************************************************************
*
* Application firmware descriptor.
*
* This structure located by the linker script somewhere after the vector table.
* (within the first several kilobytes of the beginning address of the
* application);
*
* This structure must be aligned on an 8-byte boundary.
*
* The bootloader will scan through the application FLASH image until it
* finds the signature.
*
* The image_crc is calculated as follows:
* 1) All fields of this structure must be initialized with the correct
* information about the firmware image bin file
* (Here after refereed to as image)
* 2) image_crc set to 0;
* 3) The CRC 64 is calculated over the image from offset 0 up to and including the
* last byte of the image file.
* 4) The calculated CRC 64 is stored in image_crc
* 5) The new image file is then written to a file a ".img" extension.
*
****************************************************************************/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#pragma GCC diagnostic ignored "-Wpacked"
typedef begin_packed_struct struct app_descriptor_t {
uint8_t signature[sizeof(uint64_t)];
uint64_t image_crc;
uint32_t image_size;
uint32_t vcs_commit;
uint8_t major_version;
uint8_t minor_version;
uint8_t reserved[6];
} end_packed_struct app_descriptor_t;
#pragma GCC diagnostic pop
/****************************************************************************
* Name: bootloader_app_shared_read
*
* Description:
* Based on the role requested, this function will conditionally populate
* a bootloader_app_shared_t structure from the physical locations used
* to transfer the shared data to/from an application (internal data) .
*
* The functions will only populate the structure and return a status
* indicating success, if the internal data has the correct signature as
* requested by the Role AND has a valid crc.
*
* Input Parameters:
* shared - A pointer to a bootloader_app_shared_t return the data in if
* the internal data is valid for the requested Role
* role - An eRole_t of App or BootLoader to validate the internal data
* against. For a Bootloader this would be the value of App to
* read the application passed data.
*
* Returned value:
* OK - Indicates that the internal data has been copied to callers
* bootloader_app_shared_t structure.
*
* -EBADR - The Role or crc of the internal data was not valid. The copy
* did not occur.
*
****************************************************************************/
int bootloader_app_shared_read(bootloader_app_shared_t *shared, eRole_t role);
/****************************************************************************
* Name: bootloader_app_shared_write
*
* Description:
* Based on the role, this function will commit the data passed
* into the physical locations used to transfer the shared data to/from
* an application (internal data) .
*
* The functions will populate the signature and crc the data
* based on the provided Role.
*
* Input Parameters:
* shared - A pointer to a bootloader_app_shared_t data to commit to
* the internal data for passing to/from an application.
* role - An eRole_t of App or BootLoader to use in the internal data
* to be passed to/from an application. For a Bootloader this
* would be the value of Bootloader to write to the passed data.
* to the application via the internal data.
*
* Returned value:
* None.
*
****************************************************************************/
void bootloader_app_shared_write(bootloader_app_shared_t *shared, eRole_t role);
/****************************************************************************
* Name: bootloader_app_shared_invalidate
*
* Description:
* Invalidates the data passed the physical locations used to transfer
* the shared data to/from an application (internal data) .
*
* The functions will invalidate the signature and crc and should be used
* to prevent deja vu.
*
* Input Parameters:
* None.
*
* Returned value:
* None.
*
****************************************************************************/
void bootloader_app_shared_invalidate(void);
__END_DECLS
platforms/nuttx/src/canbootloader/include/can.h
+218
View File
@@ -0,0 +1,218 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
#include "timer.h"
typedef enum {
CanPayloadLength = 8,
} can_const_t;
typedef enum {
CAN_OK = 0,
CAN_BOOT_TIMEOUT,
CAN_ERROR
} can_error_t;
typedef enum {
CAN_UNKNOWN = 0,
CAN_125KBAUD = 1,
CAN_250KBAUD = 2,
CAN_500KBAUD = 3,
CAN_1MBAUD = 4
} can_speed_t;
typedef enum {
CAN_Mode_Normal = 0, // Bits 30 and 31 00
CAN_Mode_LoopBack = 1, // Bit 30: Loop Back Mode (Debug)
CAN_Mode_Silent = 2, // Bit 31: Silent Mode (Debug)
CAN_Mode_Silent_LoopBack = 3 // Bits 30 and 31 11
} can_mode_t;
/*
* Receive from FIFO 1 -- filters are configured to push the messages there,
* and there are send/receive functions called off the SysTick ISR so
* we partition the usage of the CAN hardware to avoid the same FIFOs/mailboxes
* as the rest of the application uses.
*/
typedef enum {
Fifo0 = 0,
MailBox0 = 0,
Fifo1 = 1,
MailBox1 = 1,
Fifo2 = 2,
MailBox2 = 2,
FifoNone = 3,
MailBoxNone = 3,
} can_fifo_mailbox_t;
/****************************************************************************
* Name: can_speed2freq
*
* Description:
* This function maps a can_speed_t to a bit rate in Hz
*
* Input Parameters:
* can_speed - A can_speed_t from CAN_125KBAUD to CAN_1MBAUD
*
* Returned value:
* Bit rate in Hz
*
****************************************************************************/
int can_speed2freq(can_speed_t speed);
/****************************************************************************
* Name: can_speed2freq
*
* Description:
* This function maps a frequency in Hz to a can_speed_t in the range
* CAN_125KBAUD to CAN_1MBAUD.
*
* Input Parameters:
* freq - Bit rate in Hz
*
* Returned value:
* A can_speed_t from CAN_125KBAUD to CAN_1MBAUD
*
****************************************************************************/
can_speed_t can_freq2speed(int freq);
/****************************************************************************
* Name: can_tx
*
* Description:
* This function is called to transmit a CAN frame using the supplied
* mailbox. It will busy wait on the mailbox if not available.
*
* Input Parameters:
* message_id - The CAN message's EXID field
* length - The number of bytes of data - the DLC field
* message - A pointer to 8 bytes of data to be sent (all 8 bytes will be
* loaded into the CAN transmitter but only length bytes will
* be sent.
* mailbox - A can_fifo_mailbox_t MBxxx value to choose the outgoing
* mailbox.
*
* Returned value:
* The CAN_OK of the data sent or CAN_ERROR if a time out occurred
*
****************************************************************************/
uint8_t can_tx(uint32_t message_id, size_t length, const uint8_t *message, uint8_t mailbox);
/****************************************************************************
* Name: can_rx
*
* Description:
* This function is called to receive a CAN frame from a supplied fifo.
* It does not block if there is not available, but returns 0
*
* Input Parameters:
* message_id - A pointer to return the CAN message's EXID field
* length - A pointer to return the number of bytes of data - the DLC field
* message - A pointer to return 8 bytes of data to be sent (all 8 bytes will
* be written from the CAN receiver but only length bytes will be sent.
* fifo A can_fifo_mailbox_t fifixxx value to choose the incoming fifo.
*
* Returned value:
* The length of the data read or 0 if the fifo was empty
*
****************************************************************************/
uint8_t can_rx(uint32_t *message_id, size_t *length, uint8_t *message, uint8_t fifo);
/****************************************************************************
* Name: can_init
*
* Description:
* This function is used to initialize the CAN block for a given bit rate and
* mode.
*
* Input Parameters:
* speed - A can_speed_t from CAN_125KBAUD to CAN_1MBAUD
* mode - One of the can_mode_t of Normal, LoopBack and Silent or
* combination thereof.
*
* Returned value:
* OK - on Success or a negate errno value
*
****************************************************************************/
int can_init(can_speed_t speed, can_mode_t mode);
/****************************************************************************
* Name: can_autobaud
*
* Description:
* This function will attempt to detect the bit rate in use on the CAN
* interface until the timeout provided expires or the successful detection
* occurs.
*
* It will initialize the CAN block for a given bit rate
* to test that a message can be received. The CAN interface is left
* operating at the detected bit rate and in CAN_Mode_Normal mode.
*
* Input Parameters:
* can_speed - A pointer to return detected can_speed_t from CAN_UNKNOWN to
* CAN_1MBAUD
* timeout - The timer id of a timer to use as the maximum time to wait for
* successful bit rate detection. This timer may be not running
* in which case the auto baud code will try indefinitely to
* detect the bit rate.
*
* Returned value:
* CAN_OK - on Success or a CAN_BOOT_TIMEOUT
*
****************************************************************************/
int can_autobaud(can_speed_t *can_speed, bl_timer_id timeout);
/****************************************************************************
* Name: can_cancel_on_error
*
* Description:
* This function will test for transition completion or any error.
* If the is a error the the transmit will be aborted.
*
* Input Parameters:
* mailbox - A can_fifo_mailbox_t MBxxx value to choose the outgoing
* mailbox.
*
* Returned value:
* None
*
****************************************************************************/
void can_cancel_on_error(uint8_t mailbox);
platforms/nuttx/src/canbootloader/include/crc.h
+95
View File
@@ -0,0 +1,95 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
#define CRC16_INITIAL 0xFFFFu
#define CRC16_OUTPUT_XOR 0x0000u
#define CRC64_INITIAL 0xFFFFFFFFFFFFFFFFull
#define CRC64_OUTPUT_XOR 0xFFFFFFFFFFFFFFFFull
/****************************************************************************
* Name: crc16_add
*
* Description:
* Use to calculates a CRC-16-CCITT using the polynomial of
* 0x1021 by adding a value successive values.
*
* Input Parameters:
* crc - The running total of the crc 16
* value - The value to add
*
* Returned Value:
* The current crc16 with the value processed.
*
****************************************************************************/
uint16_t crc16_add(uint16_t crc, uint8_t value);
/****************************************************************************
* Name: crc16_signature
*
* Description:
* Calculates a CRC-16-CCITT using the crc16_add
* function
*
* Input Parameters:
* initial - The Initial value to uses as the crc's starting point
* length - The number of bytes to add to the crc
* bytes - A pointer to any array of length bytes
*
* Returned Value:
* The crc16 of the array of bytes
*
****************************************************************************/
uint16_t crc16_signature(uint16_t initial, size_t length, const uint8_t *bytes);
/****************************************************************************
* Name: crc64_add_word
*
* Description:
* Calculates a CRC-64-WE using the polynomial of 0x42F0E1EBA9EA3693
* See http://reveng.sourceforge.net/crc-catalogue/17plus.htm#crc.cat-bits.64
* Check: 0x62EC59E3F1A4F00A
*
* Input Parameters:
* crc - The running total of the crc 64
* value - The value to add
*
* Returned Value:
* The current crc64 with the value processed.
*
****************************************************************************/
uint64_t crc64_add_word(uint64_t crc, uint32_t value);
platforms/nuttx/src/canbootloader/include/flash.h
+85
View File
@@ -0,0 +1,85 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
typedef enum {
FLASH_OK = 0,
FLASH_ERROR,
FLASH_ERASE_ERROR,
FLASH_ERASE_VERIFY_ERROR,
FLASH_ERROR_SUICIDE,
FLASH_ERROR_AFU,
} flash_error_t;
/****************************************************************************
* Name: bl_flash_erase
*
* Description:
* This function erases the flash starting at address and ending at
* address + nbytes.
*
* Input Parameters:
* address - A word-aligned address within the first page of flash to erase
* nbytes - The number of bytes to erase, rounding up to the next page.
*
*
*
* Returned value:
* On success FLASH_OK On Error one of the flash_error_t
*
****************************************************************************/
flash_error_t bl_flash_erase(size_t address, size_t nbytes);
/****************************************************************************
* Name: bl_flash_write
*
* Description:
* This function writes the flash starting at the given address
*
* Input Parameters:
* flash_address - The address of the flash to write
* must be word aligned
* data - A pointer to a buffer count bytes to be written
* to the flash.
* count - Number of bytes to write
*
* Returned value:
* On success FLASH_OK On Error one of the flash_error_t
*
****************************************************************************/
flash_error_t bl_flash_write(uint32_t flash_address, uint8_t *data, ssize_t count);
platforms/nuttx/src/canbootloader/include/px4_config.h
+51
View File
@@ -0,0 +1,51 @@
/****************************************************************************
*
* Copyright (C) 2015 Mark Charlebois. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file px4_config.h
Configuration flags used in code.
*/
#pragma once
#if defined(__PX4_NUTTX)
#include <nuttx/config.h>
#include <nuttx/arch.h>
#include "px4_micro_hal.h"
#include <board_config.h>
#elif defined (__PX4_POSIX)
# include <board_config.h>
#endif
platforms/nuttx/src/canbootloader/include/px4_macros.h
+116
View File
@@ -0,0 +1,116 @@
/****************************************************************************
*
* Copyright (C) 2014 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file px4_macros.h
*
* A set of useful macros for enhanced runtime and compile time
* error detection and warning suppression.
*
* Define NO_BLOAT to reduce bloat from file name inclusion.
*
* The arraySize() will compute the size of an array regardless
* it's type
*
* INVALID_CASE(c) should be used is case statements to ferret out
* unintended behavior
*
* UNUSED(var) will suppress compile time warnings of unused
* variables
*
* CCASSERT(predicate) Will generate a compile time error it the
* predicate is false
*/
#include <assert.h>
#ifndef _PX4_MACROS_H
#define _PX4_MACROS_H
#if !defined(arraySize)
#define arraySize(a) (sizeof((a))/sizeof((a[0])))
#endif
#if !defined(NO_BLOAT)
#if defined(__BASE_FILE__)
#define _FILE_NAME_ __BASE_FILE__
#else
#define _FILE_NAME_ __FILE__
#endif
#else
#define _FILE_NAME_ ""
#endif
#if !defined(INVALID_CASE)
#define INVALID_CASE(c) printf("Invalid Case %d, %s:%d",(c),__BASE_FILE__,__LINE__) /* todo use PANIC */
#endif
#if !defined(UNUSED)
#define UNUSED(var) (void)(var)
#endif
#if !defined(CAT)
#if !defined(_CAT)
#define _CAT(a, b) a ## b
#endif
#define CAT(a, b) _CAT(a, b)
#endif
#if !defined(FREEZE_STR)
# define FREEZE_STR(s) #s
#endif
#if !defined(STRINGIFY)
#define STRINGIFY(s) FREEZE_STR(s)
#endif
#if !defined(CCASSERT)
#if defined(static_assert)
# define CCASSERT(predicate) static_assert(predicate, STRINGIFY(predicate))
# else
# define CCASSERT(predicate) _x_CCASSERT_LINE(predicate, __LINE__)
# if !defined(_x_CCASSERT_LINE)
# define _x_CCASSERT_LINE(predicate, line) typedef char CAT(constraint_violated_on_line_,line)[2*((predicate)!=0)-1] __attribute__ ((unused)) ;
# endif
# endif
#endif
#if !defined(DO_PRAGMA)
# define DO_PRAGMA(x) _Pragma (#x)
#endif
#if !defined(TODO)
# define TODO(x) DO_PRAGMA(message ("TODO - " #x))
#endif
#endif /* _PX4_MACROS_H */
platforms/nuttx/src/canbootloader/include/px4_micro_hal.h
+56
View File
@@ -0,0 +1,56 @@
/****************************************************************************
*
* Copyright (c) 2016 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
/*
* This file is a shim to bridge to nuttx_v3
*/
__BEGIN_DECLS
# define PX4_CPU_UUID_BYTE_LENGTH 12
# define PX4_CPU_UUID_WORD32_LENGTH (PX4_CPU_UUID_BYTE_LENGTH/sizeof(uint32_t))
/* The mfguid will be an array of bytes with
* MSD @ index 0 - LSD @ index PX4_CPU_MFGUID_BYTE_LENGTH-1
*
* It will be converted to a string with the MSD on left and LSD on the right most position.
*/
# define PX4_CPU_MFGUID_BYTE_LENGTH PX4_CPU_UUID_BYTE_LENGTH
/* Separator nnn:nnn:nnnn 2 char per byte term */
# define PX4_CPU_UUID_WORD32_FORMAT_SIZE (PX4_CPU_UUID_WORD32_LENGTH-1+(2*PX4_CPU_UUID_BYTE_LENGTH)+1)
# define PX4_CPU_MFGUID_FORMAT_SIZE ((2*PX4_CPU_MFGUID_BYTE_LENGTH)+1)
#include <arch/board/board.h>
__END_DECLS
platforms/nuttx/src/canbootloader/include/random.h
+75
View File
@@ -0,0 +1,75 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
#define CRC16_INITIAL 0xFFFFu
#define CRC16_OUTPUT_XOR 0x0000u
#define CRC64_INITIAL 0xFFFFFFFFFFFFFFFFull
#define CRC64_OUTPUT_XOR 0xFFFFFFFFFFFFFFFFull
/****************************************************************************
* Name: util_srand
*
* Description:
* This function seeds the random number generator
*
*
* Input Parameters:
* seed - The seed
*
* Returned value:
* None
*
****************************************************************************/
void util_srand(uint16_t seed);
/****************************************************************************
* Name: util_random
*
* Description:
* This function returns a random number between min and max
*
*
* Input Parameters:
* min - The minimum value the return value can be.
* max - The maximum value the return value can be.
*
* Returned value:
* A random number
*
****************************************************************************/
uint16_t util_random(uint16_t min, uint16_t max);
platforms/nuttx/src/canbootloader/include/timer.h
+419
View File
@@ -0,0 +1,419 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
/*
* We support two classes of timer interfaces. The first one is for structured
* timers that have an API for life cycle management and use. (timer_xx)
* The Second type of methods are for interfacing to a high resolution
* counter with fast access and are provided via an in line API (timer_hrt)
*/
/****************************************************************************
* Included Files
****************************************************************************/
#include <stdbool.h>
#include <stdint.h>
#include "stm32.h"
#include "nvic.h"
#define TIMER_HRT_CYCLES_PER_US (STM32_HCLK_FREQUENCY/1000000)
#define TIMER_HRT_CYCLES_PER_MS (STM32_HCLK_FREQUENCY/1000)
/* Types for timer access */
typedef uint8_t bl_timer_id; /* A timer handle */
typedef uint32_t time_ms_t; /* A timer value */
typedef volatile time_ms_t *time_ref_t; /* A pointer to the internal
counter in the structure of a timer
used to do a time out test value */
typedef uint32_t time_hrt_cycles_t; /* A timer value type of the hrt */
/*
* Timers
*
* There are 3 modes of operation for the timers.
* All modes support a call back on expiration.
*
*/
typedef enum {
/* Specifies a one-shot timer. After notification timer is discarded. */
modeOneShot = 1,
/* Specifies a repeating timer. */
modeRepeating = 2,
/* Specifies a persistent start / stop timer. */
modeTimeout = 3,
/* Or'ed in to start the timer when allocated */
modeStarted = 0x40
} bl_timer_modes_t;
/* The call back function signature type */
typedef void (*bl_timer_ontimeout)(bl_timer_id id, void *context);
/*
* A helper type for timer allocation to setup a callback
* There is a null_cb object (see below) that can be used to
* a bl_timer_cb_t.
*
* Typical usage is:
*
* void my_process(bl_timer_id id, void *context) {
* ...
* };
*
* bl_timer_cb_t mycallback = null_cb;
* mycallback.cb = my_process;
* bl_timer_id mytimer = timer_allocate(modeRepeating|modeStarted, 100, &mycallback);
*/
typedef struct {
void *context;
bl_timer_ontimeout cb;
} bl_timer_cb_t;
extern const bl_timer_cb_t null_cb;
/****************************************************************************
* Name: timer_init
*
* Description:
* Called early in os_start to initialize the data associated with
* the timers
*
* Input Parameters:
* None
*
* Returned Value:
* None
*
****************************************************************************/
void timer_init(void);
/****************************************************************************
* Name: timer_allocate
*
* Description:
* Is used to allocate a timer. Allocation does not involve memory
* allocation as the data for the timer are compile time generated.
* See OPT_BL_NUMBER_TIMERS
*
* There is an inherent priority to the timers in that the first timer
* allocated is the first timer run per tick.
*
* There are 3 modes of operation for the timers. All modes support an
* optional call back on expiration.
*
* modeOneShot - Specifies a one-shot timer. After notification timer
* is resource is freed.
* modeRepeating - Specifies a repeating timer that will reload and
* call an optional.
* modeTimeout - Specifies a persistent start / stop timer.
*
* modeStarted - Or'ed in to start the timer when allocated
*
*
* Input Parameters:
* mode - One of bl_timer_modes_t with the Optional modeStarted
* msfromnow - The reload and initial value for the timer in Ms.
* fc - A pointer or NULL (0). If it is non null it can be any
* of the following:
*
* a) A bl_timer_cb_t populated on the users stack or
* in the data segment. The values are copied into the
* internal data structure of the timer and therefore do
* not have to persist after the call to timer_allocate
*
* b) The address of null_cb. This is identical to passing
* null for the value of fc.
*
* Returned Value:
* On success a value from 0 - OPT_BL_NUMBER_TIMERS-1 that is
* the bl_timer_id for subsequent timer operations
* -1 on failure. This indicates there are no free timers.
*
****************************************************************************/
bl_timer_id timer_allocate(bl_timer_modes_t mode, time_ms_t msfromnow, bl_timer_cb_t *fc);
/****************************************************************************
* Name: timer_free
*
* Description:
* Is used to free a timer. Freeing a timer does not involve memory
* deallocation as the data for the timer are compile time generated.
* See OPT_BL_NUMBER_TIMERS
*
* Input Parameters:
* id - Returned from timer_allocate;
*
* Returned Value:
* None.
*
****************************************************************************/
void timer_free(bl_timer_id id);
/****************************************************************************
* Name: timer_start
*
* Description:
* Is used to Start a timer. The reload value is copied to the counter.
* And the running bit it set. There is no problem in Starting a running
* timer. But it will restart the timeout.
*
* Input Parameters:
* id - Returned from timer_allocate;
*
* Returned Value:
* None.
*
****************************************************************************/
void timer_start(bl_timer_id id);
/****************************************************************************
* Name: timer_restart
*
* Description:
* Is used to re start a timer with a new reload count. The reload value
* is copied to the counter and the running bit it set. There is no
* problem in restarting a running timer.
*
* Input Parameters:
* id - Returned from timer_allocate;
* ms - Is a time_ms_t and the new reload value to use.
*
* Returned Value:
* None.
*
****************************************************************************/
void timer_restart(bl_timer_id id, time_ms_t ms);
/****************************************************************************
* Name: timer_stop
*
* Description:
* Is used to stop a timer. It is Ok to stop a stopped timer.
*
* Input Parameters:
* id - Returned from timer_allocate;
*
* Returned Value:
* None.
*
****************************************************************************/
void timer_stop(bl_timer_id id);
/****************************************************************************
* Name: timer_expired
*
* Description:
* Test if a timer that was configured as a modeTimeout timer is expired.
* To be expired the time has to be running and have a count of 0.
*
* Input Parameters:
* id - Returned from timer_allocate;
*
* Returned Value:
* No Zero if the timer is expired otherwise zero.
*
****************************************************************************/
int timer_expired(bl_timer_id id);
/****************************************************************************
* Name: timer_ref
*
* Description:
* Returns an time_ref_t that is a reference (pointer) to the internal counter
* of the timer selected by id. It should only be used with calls to
* timer_ref_expired.
*
* Input Parameters:
* id - Returned from timer_allocate;
*
* Returned Value:
* An internal reference that should be treated as opaque by the caller and
* should only be used with calls to timer_ref_expired.
* There is no reference counting on the reference and therefore does not
* require any operation to free it.
*
****************************************************************************/
time_ref_t timer_ref(bl_timer_id id);
/****************************************************************************
* Name: timer_ref_expired
*
* Description:
* Test if a timer, that was configured as a modeTimeout timer is expired
* based on the reference provided.
*
* Input Parameters:
* ref - Returned timer_ref;
*
* Returned Value:
* Non Zero if the timer is expired otherwise zero.
*
****************************************************************************/
static inline int timer_ref_expired(time_ref_t ref)
{
return *ref == 0;
}
/****************************************************************************
* Name: timer_tic
*
* Description:
* Returns the system tic counter that counts in units of
* (CONFIG_USEC_PER_TICK/1000). By default 10 Ms.
*
* Input Parameters:
* None
*
* Returned Value:
* None
*
****************************************************************************/
time_ms_t timer_tic(void);
/****************************************************************************
* Name: timer_hrt_read
*
* Description:
* Returns the hardware SysTic counter that counts in units of
* STM32_HCLK_FREQUENCY. This file defines TIMER_HRT_CYCLES_PER_US
* and TIMER_HRT_CYCLES_PER_MS that should be used to define times.
*
* Input Parameters:
* None
*
* Returned Value:
* The current value of the HW counter in the type of time_hrt_cycles_t.
*
****************************************************************************/
static inline time_hrt_cycles_t timer_hrt_read(void)
{
return getreg32(NVIC_SYSTICK_CURRENT);
}
/****************************************************************************
* Name: timer_hrt_clear_wrap
*
* Description:
* Clears the wrap flag by reading the timer
*
*
* Input Parameters:
* None
*
* Returned Value:
* None
*
****************************************************************************/
static inline void timer_hrt_clear_wrap(void)
{
(void)timer_hrt_read();
}
/****************************************************************************
* Name: timer_hrt_wrap
*
* Description:
* Returns true if SysTic counted to 0 since last time it was
* read.
*
* Input Parameters:
* None
*
* Returned Value:
* Returns true if timer counted to 0 since last time this was read.
*
****************************************************************************/
static inline bool timer_hrt_wrap(void)
{
uint32_t rv = getreg32(NVIC_SYSTICK_CTRL);
return ((rv & NVIC_SYSTICK_CTRL_COUNTFLAG) ? true : false);
}
/****************************************************************************
* Name: timer_hrt_max
*
* Description:
* Returns the hardware SysTic reload value +1
*
* Input Parameters:
* None
*
* Returned Value:
* The current SysTic reload of the HW counter in the type of
* time_hrt_cycles_t.
*
****************************************************************************/
static inline time_hrt_cycles_t timer_hrt_max(void)
{
return getreg32(NVIC_SYSTICK_RELOAD) + 1;
}
/****************************************************************************
* Name: timer_hrt_elapsed
*
* Description:
* Returns the difference between 2 time values, taking into account
* the way the timer wrap.
*
* Input Parameters:
* begin - Beginning timer count.
* end - Ending timer count.
*
* Returned Value:
* The difference from begin to end
*
****************************************************************************/
static inline time_hrt_cycles_t timer_hrt_elapsed(time_hrt_cycles_t begin, time_hrt_cycles_t end)
{
/* It is a down count from NVIC_SYSTICK_RELOAD */
time_hrt_cycles_t elapsed = begin - end;
time_hrt_cycles_t reload = timer_hrt_max();
/* Did it wrap */
if (elapsed > reload) {
elapsed += reload;
}
return elapsed;
}
platforms/nuttx/src/canbootloader/include/uavcan.h
+841
View File
@@ -0,0 +1,841 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#pragma once
/*
* Uavcan protocol CAN ID formats and Tail byte component definitions
*
* Most all the constants below are auto generated by the compiler in the
* section above.
* For all UAVCAN_BIT_DEFINE({item name}, lsb_pos, length) entries
* it defines the following enumeration constants:
*
* Mask{item name} - The mask that is positioned at the lsb and
* length long
* BitPos{item name} - The bit position of the lsb
* Length{item name} - The number of bits in the field
*
*
* For the UAVCAN_DSDL_TYPE_DEF(name, dtid, service, signature, packsize,
* mailbox, fifo, inbound, outbound)
* it defines:
*
* uavcan dtid definitions are in the form nnnn.type_name.uavcan
*
* DSDL{type_name} - An internal zero based ID for the transfer
* format E.G DSDLNodeInfo would return the internal
* constant index derived from the line that
* UAVCAN_DSDL_TYPE_DEF(GetNodeInfo... is defined on
* in uavcan_dsdl_defs.h (as of this writing it would
* be the value 1)
*
* DTID{type_name} - The uavcan Number nnn.name E.G DTIDNodeInfo
*
* ServiceNotMessage{type_name} - True for DTID that are uavcan Services Type
* Defined Transfer Type
*
* SignatureCRC16{type_name} - Required for multi-frame Transfer Type
*
* PackedSize{type_name} - The packed size of the Transfer Type
*
* MailBox{type_name} - When sending this Transfer Type, use this
* mailbox
*
* Fifo{type_name} - When receiving this Transfer Type, use this
* fifo. - Filers need to be configured
*
* Fifo{type_name} - The uavcan Number nnn.name E.G DTIDNodeInfo
*
* InTailInit{type_name} - The value of the tail byte to expect at
* the end of a transfer
*
* OutTailInit{type_name} - The value of the tail byte to to use when
* sending this transfer
*
* For all UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length)
* it defines the following enumeration constants:
*
* Mask{item name} - The mask that is positioned at the lsb and
* length long
* BitPos{item name} - The bit position of the lsb
* Length{item name} - The number of bits in the field
* PayloadOffset{<name><field_name>} - The offset in the payload
* PayloadLength{<name><field_name>} - The number of bytes
*
*/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/compiler.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include "bitminip.h"
#include "can.h"
#include "px4_macros.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define sizeof_member(t, m) sizeof(((t *)0)->m)
#define UAVCAN_STRLEN(x) sizeof((x))-1
#define uavcan_exclude(x, name) BITFEILD_EXCLUDE((x), BitPos##name,Length##name)
#define uavcan_make_uint16(d0, d1) (uint16_t)(((d1) << 8u) | (d0))
#define uavcan_dsdl_field(op, data_typ_name, field_name) (op##data_typ_name##field_name)
#define uavcan_bit_pos(data_typ_name, field_name) uavcan_dsdl_field(BitPos, data_typ_name, field_name)
#define uavcan_bit_mask(data_typ_name, field_name) uavcan_dsdl_field(Mask, data_typ_name, field_name)
#define uavcan_bit_count(data_typ_name, field_name) uavcan_dsdl_field(Length, data_typ_name, field_name)
#define uavcan_byte_offset(data_typ_name, field_name) uavcan_dsdl_field(PayloadOffset, data_typ_name, field_name)
#define uavcan_byte_count(data_typ_name, field_name) uavcan_dsdl_field(PayloadLength, data_typ_name, field_name)
#define uavcan_pack(d, data_typ_name, field_name) \
(((d) << uavcan_bit_pos(data_typ_name, field_name)) & uavcan_bit_mask(data_typ_name, field_name))
#define uavcan_ppack(d, data_typ_name, field_name) uavcan_pack(d->field_name, data_typ_name, field_name)
#define uavcan_rpack(d, data_typ_name, field_name) uavcan_pack(d.field_name, data_typ_name, field_name)
#define uavcan_unpack(d, data_typ_name, field_name) \
(((d) & uavcan_bit_mask(data_typ_name, field_name)) >> uavcan_bit_pos(data_typ_name, field_name))
#define uavcan_punpack(d, data_typ_name, field_name) uavcan_unpack(d->field_name, data_typ_name, field_name)
#define uavcan_runpack(d, data_typ_name, field_name) uavcan_unpack(d.field_name, data_typ_name, field_name)
#define uavcan_protocol_mask(field_name) (Mask##field_name)
/****************************************************************************
* Auto Generated Public Type Definitions
****************************************************************************/
/* CAN ID fields */
#define UAVCAN_BIT_DEFINE(field_name, lsb_pos, length) Mask##field_name = BITFEILD_MASK((lsb_pos), (length)),
typedef enum uavcan_can_id_mask_t {
#include "uavcan_can_id_defs.h"
} uavcan_can_id_mask_t;
#undef UAVCAN_BIT_DEFINE
#define UAVCAN_BIT_DEFINE(field_name, lsb_pos, length) BitPos##field_name = (lsb_pos),
typedef enum uavcan_can_id_pos_t {
#include "uavcan_can_id_defs.h"
} uavcan_can_id_pos_t;
#undef UAVCAN_BIT_DEFINE
#define UAVCAN_BIT_DEFINE(field_name, lsb_pos, length) Length##field_name = (length),
typedef enum uavcan_can_id_length_t {
#include "uavcan_can_id_defs.h"
} uavcan_can_id_length_t;
#undef UAVCAN_BIT_DEFINE
/****************************************************************************
* Public Type Definitions
****************************************************************************/
typedef enum uavcan_direction_t {
InBound = true,
OutBound = false,
MessageIn = InBound,
MessageOut = OutBound,
} uavcan_direction_t;
/*
* Uavcan protocol CAN ID formats and Tail byte component definitions
*
* Most all the constants below are auto generated by the compiler in the
* section above.
* It defines Mask{item name}, BitPos{item name} and Length{item name}
* for all UAVCAN_BIT_DEFINE({item name}, lsb_pos, length) entries
*
* [CAN ID[4]][data[0-7][tail[1]]]
*
*/
/* General UAVCAN Constants */
typedef enum uavcan_general_t {
UavcanPriorityMax = 0,
UavcanPriorityMin = 31,
} uavcan_general_t;
/* CAN ID definitions for native data manipulation */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#pragma GCC diagnostic ignored "-Wpacked"
typedef begin_packed_struct struct can_id_t {
union {
uint32_t u32;
uint8_t b[sizeof(uint32_t)];
};
} end_packed_struct can_id_t;
/* UAVCAN CAN ID Usage: Message definition */
typedef struct uavcan_message_t {
uint32_t source_node_id : LengthUavCanMessageSourceNodeID;
uint32_t service_not_message : LengthUavCanMessageServiceNotMessage;
uint32_t type_id : LengthUavCanMessageTypeID;
uint32_t priority : LengthUavCanMessagePriority;
} uavcan_message_t;
/* UAVCAN CAN ID Usage: Anonymous Message Constants */
typedef enum uavcan_anon_const_t {
UavcanAnonymousNodeID = 0,
} uavcan_anon_const_t;
/* UAVCAN CAN ID Usage: Anonymous Message definition */
typedef struct uavcan_anonymous_message_t {
uint32_t source_node_id : LengthUavCanAnonMessageSourceNodeID;
uint32_t service_not_message : LengthUavCanAnonMessageServiceNotMessage;
uint32_t type_id : LengthUavCanAnonMessageTypeID;
uint32_t discriminator : LengthUavCanAnonMessageDiscriminator;
uint32_t priority : LengthUavCanAnonMessagePriority;
} uavcan_anonymous_message_t;
/* UAVCAN CAN ID Usage: Service Constants */
typedef enum uavcan_service_const_t {
UavcanServiceRetries = 3,
UavcanServiceTimeOutMs = 1000,
} uavcan_service_const_t;
/* UAVCAN CAN ID Usage: Service definition */
typedef struct uavcan_service_t {
uint32_t source_node_id : LengthUavCanServiceSourceNodeID;
uint32_t service_not_message : LengthUavCanServiceServiceNotMessage;
uint32_t dest_node_id : LengthUavCanServiceDestinationNodeID;
uint32_t request_not_response : LengthUavCanServiceRequestNotResponse;
uint32_t type_id : LengthUavCanServiceTypeID;
uint32_t priority : LengthUavCanServicePriority;
} uavcan_service_t;
/* UAVCAN Tail Byte definitions for native data manipulation */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpacked"
typedef begin_packed_struct struct can_tail_t {
union {
uint8_t u8;
};
} end_packed_struct can_tail_t;
#pragma GCC diagnostic pop
/* UAVCAN Tail Byte definitions */
typedef struct uavcan_tail_t {
uint8_t transfer_id : LengthUavCanTransferID;
uint8_t toggle : LengthUavCanToggle;
uint8_t eot : LengthUavCanEndOfTransfer;
uint8_t sot : LengthUavCanStartOfTransfer;
} uavcan_tail_t;
/* UAVCAN Tail Byte Initialization constants */
typedef enum uavcan_tail_init_t {
SingleFrameTailInit = (MaskUavCanStartOfTransfer | MaskUavCanEndOfTransfer),
MultiFrameTailInit = (MaskUavCanStartOfTransfer),
BadTailState = (MaskUavCanStartOfTransfer | MaskUavCanToggle),
MaxUserPayloadLength = CanPayloadLength - sizeof(uavcan_tail_t),
} uavcan_tail_init_t;
/*
* Assert that assumptions in code are true
* The code assumes it can manipulate a ALL sub protocol objects
* using MaskUavCanMessageServiceNotMessage, MaskUavCanMessagePriority
* and MaskUavCanMessageSourceNodeID
*/
CCASSERT(MaskUavCanServicePriority == MaskUavCanAnonMessagePriority);
CCASSERT(MaskUavCanServicePriority == MaskUavCanMessagePriority);
CCASSERT(MaskUavCanServiceSourceNodeID == MaskUavCanAnonMessageSourceNodeID);
CCASSERT(MaskUavCanServiceSourceNodeID == MaskUavCanMessageSourceNodeID);
CCASSERT(MaskUavCanMessageServiceNotMessage == MaskUavCanAnonMessageServiceNotMessage);
CCASSERT(MaskUavCanMessageServiceNotMessage == MaskUavCanMessageServiceNotMessage);
/****************************************************************************
* Auto Generated Public Type Definitions
****************************************************************************/
/* UAVCAN DSDL Type Definitions*/
#define NA 0
#define UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length)
#define UAVCAN_DSDL_MESG_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
UAVCAN_DSDL_TYPE_DEF(Msg##name, (dtid), (signature), (packsize), (mailbox), (fifo), (inbound), (outbound))
#define UAVCAN_DSDL_SREQ_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
UAVCAN_DSDL_TYPE_DEF(Req##name, (dtid), (signature), (packsize), (mailbox), (fifo), (inbound), (outbound))
#define UAVCAN_DSDL_SRSP_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
UAVCAN_DSDL_TYPE_DEF(Rsp##name, (dtid), (signature), (packsize), (mailbox), (fifo), (inbound), (outbound))
#define END_COMPONENTS SizeDSDLComponents,
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
DSDL##name,
typedef enum uavcan_dsdl_t {
#include "uavcan_dsdl_defs.h"
SizeDSDL,
} uavcan_dsdl_t;
#undef UAVCAN_DSDL_TYPE_DEF
#undef END_COMPONENTS
#define END_COMPONENTS
#define UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length)
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
DTID##name = (dtid),
typedef enum uavcan_dsdl_dtid_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_dtid_t;
#undef UAVCAN_DSDL_TYPE_DEF
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
SignatureCRC16##name = (signature),
typedef enum uavcan_dsdl_sig_crc16_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_sig_crc16_t;
#undef UAVCAN_DSDL_TYPE_DEF
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
PackedSize##name = (packsize),
typedef enum uavcan_dsdl_packedsize_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_packedsize_t;
#undef UAVCAN_DSDL_TYPE_DEF
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
MailBox##name = (mailbox),
typedef enum uavcan_dsdl_mb_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_mb_t;
#undef UAVCAN_DSDL_TYPE_DEF
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
Fifo##name = (fifo),
typedef enum uavcan_dsdl_fifo_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_fifo_t;
#undef UAVCAN_DSDL_TYPE_DEF
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
InTailInit##name = (inbound),
typedef enum uavcan_dsdl_inbound_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_inbound_t;
#undef UAVCAN_DSDL_TYPE_DEF
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound) \
OutTailInit##name = (outbound),
typedef enum uavcan_dsdl_outbound_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_outbound_t;
#undef UAVCAN_DSDL_TYPE_DEF
#undef UAVCAN_DSDL_SRSP_DEF
#undef UAVCAN_DSDL_SREQ_DEF
#undef UAVCAN_DSDL_MESG_DEF
#undef UAVCAN_DSDL_BIT_DEF
/* UAVCAN DSDL Fields of Type Definitions definitions*/
#define UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound)
#define UAVCAN_DSDL_MESG_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound)
#define UAVCAN_DSDL_SREQ_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound)
#define UAVCAN_DSDL_SRSP_DEF(name, dtid, signature, packsize, mailbox, fifo, inbound, outbound)
#define UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) \
Mask##data_typ_name##field_name = BITFEILD_MASK((lsb_pos), (length)),
typedef enum uavcan_dsdl_mask_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_mask_t;
#undef UAVCAN_DSDL_BIT_DEF
#define UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) \
BitPos##data_typ_name##field_name = (lsb_pos),
typedef enum uavcan_dsdl_pos_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_pos_t;
#undef UAVCAN_DSDL_BIT_DEF
#define UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) \
Length##data_typ_name##field_name = (length),
typedef enum uavcan_dsdl_length_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_length_t;
#undef UAVCAN_DSDL_BIT_DEF
#define UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) \
PayloadOffset##data_typ_name##field_name = (payload_offset),
typedef enum uavcan_dsdl_payload_offset_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_payload_offset_t;
#undef UAVCAN_DSDL_BIT_DEF
#define UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) \
PayloadLength##data_typ_name##field_name = (payload_length),
typedef enum uavcan_dsdl_payload_length_t {
#include "uavcan_dsdl_defs.h"
} uavcan_dsdl_payload_length_t;
#undef UAVCAN_DSDL_TYPE_DEF
#undef UAVCAN_DSDL_SRSP_DEF
#undef UAVCAN_DSDL_SREQ_DEF
#undef UAVCAN_DSDL_MESG_DEF
#undef UAVCAN_DSDL_BIT_DEF
#undef END_COMPONENTS
#undef NA
/****************************************************************************
* Public Type Definitions
****************************************************************************/
/* Uavcan function return values */
typedef enum uavcan_error_t {
UavcanOk = 0,
UavcanBootTimeout = 1,
UavcanError = 3
} uavcan_error_t;
/*
* Uavcan protocol CAN ID formats and Tail byte
*
* [CAN ID[4]][data[0-7][tail[1]]]
*
*/
typedef begin_packed_struct struct uavcan_protocol_t {
union {
can_id_t id;
uavcan_message_t msg;
uavcan_anonymous_message_t ana;
uavcan_service_t ser;
};
union {
can_tail_t tail_init;
uavcan_tail_t tail;
};
} end_packed_struct uavcan_protocol_t;
/*
* Uavcan protocol DSDL Type Definitions
*/
/****************************************
* Uavcan NodeStatus
****************************************/
typedef enum uavcan_NodeStatusConsts_t {
MAX_BROADCASTING_PERIOD_MS = 1000,
MIN_BROADCASTING_PERIOD_MS = 2,
OFFLINE_TIMEOUT_MS = 2000,
HEALTH_OK = 0,
HEALTH_WARNING = 1,
HEALTH_ERROR = 2,
HEALTH_CRITICAL = 3,
MODE_OPERATIONAL = 0,
MODE_INITIALIZATION = 1,
MODE_MAINTENANCE = 2,
MODE_SOFTWARE_UPDATE = 3,
MODE_OFFLINE = 7,
} uavcan_NodeStatusConsts_t;
typedef begin_packed_struct struct uavcan_NodeStatus_t {
uint32_t uptime_sec;
union {
uint8_t u8;
struct {
uint8_t sub_mode: LengthNodeStatussub_mode;
uint8_t mode : LengthNodeStatusmode;
uint8_t health : LengthNodeStatushealth;
};
};
uint16_t vendor_specific_status_code;
} end_packed_struct uavcan_NodeStatus_t;
/****************************************
* Uavcan GetNodeInfo composition
****************************************/
/* SoftwareVersion */
typedef enum uavcan_SoftwareVersionConsts_t {
OPTIONAL_FIELD_FLAG_VCS_COMMIT = 1,
OPTIONAL_FIELD_FLAG_IMAGE_CRC = 2,
} uavcan_SoftwareVersionConsts_t;
typedef begin_packed_struct struct uavcan_SoftwareVersion_t {
uint8_t major;
uint8_t minor;
uint8_t optional_field_flags;
uint32_t vcs_commit;
uint64_t image_crc;
} end_packed_struct uavcan_SoftwareVersion_t;
CCASSERT(PackedSizeSoftwareVersion == sizeof(uavcan_SoftwareVersion_t));
/* HardwareVersion */
typedef begin_packed_struct struct uavcan_HardwareVersion_t {
uint8_t major;
uint8_t minor;
uint8_t unique_id[PayloadLengthHardwareVersionunique_id];
uint8_t certificate_of_authenticity_length;
uint8_t certificate_of_authenticity[PayloadLengthHardwareVersioncertificate_of_authenticity];
} end_packed_struct uavcan_HardwareVersion_t;
typedef enum uavcan_HardwareVersionConsts_t {
FixedSizeHardwareVersion = sizeof_member(uavcan_HardwareVersion_t, major) + \
sizeof_member(uavcan_HardwareVersion_t, minor) + \
sizeof_member(uavcan_HardwareVersion_t, unique_id) + \
sizeof_member(uavcan_HardwareVersion_t, certificate_of_authenticity_length),
} uavcan_HardwareVersionConsts_t;
typedef begin_packed_struct struct uavcan_GetNodeInfo_request_t {
uint8_t empty[CanPayloadLength];
} end_packed_struct uavcan_GetNodeInfo_request_t;
/* GetNodeInfo Response */
typedef begin_packed_struct struct uavcan_GetNodeInfo_response_t {
uavcan_NodeStatus_t nodes_status;;
uavcan_SoftwareVersion_t software_version;
uavcan_HardwareVersion_t hardware_version;
uint8_t name[PayloadLengthGetNodeInfoname];
uint8_t name_length;
} end_packed_struct uavcan_GetNodeInfo_response_t;
typedef enum uavcan_GetNodeInfoConsts_t {
FixedSizeGetNodeInfo = PackedSizeMsgNodeStatus + PackedSizeSoftwareVersion + FixedSizeHardwareVersion,
} uavcan_GetNodeInfoConsts_t;
/****************************************
* Uavcan LogMessage
****************************************/
typedef enum uavcan_LogMessageConsts_t {
LOGMESSAGE_LEVELDEBUG = 0,
LOGMESSAGE_LEVELINFO = 1,
LOGMESSAGE_LEVELWARNING = 2,
LOGMESSAGE_LEVELERROR = 3,
} uavcan_LogMessageConsts_t;
typedef begin_packed_struct struct uavcan_LogMessage_t {
uint8_t level;
uint8_t source[uavcan_byte_count(LogMessage, source)];
uint8_t text[uavcan_byte_count(LogMessage, text)];
} end_packed_struct uavcan_LogMessage_t;
CCASSERT(sizeof(uavcan_LogMessage_t) == PackedSizeMsgLogMessage);
/****************************************
* Uavcan Allocation
****************************************/
typedef enum uavcan_AllocationConsts_t {
MAX_REQUEST_PERIOD_MS = 1400,
MIN_REQUEST_PERIOD_MS = 600,
MAX_FOLLOWUP_DELAY_MS = 400,
MIN_FOLLOWUP_DELAY_MS = 0,
FOLLOWUP_TIMEOUT_MS = 500,
MAX_LENGTH_OF_UNIQUE_ID_IN_REQUEST = 6,
ANY_NODE_ID = 0,
PriorityAllocation = UavcanPriorityMin - 1,
} uavcan_AllocationConsts_t;
typedef begin_packed_struct struct uavcan_Allocation_t {
uint8_t node_id; /* bottom bit is the first part flag */
uint8_t unique_id[PayloadLengthAllocationunique_id];
} end_packed_struct uavcan_Allocation_t;
/****************************************
* Uavcan Path
****************************************/
typedef begin_packed_struct struct uavcan_Path_t {
uint8_t u8[PayloadLengthPathpath];
} uavcan_Path_t;
typedef enum uavcan_PathConst_t {
SEPARATOR = '/',
} end_packed_struct uavcan_PathConst_t;
/****************************************
* Uavcan GetInfo Composition
****************************************/
typedef enum uavcan_ErrorConst_t {
FILE_ERROR_OK = 0,
FILE_ERROR_UNKNOWN_ERROR = 32767,
FILE_ERROR_NOT_FOUND = 2,
FILE_ERROR_IO_ERROR = 5,
FILE_ERROR_ACCESS_DENIED = 13,
FILE_ERROR_IS_DIRECTORY = 21,
FILE_ERROR_INVALID_VALUE = 22,
FILE_ERROR_FILE_TOO_LARGE = 27,
FILE_ERROR_OUT_OF_SPACE = 28,
FILE_ERROR_NOT_IMPLEMENTED = 38,
} uavcan_ErrorConst_t;
typedef begin_packed_struct struct uavcan_Error_t {
uint16_t value;
} end_packed_struct uavcan_Error_t;
typedef enum uavcan_EntryTypeConst_t {
ENTRY_TYPE_FLAG_FILE = 1,
ENTRY_TYPE_FLAG_DIRECTORY = 2,
ENTRY_TYPE_FLAG_SYMLINK = 4,
ENTRY_TYPE_FLAG_READABLE = 8,
ENTRY_TYPE_FLAG_WRITEABLE = 16,
} uavcan_EntryTypeConst_t;
typedef begin_packed_struct struct uavcan_EntryType_t {
uint8_t flags;
} end_packed_struct uavcan_EntryType_t;
/****************************************
* Uavcan BeginFirmwareUpdate
****************************************/
typedef enum uavcan_BeginFirmwareUpdateConst_t {
ERROR_OK = 0,
ERROR_INVALID_MODE = 1,
ERROR_IN_PROGRESS = 2,
ERROR_UNKNOWN = 255,
} uavcan_BeginFirmwareUpdateConst_t;
typedef begin_packed_struct struct uavcan_BeginFirmwareUpdate_request {
uint8_t source_node_id;
uavcan_Path_t image_file_remote_path;
} end_packed_struct uavcan_BeginFirmwareUpdate_request;
typedef begin_packed_struct struct uavcan_BeginFirmwareUpdate_response {
uint8_t error;
} end_packed_struct uavcan_BeginFirmwareUpdate_response;
/****************************************
* Uavcan GetInfo
****************************************/
typedef begin_packed_struct struct uavcan_GetInfo_request_t {
uavcan_Path_t path;
} uavcan_GetInfo_request_t;
typedef enum uavcan_GetInfo_requestConst_t {
FixedSizeGetInfoRequest = 0,
} end_packed_struct uavcan_GetInfo_requestConst_t;
typedef begin_packed_struct struct uavcan_GetInfo_response_t {
uint32_t size;
uint8_t msbsize;
uavcan_Error_t error;
uavcan_EntryType_t entry_type;
} end_packed_struct uavcan_GetInfo_response_t;
/****************************************
* Uavcan Read Composition
****************************************/
typedef begin_packed_struct struct uavcan_Read_request_t {
uint32_t offset;
uint8_t msboffset;
uavcan_Path_t path;
} end_packed_struct uavcan_Read_request_t;
typedef enum uavcan_ReadRequestConsts_t {
FixedSizeReadRequest = sizeof_member(uavcan_Read_request_t, offset) + \
sizeof_member(uavcan_Read_request_t, msboffset),
} uavcan_ReadRequestConsts_t;
typedef begin_packed_struct struct uavcan_Read_response_t {
uavcan_Error_t error;
uint8_t data[PayloadLengthReaddata];
} end_packed_struct uavcan_Read_response_t;
/****************************************************************************
* Global Variables
****************************************************************************/
extern uint8_t g_this_node_id;
extern uint8_t g_server_node_id;
extern uint8_t g_uavcan_priority;
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
/****************************************************************************
* Name: uavcan_pack_GetNodeInfo_response
*
* Description:
* This function packs the data of a uavcan_NodeStatus_t into
* a uavcan_GetNodeInfo_response_t structure as array of bytes.
* Then it packs the uavcan_GetNodeInfo_response_t
*
* Input Parameters:
* response The uavcan_GetNodeInfo_response_t to be packed
* node_status - The uavcan_NodeStatus_t that is part of the composition
*
* Returned value:
* Number of bytes written.
*
****************************************************************************/
size_t uavcan_pack_GetNodeInfo_response(uavcan_GetNodeInfo_response_t
*response);
/****************************************************************************
* Name: uavcan_tx_dsdl
*
* Description:
* This helper function sends a uavcan service protocol, it
* assumes the protocol object has the destination node id set.
*
* Input Parameters:
* dsdl - An Uavcan DSDL Identifier (Auto Generated)
* protocol - A pointer to a uavcan_protocol_t to configure the send,
* the transfer with the dest_node_id set to that of the
* node we are making the request of.
* transfer - A pointer to the packed data of the transfer to be sent.
* length - The number of bytes of data
*
* Returned value:
* The UavcanOk of the data sent. Anything else indicates if a timeout
* occurred.
*
****************************************************************************/
uavcan_error_t uavcan_tx_dsdl(uavcan_dsdl_t dsdl, uavcan_protocol_t *protocol,
const uint8_t *transfer, size_t transfer_length);
/****************************************************************************
* Name: uavcan_rx_dsdl
*
* Description:
* This function receives a uavcan Service response protocol transfer
*
* Input Parameters:
* dsdl - An Uavcan DSDL Identifier (Auto Generated)
* protocol - A pointer to a uavcan_protocol_t to configure the receive,
* based the dsdl for the DTID Service.
* If the request must come from a specific server
* then protocol->ser.source_node_id, should be set
* to that node id;
*
* in_out_transfer_length - The number of bytes of data to receive and the
* number received.
* timeout_ms - The amount of time in mS to wait for the initial transfer
*
* Returned value:
* None
*
****************************************************************************/
uavcan_error_t uavcan_rx_dsdl(uavcan_dsdl_t dsdl, uavcan_protocol_t *protocol,
uint8_t *transfer, size_t *in_out_transfer_length,
uint32_t timeout_ms);
/****************************************************************************
* Name: uavcan_tx_log_message
*
* Description:
* This functions sends uavcan LogMessage type data. The Source will be
* taken from the application defined debug_log_source
*
* Input Parameters:
* level - Log Level of the LogMessage Constants DEBUG, INFO, WARN, ERROR
* stage - The Stage the application is at. see Aplication defined
* LOGMESSAGE_STAGE_x
* status - The status of that stage. See Application defined
* LOGMESSAGE_RESULT_x
*
* Returned Value:
* None
*
****************************************************************************/
/* The application must define this */
extern const uint8_t debug_log_source[uavcan_byte_count(LogMessage, source)];
void uavcan_tx_log_message(uavcan_LogMessageConsts_t level, uint8_t stage,
uint8_t status);
/****************************************************************************
* Name: uavcan_tx_allocation_message
*
* Description:
* This function sends a uavcan allocation message.
*
* Input Parameters:
* requested_node_id - This node's preferred node id 0 for no preference.
* unique_id_length - This node's length of it's unique identifier.
* unique_id - A pointer to the bytes that represent unique
* identifier.
* unique_id_offset - The offset equal 0 or the number of bytes in the
* the last received message that matched the unique ID
* field.
* random - The value to use as the discriminator of the
* anonymous message
*
* Returned value:
* None
*
****************************************************************************/
void uavcan_tx_allocation_message(uint8_t requested_node_id,
size_t unique_id_length,
const uint8_t *unique_id,
uint8_t unique_id_offset,
uint16_t random);
platforms/nuttx/src/canbootloader/include/uavcan_can_id_defs.h
+66
View File
@@ -0,0 +1,66 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/* This file not a typical h file, is defines the UAVCAN dsdl
* usage and may be included several times in header or source
* file
*/
/* UAVCAN_BIT_DEFINE( field_name, lsb_pos, length) */
/* Message Frame Format */
UAVCAN_BIT_DEFINE(UavCanMessagePriority, 24, 5)
UAVCAN_BIT_DEFINE(UavCanMessageTypeID, 8, 16)
UAVCAN_BIT_DEFINE(UavCanMessageServiceNotMessage, 7, 1)
UAVCAN_BIT_DEFINE(UavCanMessageSourceNodeID, 0, 7)
/* Anonymous message Frame Format */
UAVCAN_BIT_DEFINE(UavCanAnonMessagePriority, 24, 5)
UAVCAN_BIT_DEFINE(UavCanAnonMessageDiscriminator, 10, 14)
UAVCAN_BIT_DEFINE(UavCanAnonMessageTypeID, 8, 2)
UAVCAN_BIT_DEFINE(UavCanAnonMessageServiceNotMessage, 7, 1)
UAVCAN_BIT_DEFINE(UavCanAnonMessageSourceNodeID, 0, 7)
/* Service Frame Format */
UAVCAN_BIT_DEFINE(UavCanServicePriority, 24, 5)
UAVCAN_BIT_DEFINE(UavCanServiceTypeID, 16, 8)
UAVCAN_BIT_DEFINE(UavCanServiceRequestNotResponse, 15, 1)
UAVCAN_BIT_DEFINE(UavCanServiceDestinationNodeID, 8, 7)
UAVCAN_BIT_DEFINE(UavCanServiceServiceNotMessage, 7, 1)
UAVCAN_BIT_DEFINE(UavCanServiceSourceNodeID, 0, 7)
/* Tail Format */
UAVCAN_BIT_DEFINE(UavCanStartOfTransfer, 7, 1)
UAVCAN_BIT_DEFINE(UavCanEndOfTransfer, 6, 1)
UAVCAN_BIT_DEFINE(UavCanToggle, 5, 1)
UAVCAN_BIT_DEFINE(UavCanTransferID, 0, 5)
platforms/nuttx/src/canbootloader/include/uavcan_dsdl_defs.h
+187
View File
@@ -0,0 +1,187 @@
/****************************************************************************
*
* Copyright (c) 2015 PX4 Development Team. All rights reserved.
* Author: Ben Dyer <ben_dyer@mac.com>
* Pavel Kirienko <pavel.kirienko@zubax.com>
* David Sidrane <david_s5@nscdg.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/* This file not a typical h file, is defines the UAVCAN dsdl
* usage and may be included several times in header or source
* file
*/
/* Components */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(CRC, lsb, 0, 8, 0, 1)
UAVCAN_DSDL_BIT_DEF(CRC, msb, 0, 8, 1, 1)
UAVCAN_DSDL_BIT_DEF(CRC, data, 0, 8, 2, 4)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_TYPE_DEF(Path, 0, 0, 200, NA, NA,
NA, NA)
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(Path, path, 0, 8, 0,
200)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_TYPE_DEF(SoftwareVersion, 0, 0, 15, NA, NA,
NA, NA)
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(SoftwareVersion, major, 0, 8, 0,
1)
UAVCAN_DSDL_BIT_DEF(SoftwareVersion, minor, 0, 8, 1,
1)
UAVCAN_DSDL_BIT_DEF(SoftwareVersion, optional_field_flags, 0, 8, 2,
1)
UAVCAN_DSDL_BIT_DEF(SoftwareVersion, vcs_commit, 0, 32, 3,
4)
UAVCAN_DSDL_BIT_DEF(SoftwareVersion, image_crc, 0, NA, 7,
8) // NA becuase bit mask is 64
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_TYPE_DEF(HardwareVersion, 0, 0, NA, NA, NA,
NA, NA)
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(HardwareVersion, unique_id, 0, 8, 0,
16)
UAVCAN_DSDL_BIT_DEF(HardwareVersion, certificate_of_authenticity, 0, 8, 0,
255)
END_COMPONENTS
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_MESG_DEF(Allocation, 1, 0xf258, 0, MailBox0, Fifo0,
MultiFrameTailInit, SingleFrameTailInit) /* Message */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(Allocation, node_id, 1, 7, 0,
1)
UAVCAN_DSDL_BIT_DEF(Allocation, first_part_of_unique_id, 0, 1, 0,
1)
UAVCAN_DSDL_BIT_DEF(Allocation, unique_id, 0, 8, 1,
16)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_MESG_DEF(NodeStatus, 341, 0xbe5f, 7, MailBox1, FifoNone,
SingleFrameTailInit, SingleFrameTailInit) /* Message */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(NodeStatus, uptime_sec, 0, 32, 0,
4)
UAVCAN_DSDL_BIT_DEF(NodeStatus, health, 6, 2, 5,
1)
UAVCAN_DSDL_BIT_DEF(NodeStatus, mode, 3, 3, 5,
1)
UAVCAN_DSDL_BIT_DEF(NodeStatus, sub_mode, 0, 3, 5,
1)
UAVCAN_DSDL_BIT_DEF(NodeStatus, vendor_specific_status_code, 0, 16, 6,
2)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_SREQ_DEF(GetNodeInfo, 1, 0xd9a7, 0, MailBox1, Fifo1,
SingleFrameTailInit, MultiFrameTailInit) /* Request */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) Empty */
UAVCAN_DSDL_SRSP_DEF(GetNodeInfo, 1, 0xd9a7, 0, MailBox1, Fifo1,
SingleFrameTailInit, MultiFrameTailInit) /* Response */
UAVCAN_DSDL_BIT_DEF(GetNodeInfo, status, 0, 8, 0,
PackedSizeMsgNodeStatus)
UAVCAN_DSDL_BIT_DEF(GetNodeInfo, software_version, 0, 8, NA,
NA)
UAVCAN_DSDL_BIT_DEF(GetNodeInfo, hardware_version, 0, 8, NA,
NA)
UAVCAN_DSDL_BIT_DEF(GetNodeInfo, name, 0, 8, NA,
80)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_SREQ_DEF(BeginFirmwareUpdate, 40, 0x729e, 0, MailBox0, Fifo0,
MultiFrameTailInit, SingleFrameTailInit) /* Request */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(BeginFirmwareUpdate, source_node_id, 0, 8, 0,
1)
UAVCAN_DSDL_BIT_DEF(BeginFirmwareUpdate, image_file_remote_path, 0, 8, 1,
PayloadLengthPathpath)
UAVCAN_DSDL_SRSP_DEF(BeginFirmwareUpdate, 40, 0x729e, 0, MailBox0, Fifo0,
MultiFrameTailInit, SingleFrameTailInit) /* Response */
UAVCAN_DSDL_BIT_DEF(BeginFirmwareUpdate, error, 0, 8, 0,
1)
UAVCAN_DSDL_BIT_DEF(BeginFirmwareUpdate, optional_error_message, 0, 8, 1,
128)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_SREQ_DEF(GetInfo, 45, 0x14b9, 0, MailBox0, Fifo0,
SingleFrameTailInit, MultiFrameTailInit) /* Request */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(GetInfo, path, 0, 8, 0,
PayloadLengthPathpath)
UAVCAN_DSDL_SRSP_DEF(GetInfo, 45, 0x14b9, 0, MailBox0, Fifo0,
SingleFrameTailInit, MultiFrameTailInit) /* Response */
UAVCAN_DSDL_BIT_DEF(GetInfo, size, 0, 32, 0,
4) /* Response */
UAVCAN_DSDL_BIT_DEF(GetInfo, sizemsb, 0, 8, 4,
1)
UAVCAN_DSDL_BIT_DEF(GetInfo, error, 0, 16, 5,
2)
UAVCAN_DSDL_BIT_DEF(GetInfo, entry_type, 0, 8, 7,
1)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_SREQ_DEF(Read, 48, 0x2f12, 0, MailBox0, Fifo0,
SingleFrameTailInit, MultiFrameTailInit) /* Request */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(Read, offset, 0, 32, 0,
4) /* Request */
UAVCAN_DSDL_BIT_DEF(Read, msboffset, 0, 8, 4,
1)
UAVCAN_DSDL_BIT_DEF(Read, path, 0, 8, 5,
PayloadLengthPathpath)
UAVCAN_DSDL_SRSP_DEF(Read, 48, 0x2f12, 0, MailBox0, Fifo0,
SingleFrameTailInit, MultiFrameTailInit) // Responce
UAVCAN_DSDL_BIT_DEF(Read, error, 0, 16, 0,
2) /* Response */
UAVCAN_DSDL_BIT_DEF(Read, data, 0, 8, 2,
256)
/*UAVCAN_DSDL_TYPE_DEF(name, dtid, signature, packed size mailbox, fifo, inbound, outbound) */
UAVCAN_DSDL_MESG_DEF(LogMessage, 16383, 0x4570, 7, MailBox0, Fifo0,
NA, SingleFrameTailInit) /* Message */
/* UAVCAN_DSDL_BIT_DEF(data_typ_name, field_name, lsb_pos, length, payload_offset, payload_length) */
UAVCAN_DSDL_BIT_DEF(LogMessage, level, 5, 3, 0,
1)
UAVCAN_DSDL_BIT_DEF(LogMessage, source_length, 0, 5, 0,
1)
UAVCAN_DSDL_BIT_DEF(LogMessage, source, 0, 8, 1,
4) // Bootloader specific uses is 4
UAVCAN_DSDL_BIT_DEF(LogMessage, text, 0, 8, 5,
2) // Bootloader specific uses is 2
platforms/nuttx/src/canbootloader/include/visibility.h
+72
View File
@@ -0,0 +1,72 @@
/****************************************************************************
*
* Copyright (C) 2012 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file visibility.h
*
* Definitions controlling symbol naming and visibility.
*
* This file is normally included automatically by the build system.
*/
#pragma once
#ifdef __EXPORT
# undef __EXPORT
#endif
#define __EXPORT __attribute__ ((visibility ("default")))
#ifdef __PRIVATE
# undef __PRIVATE
#endif
#define __PRIVATE __attribute__ ((visibility ("hidden")))
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS
# define __END_DECLS
#endif
#ifdef __PX4_NUTTX
/* On NuttX we call clearenv() so we cannot use getenv() and others (see px4_task_spawn_cmd() in px4_nuttx_tasks.c).
* We need to include the headers declaring getenv() before the pragma, otherwise it will trigger a poison error.
*/
#include <stdlib.h>
#ifdef __cplusplus
#include <cstdlib>
#endif
#pragma GCC poison getenv setenv putenv
#endif /* __PX4_NUTTX */