rfidrig/ChameleonMini
0
0
Fork 0
mirror of https://github.com/RfidResearchGroup/ChameleonMini.git synced 2026-05-12 11:20:37 -07:00
Code Issues Packages Projects Releases Wiki Activity

make style

Browse Source
This commit is contained in:
Willok
2019-12-06 10:18:25 +01:00
parent 1339e6350d
commit 6606f8d0ff
5 changed files with 341 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Firmware/Chameleon-Mini/Terminal/Commands.c
+1 -1
View File
@@ -670,7 +670,7 @@ CommandStatusIdType CommandSetLedMode(char *OutMessage, const char *InParam) {
break;
case 'R': // State reset
bKeepAlive = 1;
bUSBTerminal = 0;
bUSBTerminal = 0;
break;
case 'T': // Test
SendTestCmd(InParam[1]);
Firmware/Chameleon-Mini/Uart.c
+140 -163
View File
@@ -2,7 +2,7 @@
* Uart.c
*
* Created on: 20.03.2013
* Author: Willok
* Author: Willok
*
* ChangeLog
* 2019-09-22 Willok Add some UART PROCESS
@@ -13,21 +13,21 @@
#include "Uart.h"
#include "uartcmd.h"
// This defines the buffer used by the UART
// This defines the buffer used by the UART
#define RBUF_SIZE 512
typedef struct _buf_rx {
uint16_t in;
uint16_t out;
uint8_t buf[RBUF_SIZE];
}buf_rx;
uint16_t in;
uint16_t out;
uint8_t buf[RBUF_SIZE];
} buf_rx;
#define TBUF_SIZE 512
typedef struct _buf_tx {
uint16_t in;
uint16_t out;
uint8_t buf[TBUF_SIZE];
}buf_tx;
uint16_t in;
uint16_t out;
uint8_t buf[TBUF_SIZE];
} buf_tx;
buf_rx rbuf = { 0, 0, };
@@ -36,189 +36,166 @@ buf_tx tbuf = { 0, 0, };
//#pragma GCC push_options
//#pragma GCC optimize ("O0")
ISR(USARTE0_RXC_vect)
{
if (0 == (USART.STATUS & (USART_BUFOVF_bm | USART_FERR_bm | USART_PERR_bm)))
{
if (((rbuf.in - rbuf.out) & ~(RBUF_SIZE - 1)) == 0)
{
rbuf.buf[rbuf.in & (RBUF_SIZE - 1)] = USART_GetChar(&USART);
rbuf.in++;
}
else
{
// It means that the buffer is full. Find a way to deal with it
uart_putc('E');
uart_putc('0');
uart_putc(USART_GetChar(&USART));
}
}
else
{
uart_putc('E');
uart_putc('1');
uart_putc(USART.STATUS);
uart_putc(USART_GetChar(&USART));
}
ISR(USARTE0_RXC_vect) {
if (0 == (USART.STATUS & (USART_BUFOVF_bm | USART_FERR_bm | USART_PERR_bm))) {
if (((rbuf.in - rbuf.out) & ~(RBUF_SIZE - 1)) == 0) {
rbuf.buf[rbuf.in & (RBUF_SIZE - 1)] = USART_GetChar(&USART);
rbuf.in++;
} else {
// It means that the buffer is full. Find a way to deal with it
uart_putc('E');
uart_putc('0');
uart_putc(USART_GetChar(&USART));
}
} else {
uart_putc('E');
uart_putc('1');
uart_putc(USART.STATUS);
uart_putc(USART_GetChar(&USART));
}
}
int16_t uart_fifo_get(void)
{
if (rbuf.in - rbuf.out)
return rbuf.buf[(rbuf.out++) & (RBUF_SIZE - 1)];
int16_t uart_fifo_get(void) {
if (rbuf.in - rbuf.out)
return rbuf.buf[(rbuf.out++) & (RBUF_SIZE - 1)];
return -1;
return -1;
}
void uart_fifo_put(uint8_t* buf, uint16_t len)
{
while(len)
{
if (((tbuf.in - tbuf.out) & ~(TBUF_SIZE - 1)) == 0)
{
tbuf.buf[tbuf.in & (TBUF_SIZE - 1)] = *buf;
tbuf.in++;
}
else
{
// It means that the buffer is full. Find a way to deal with it
uart_putc('E');
uart_putc('2');
}
void uart_fifo_put(uint8_t *buf, uint16_t len) {
while (len) {
if (((tbuf.in - tbuf.out) & ~(TBUF_SIZE - 1)) == 0) {
tbuf.buf[tbuf.in & (TBUF_SIZE - 1)] = *buf;
tbuf.in++;
} else {
// It means that the buffer is full. Find a way to deal with it
uart_putc('E');
uart_putc('2');
}
buf++;
len--;
}
buf++;
len--;
}
}
// UART loop, sending data, fetching data from sending buffer
void uart_task(void)
{
uint8_t sendbuf[sizeof(CMD_HEAD) + 64];
uint16_t DataLen = tbuf.in - tbuf.out;
uint16_t CurrentLen;
PCMD_HEAD SendHead = (PCMD_HEAD)sendbuf;
uint8_t i;
// UART loop, sending data, fetching data from sending buffer
void uart_task(void) {
uint8_t sendbuf[sizeof(CMD_HEAD) + 64];
uint16_t DataLen = tbuf.in - tbuf.out;
uint16_t CurrentLen;
PCMD_HEAD SendHead = (PCMD_HEAD)sendbuf;
uint8_t i;
while (DataLen)
{
// Maximum 64 bytes at one time
CurrentLen = DataLen;
if (CurrentLen > 64)
CurrentLen = 64;
while (DataLen) {
// Maximum 64 bytes at one time
CurrentLen = DataLen;
if (CurrentLen > 64)
CurrentLen = 64;
SendHead->bSign = CMD_HEAD_SIGN;
SendHead->bCmd = CMD_UART_RXTX;
SendHead->bCmdLen = CurrentLen;
SendHead->bChkSum = 0;
SendHead->bSign = CMD_HEAD_SIGN;
SendHead->bCmd = CMD_UART_RXTX;
SendHead->bCmdLen = CurrentLen;
SendHead->bChkSum = 0;
// It has to be copied here because the circular buffer is discontinuous
for (i = 0; i < CurrentLen; i++)
{
sendbuf[sizeof(CMD_HEAD) + i] = tbuf.buf[(tbuf.out++) & (TBUF_SIZE - 1)];
}
// Check Summing
SendHead->bChkSum = GetChkSum(SendHead, NULL);
// Send filled buffer
uart_putb(sendbuf, CurrentLen + sizeof(CMD_HEAD));
// It has to be copied here because the circular buffer is discontinuous
for (i = 0; i < CurrentLen; i++) {
sendbuf[sizeof(CMD_HEAD) + i] = tbuf.buf[(tbuf.out++) & (TBUF_SIZE - 1)];
}
// Check Summing
SendHead->bChkSum = GetChkSum(SendHead, NULL);
// Resize data
DataLen -= CurrentLen;
}
// Send filled buffer
uart_putb(sendbuf, CurrentLen + sizeof(CMD_HEAD));
// Resize data
DataLen -= CurrentLen;
}
}
// Send a byte
void uart_putc(uint8_t c)
{
// Wait buffer empty
while(!(USART.STATUS & USART_DREIF_bm));
// Send a byte
void uart_putc(uint8_t c) {
// Wait buffer empty
while (!(USART.STATUS & USART_DREIF_bm));
/* send next byte */
USART.DATA = c;
/* send next byte */
USART.DATA = c;
}
// Send a data block
void uart_putb(uint8_t* data, uint8_t len)
{
while (len)
{
uart_putc(*data);
data++;
len--;
}
// Send a data block
void uart_putb(uint8_t *data, uint8_t len) {
while (len) {
uart_putc(*data);
data++;
len--;
}
}
uint32_t dwBaudRate = 115200;
// Set UART rate
uint8_t uart_baudrate(uint32_t NewBaudrate)
{
uint8_t bRet = 1;
uint32_t dwBaudRate = 115200;
// Set UART rate
uint8_t uart_baudrate(uint32_t NewBaudrate) {
uint8_t bRet = 1;
switch (NewBaudrate)
{
case 115200:
USART_Baudrate_Set(&USART, 878 , -6); // 115200 -0.04%
break;
case 230400:
USART_Baudrate_Set(&USART, 407 , -6); // 230400 -0.04%
break;
case 460800:
USART_Baudrate_Set(&USART, 343 , -7); // 460800 -0.04%
break;
default:
dwBaudRate = 460800;
USART_Baudrate_Set(&USART, 343 , -7); // 460800 -0.04%
bRet = 0;
break;
}
switch (NewBaudrate) {
case 115200:
USART_Baudrate_Set(&USART, 878, -6); // 115200 -0.04%
break;
case 230400:
USART_Baudrate_Set(&USART, 407, -6); // 230400 -0.04%
break;
case 460800:
USART_Baudrate_Set(&USART, 343, -7); // 460800 -0.04%
break;
default:
dwBaudRate = 460800;
USART_Baudrate_Set(&USART, 343, -7); // 460800 -0.04%
bRet = 0;
break;
}
if (bRet)
{
dwBaudRate = NewBaudrate;
}
if (bRet) {
dwBaudRate = NewBaudrate;
}
return bRet;
return bRet;
}
// UART port initialization
void uart_init(void)
{
#ifdef CONFIG_UART_MODE
// Buffer initialization
rbuf.in = 0;
rbuf.out = 0;
rbuf.buf[0] = 0;
tbuf.in = 0;
tbuf.out = 0;
tbuf.buf[0] = 0;
// UART port initialization
void uart_init(void) {
#ifdef CONFIG_UART_MODE
// Buffer initialization
rbuf.in = 0;
rbuf.out = 0;
rbuf.buf[0] = 0;
tbuf.in = 0;
tbuf.out = 0;
tbuf.buf[0] = 0;
/* PE3 (TXD0) output */
PORTE.DIRSET = PIN3_bm;
PORTE.OUTSET = PIN3_bm;
/* PE2 (RXD0) input */
PORTE.DIRCLR = PIN2_bm;
PORTE.PIN2CTRL = PORT_OPC_PULLUP_gc;
/* PE3 (TXD0) output */
PORTE.DIRSET = PIN3_bm;
PORTE.OUTSET = PIN3_bm;
/* PE2 (RXD0) input */
PORTE.DIRCLR = PIN2_bm;
PORTE.PIN2CTRL = PORT_OPC_PULLUP_gc;
/* USART Mode - Asynchronous*/
USART_SetMode(&USART, USART_CMODE_ASYNCHRONOUS_gc);
/* USARTE0 Frame structure, 8-bit data bits, no check, 1 stop bit */
USART_Format_Set(&USART, USART_CHSIZE_8BIT_gc,USART_PMODE_DISABLED_gc, 0);
/* USART Mode - Asynchronous*/
USART_SetMode(&USART, USART_CMODE_ASYNCHRONOUS_gc);
/* USARTE0 Frame structure, 8-bit data bits, no check, 1 stop bit */
USART_Format_Set(&USART, USART_CHSIZE_8BIT_gc, USART_PMODE_DISABLED_gc, 0);
// Set baud rate @ 27.12M = 13.56 * 2
uart_baudrate(460800); // 460800
// uart_baudrate(230400); // 115200
// uart_baudrate(115200); // 115200
// Set baud rate @ 27.12M = 13.56 * 2
uart_baudrate(460800); // 460800
// uart_baudrate(230400); // 115200
// uart_baudrate(115200); // 115200
/* USART enable TX*/
USART_Tx_Enable(&USART);
/* USART enable RX*/
USART_Rx_Enable(&USART);
/* USART enable TX*/
USART_Tx_Enable(&USART);
/* USART enable RX*/
USART_Rx_Enable(&USART);
///* USART Receive interrupt level*/
//USART_RxdInterruptLevel_Set(&USART,USART_RXCINTLVL_LO_gc);
USART_RxdInterruptLevel_Set(&USART,USART_RXCINTLVL_HI_gc);
///* USART Receive interrupt level*/
//USART_RxdInterruptLevel_Set(&USART,USART_RXCINTLVL_LO_gc);
USART_RxdInterruptLevel_Set(&USART, USART_RXCINTLVL_HI_gc);
#endif
}
Firmware/Chameleon-Mini/Uart.h
+48 -48
View File
@@ -9,9 +9,9 @@
void uart_init(void);
void uart_task(void);
void uart_putc(uint8_t c);
void uart_putb(uint8_t* data, uint8_t len);
void uart_putb(uint8_t *data, uint8_t len);
void uart_fifo_put(uint8_t* buf, uint16_t len);
void uart_fifo_put(uint8_t *buf, uint16_t len);
int16_t uart_fifo_get(void);
//uint16_t user_get(uint8_t *buf);
@@ -20,20 +20,20 @@ int16_t uart_fifo_get(void);
//+------------------------------------------------------------------------------
/*Macros. */
/*Macros. */
/*! \brief Macro that sets the USART frame format.
*
* Sets the frame format, Frame Size, parity mode and number of stop bits.
*
* \param _usart Pointer to the USART module
* \param _charSize The character size. Use USART_CHSIZE_t type.
* \param _usart Pointer to the USART module
* \param _charSize The character size. Use USART_CHSIZE_t type.
* \param _parityMode The parity Mode. Use USART_PMODE_t type.
* \param _twoStopBits Enable two stop bit mode. Use bool type.
*/
#define USART_Format_Set(_usart, _charSize, _parityMode, _twoStopBits) \
(_usart)->CTRLC = (uint8_t) _charSize | _parityMode | \
(_twoStopBits ? USART_SBMODE_bm : 0)
#define USART_Format_Set(_usart, _charSize, _parityMode, _twoStopBits) \
(_usart)->CTRLC = (uint8_t) _charSize | _parityMode | \
(_twoStopBits ? USART_SBMODE_bm : 0)
/*! \brief Set USART baud rate.
@@ -44,28 +44,28 @@ int16_t uart_fifo_get(void);
* ScaleFactor : Time Base Generator Scale Factor
*
* Equation for calculation of BSEL value in asynchronous normal speed mode:
* If ScaleFactor >= 0
* BSEL = ((I/O clock frequency)/(2^(ScaleFactor)*16*Baudrate))-1
* If ScaleFactor < 0
* BSEL = (1/(2^(ScaleFactor)*16))*(((I/O clock frequency)/Baudrate)-1)
* If ScaleFactor >= 0
* BSEL = ((I/O clock frequency)/(2^(ScaleFactor)*16*Baudrate))-1
* If ScaleFactor < 0
* BSEL = (1/(2^(ScaleFactor)*16))*(((I/O clock frequency)/Baudrate)-1)
*
* \note See XMEGA manual for equations for calculation of BSEL value in other
* modes.
* \note See XMEGA manual for equations for calculation of BSEL value in other
* modes.
*
* \param _usart Pointer to the USART module.
* \param _bselValue Value to write to BSEL part of Baud control register.
* Use uint16_t type.
* \param _usart Pointer to the USART module.
* \param _bselValue Value to write to BSEL part of Baud control register.
* Use uint16_t type.
* \param _bScaleFactor USART baud rate scale factor.
* Use uint8_t type
* Use uint8_t type
*/
#define USART_Baudrate_Set(_usart, _bselValue, _bScaleFactor) \
(_usart)->BAUDCTRLA =(uint8_t)_bselValue; \
(_usart)->BAUDCTRLB =(_bScaleFactor << USART_BSCALE0_bp)|(_bselValue >> 8)
#define USART_Baudrate_Set(_usart, _bselValue, _bScaleFactor) \
(_usart)->BAUDCTRLA =(uint8_t)_bselValue; \
(_usart)->BAUDCTRLB =(_bScaleFactor << USART_BSCALE0_bp)|(_bselValue >> 8)
/*! \brief Enable USART receiver.
*
* \param _usart Pointer to the USART module
* \param _usart Pointer to the USART module
*/
#define USART_Rx_Enable(_usart) ((_usart)->CTRLB |= USART_RXEN_bm)
@@ -81,7 +81,7 @@ int16_t uart_fifo_get(void);
*
* \param _usart Pointer to the USART module.
*/
#define USART_Tx_Enable(_usart) ((_usart)->CTRLB |= USART_TXEN_bm)
#define USART_Tx_Enable(_usart) ((_usart)->CTRLB |= USART_TXEN_bm)
/*! \brief Disable USART transmitter.
@@ -95,24 +95,24 @@ int16_t uart_fifo_get(void);
*
* Sets the interrupt level on RX Complete interrupt.
*
* \param _usart Pointer to the USART module.
* \param _usart Pointer to the USART module.
* \param _rxdIntLevel Interrupt level of the RXD interrupt.
* Use USART_RXCINTLVL_t type.
* Use USART_RXCINTLVL_t type.
*/
#define USART_RxdInterruptLevel_Set(_usart, _rxdIntLevel) \
((_usart)->CTRLA = ((_usart)->CTRLA & ~USART_RXCINTLVL_gm) | _rxdIntLevel)
#define USART_RxdInterruptLevel_Set(_usart, _rxdIntLevel) \
((_usart)->CTRLA = ((_usart)->CTRLA & ~USART_RXCINTLVL_gm) | _rxdIntLevel)
/*! \brief Set USART TXD interrupt level.
*
* Sets the interrupt level on TX Complete interrupt.
*
* \param _usart Pointer to the USART module.
* \param _usart Pointer to the USART module.
* \param _txdIntLevel Interrupt level of the TXD interrupt.
* Use USART_TXCINTLVL_t type.
* Use USART_TXCINTLVL_t type.
*/
#define USART_TxdInterruptLevel_Set(_usart, _txdIntLevel) \
(_usart)->CTRLA = ((_usart)->CTRLA & ~USART_TXCINTLVL_gm) | _txdIntLevel
#define USART_TxdInterruptLevel_Set(_usart, _txdIntLevel) \
(_usart)->CTRLA = ((_usart)->CTRLA & ~USART_TXCINTLVL_gm) | _txdIntLevel
@@ -120,35 +120,35 @@ int16_t uart_fifo_get(void);
*
* Sets the interrupt level on Data Register interrupt.
*
* \param _usart Pointer to the USART module.
* \param _usart Pointer to the USART module.
* \param _dreIntLevel Interrupt level of the DRE interrupt.
* Use USART_DREINTLVL_t type.
* Use USART_DREINTLVL_t type.
*/
#define USART_DreInterruptLevel_Set(_usart, _dreIntLevel) \
(_usart)->CTRLA = ((_usart)->CTRLA & ~USART_DREINTLVL_gm) | _dreIntLevel
#define USART_DreInterruptLevel_Set(_usart, _dreIntLevel) \
(_usart)->CTRLA = ((_usart)->CTRLA & ~USART_DREINTLVL_gm) | _dreIntLevel
/*! \brief Set the mode the USART run in.
*
* Set the mode the USART run in. The default mode is asynchronous mode.
*
* \param _usart Pointer to the USART module register section.
* \param _usart Pointer to the USART module register section.
* \param _usartMode Selects the USART mode. Use USART_CMODE_t type.
*
* USART modes:
* - 0x0 : Asynchronous mode.
* - 0x1 : Synchronous mode.
* - 0x2 : IrDA mode.
* - 0x3 : Master SPI mode.
* - 0x0 : Asynchronous mode.
* - 0x1 : Synchronous mode.
* - 0x2 : IrDA mode.
* - 0x3 : Master SPI mode.
*/
#define USART_SetMode(_usart, _usartMode) \
((_usart)->CTRLC = ((_usart)->CTRLC & (~USART_CMODE_gm)) | _usartMode)
#define USART_SetMode(_usart, _usartMode) \
((_usart)->CTRLC = ((_usart)->CTRLC & (~USART_CMODE_gm)) | _usartMode)
/*! \brief Check if data register empty flag is set.
*
* \param _usart The USART module.
* \param _usart The USART module.
*/
#define USART_IsTXDataRegisterEmpty(_usart) (((_usart)->STATUS & USART_DREIF_bm) != 0)
@@ -159,8 +159,8 @@ int16_t uart_fifo_get(void);
* Use the macro USART_IsTXDataRegisterEmpty before using this function to
* put data to the TX register.
*
* \param _usart The USART module.
* \param _data The data to send.
* \param _usart The USART module.
* \param _data The data to send.
*/
#define USART_PutChar(_usart, _data) ((_usart)->DATA = _data)
@@ -170,7 +170,7 @@ int16_t uart_fifo_get(void);
*
* Checks if the RX complete interrupt flag is set.
*
* \param _usart The USART module.
* \param _usart The USART module.
*/
#define USART_IsRXComplete(_usart) (((_usart)->STATUS & USART_RXCIF_bm) != 0)
@@ -182,9 +182,9 @@ int16_t uart_fifo_get(void);
* This macro reads out the RX register.
* Use the macro USART_RX_Complete to check if anything is received.
*
* \param _usart The USART module.
* \param _usart The USART module.
*
* \retval Received data.
* \retval Received data.
*/
#define USART_GetChar(_usart) ((_usart)->DATA)
Firmware/Chameleon-Mini/uartcmd.c
+123 -142
View File
@@ -2,7 +2,7 @@
* uartcmd.c
*
* Created on: 20.03.2013
* Author: Willok
* Author: Willok
*
* ChangeLog
* 2019-09-22 Willok Added processing of UART command
@@ -18,178 +18,159 @@
#include "System.h"
uint16_t CmdLen = 0;
uint8_t CmdBuffer[256];
uint16_t CmdLen = 0;
uint8_t CmdBuffer[256];
// Check Summing
uint8_t GetChkSum(PCMD_HEAD pCmdHead, uint8_t* DataPtr)
{
uint8_t bRet = 0;
// Check Summing
uint8_t GetChkSum(PCMD_HEAD pCmdHead, uint8_t *DataPtr) {
uint8_t bRet = 0;
if (!DataPtr)
DataPtr = (uint8_t*)(pCmdHead + 1);
if (!DataPtr)
DataPtr = (uint8_t *)(pCmdHead + 1);
bRet -= pCmdHead->bSign;
bRet -= pCmdHead->bCmd;
bRet -= pCmdHead->bCmdLen;
for (uint8_t i = 0; i < pCmdHead->bCmdLen; i++)
{
bRet -= DataPtr[i];
}
bRet -= pCmdHead->bSign;
bRet -= pCmdHead->bCmd;
bRet -= pCmdHead->bCmdLen;
return bRet;
for (uint8_t i = 0; i < pCmdHead->bCmdLen; i++) {
bRet -= DataPtr[i];
}
return bRet;
}
// UART command initialization
void uartcmd_init(void)
{
CmdLen = 0;
CmdBuffer[0] = 0;
// UART command initialization
void uartcmd_init(void) {
CmdLen = 0;
CmdBuffer[0] = 0;
}
// USBmode or UARTmode
extern uint8_t bUSBTerminal;
// USBmode or UARTmode
extern uint8_t bUSBTerminal;
// Received UART command data. Need to be handed over to the command line
void CmdUartRx(PCMD_HEAD CmdHead, uint8_t* UartData)
{
if (!bUSBTerminal)
{
while (CmdHead->bCmdLen)
{
if (XModemProcessByte(*UartData)) {
/* XModem handled the byte */
} else if (CommandLineProcessByte(*UartData)) {
/* CommandLine handled the byte */
}
// Received UART command data. Need to be handed over to the command line
void CmdUartRx(PCMD_HEAD CmdHead, uint8_t *UartData) {
if (!bUSBTerminal) {
while (CmdHead->bCmdLen) {
if (XModemProcessByte(*UartData)) {
/* XModem handled the byte */
} else if (CommandLineProcessByte(*UartData)) {
/* CommandLine handled the byte */
}
UartData++;
CmdHead->bCmdLen--;
}
}
UartData++;
CmdHead->bCmdLen--;
}
}
}
// Heartbeat marker
uint8_t bKeepAlive = 1;
// Heartbeat marker
uint8_t bKeepAlive = 1;
// Version number with compilation date
char bVersion[] = "v1.0 " BUILD_DATE " " __TIME__;
// Version number with compilation date
char bVersion[] = "v1.0 " BUILD_DATE " " __TIME__;
// Command tick, send heartbeat packet regularly
void uartcmd_tick(void)
{
static uint8_t KeepAliveTick = 200;
// Command tick, send heartbeat packet regularly
void uartcmd_tick(void) {
static uint8_t KeepAliveTick = 200;
// heartbeat every 2S
if (++KeepAliveTick >= 20)
{
KeepAliveTick = 0;
// heartbeat every 2S
if (++KeepAliveTick >= 20) {
KeepAliveTick = 0;
if (bKeepAlive)
{
uint8_t Buffer[sizeof(CMD_HEAD) + sizeof(CMD_KEEP_ALIVE)];
PCMD_HEAD CmdHead = (PCMD_HEAD)Buffer;
PCMD_KEEP_ALIVE pKeepAlive = (PCMD_KEEP_ALIVE)(CmdHead + 1);
if (bKeepAlive) {
uint8_t Buffer[sizeof(CMD_HEAD) + sizeof(CMD_KEEP_ALIVE)];
PCMD_HEAD CmdHead = (PCMD_HEAD)Buffer;
PCMD_KEEP_ALIVE pKeepAlive = (PCMD_KEEP_ALIVE)(CmdHead + 1);
// Fill handshake package
CmdHead->bSign = 0xA5;
CmdHead->bCmd = CMD_TYPE_ALIVE;
CmdHead->bCmdLen = sizeof(CMD_KEEP_ALIVE);
pKeepAlive->bMajVer = 1;
pKeepAlive->bMinVer = 0;
memcpy(pKeepAlive->bVerStr, bVersion, sizeof(bVersion));
// Fill handshake package
CmdHead->bSign = 0xA5;
CmdHead->bCmd = CMD_TYPE_ALIVE;
CmdHead->bCmdLen = sizeof(CMD_KEEP_ALIVE);
pKeepAlive->bMajVer = 1;
pKeepAlive->bMinVer = 0;
memcpy(pKeepAlive->bVerStr, bVersion, sizeof(bVersion));
CmdHead->bChkSum = GetChkSum(CmdHead, NULL);
// Send handshake package
uart_putb((uint8_t*)CmdHead, sizeof(CMD_HEAD) + CmdHead->bCmdLen);
}
}
CmdHead->bChkSum = GetChkSum(CmdHead, NULL);
// Send handshake package
uart_putb((uint8_t *)CmdHead, sizeof(CMD_HEAD) + CmdHead->bCmdLen);
}
}
}
// Receive shutdown notification
void CmdUartPowerDown(PCMD_HEAD CmdHead, uint8_t* UartData)
{
// Switch to empty configuration, not saved
ConfigurationSetById(CONFIG_NONE);
// Receive shutdown notification
void CmdUartPowerDown(PCMD_HEAD CmdHead, uint8_t *UartData) {
// Switch to empty configuration, not saved
ConfigurationSetById(CONFIG_NONE);
// Save log on demand
LogTick();
// Save log on demand
LogTick();
// Flash two LED to warning power off
LED_PORT.OUTSET = PIN4_bm;
LED_PORT.OUTCLR = PIN3_bm;
while (1)
{
if (SystemTick100ms())
{
LED_PORT.OUTTGL = PIN4_bm;
LED_PORT.OUTTGL = PIN3_bm;
}
}
// Flash two LED to warning power off
LED_PORT.OUTSET = PIN4_bm;
LED_PORT.OUTCLR = PIN3_bm;
while (1) {
if (SystemTick100ms()) {
LED_PORT.OUTTGL = PIN4_bm;
LED_PORT.OUTTGL = PIN3_bm;
}
}
}
// Command processing callback
void uartcmd_task(void)
{
int16_t RecvData;
// Loop data in receive buffer
while ((RecvData = uart_fifo_get()) >= 0)
{
CmdBuffer[CmdLen] = (uint8_t)RecvData;
// Command processing callback
void uartcmd_task(void) {
int16_t RecvData;
// Loop data in receive buffer
while ((RecvData = uart_fifo_get()) >= 0) {
CmdBuffer[CmdLen] = (uint8_t)RecvData;
// The first character must be special, otherwise it will be discarded
if (CmdLen == 0 && CmdBuffer[0] != CMD_HEAD_SIGN)
continue;
// The first character must be special, otherwise it will be discarded
if (CmdLen == 0 && CmdBuffer[0] != CMD_HEAD_SIGN)
continue;
// Statistics received
CmdLen++;
// At least one head is needed, then we can handle it.
if (CmdLen >= sizeof(CMD_HEAD))
{
PCMD_HEAD CmdHead = (PCMD_HEAD)CmdBuffer;
// Statistics received
CmdLen++;
// If the command length is too long, there must be error. Discard the data and wait for resynchronization.
if (CmdHead->bCmdLen >= (sizeof(CmdBuffer) - sizeof(CMD_HEAD)))
{
CmdLen = 0;
continue;
}
// At least one head is needed, then we can handle it.
if (CmdLen >= sizeof(CMD_HEAD)) {
PCMD_HEAD CmdHead = (PCMD_HEAD)CmdBuffer;
// Judge whether the received data is complete
if (CmdLen >= sizeof(CMD_HEAD) + CmdHead->bCmdLen)
{
// Calculate the check sum, otherwise discard it.
if (CmdHead->bChkSum != GetChkSum(CmdHead, NULL))
{
CmdLen = 0;
continue;
}
// Processing command
switch (CmdHead->bCmd)
{
case CMD_UART_RXTX: // Uart data
CmdUartRx(CmdHead, (uint8_t*)(CmdHead+1));
break;
case CMD_TYPE_POWERDOWN: // Switch to empty configuration and wait for power failure
CmdUartPowerDown(CmdHead, (uint8_t*)(CmdHead+1));
break;
case CMD_TYPE_ALIVE: // Receive the heartbeat package response, turn off the heartbeat
bKeepAlive = 0;
break;
default:
break;
}
// If the command length is too long, there must be error. Discard the data and wait for resynchronization.
if (CmdHead->bCmdLen >= (sizeof(CmdBuffer) - sizeof(CMD_HEAD))) {
CmdLen = 0;
continue;
}
// Clear command buffer after command processing
CmdLen = 0;
}
}
}
// Judge whether the received data is complete
if (CmdLen >= sizeof(CMD_HEAD) + CmdHead->bCmdLen) {
// Calculate the check sum, otherwise discard it.
if (CmdHead->bChkSum != GetChkSum(CmdHead, NULL)) {
CmdLen = 0;
continue;
}
// Processing command
switch (CmdHead->bCmd) {
case CMD_UART_RXTX: // Uart data
CmdUartRx(CmdHead, (uint8_t *)(CmdHead + 1));
break;
case CMD_TYPE_POWERDOWN: // Switch to empty configuration and wait for power failure
CmdUartPowerDown(CmdHead, (uint8_t *)(CmdHead + 1));
break;
case CMD_TYPE_ALIVE: // Receive the heartbeat package response, turn off the heartbeat
bKeepAlive = 0;
break;
default:
break;
}
// Clear command buffer after command processing
CmdLen = 0;
}
}
}
}
Firmware/Chameleon-Mini/uartcmd.h
+29 -29
View File
@@ -6,50 +6,50 @@ void uartcmd_init(void);
void uartcmd_tick(void);
void uartcmd_task(void);
// Command header ID
#define CMD_HEAD_SIGN 0xA5
// Command header ID
#define CMD_HEAD_SIGN 0xA5
// Command reply ID
#define CMD_SEND_ACK 0x80
// Command reply ID
#define CMD_SEND_ACK 0x80
// UART data command 'U'
#define CMD_UART_RXTX 0x75
// UART data command 'U'
#define CMD_UART_RXTX 0x75
// TEST data command 't'
#define CMD_BLE_TEST 0x74
// TEST data command 't'
#define CMD_BLE_TEST 0x74
// Heartbeat command 'a'
#define CMD_TYPE_ALIVE 0x61
// Heartbeat command 'a'
#define CMD_TYPE_ALIVE 0x61
// Power down command 'p'
#define CMD_TYPE_POWERDOWN 0x70
// Power down command 'p'
#define CMD_TYPE_POWERDOWN 0x70
//#pragma pack(push,1)
// GCC Use another alignment command __attribute__ ((aligned (1)))
// Command structure
// GCC Use another alignment command __attribute__ ((aligned (1)))
// Command structure
typedef struct {
uint8_t bSign; // Head sign
uint8_t bCmd; // Command type
uint8_t bCmdLen; // Command length (without header)
uint8_t bChkSum; // Command checksum
} CMD_HEAD, *PCMD_HEAD __attribute__ ((aligned (1)));
uint8_t bSign; // Head sign
uint8_t bCmd; // Command type
uint8_t bCmdLen; // Command length (without header)
uint8_t bChkSum; // Command checksum
} CMD_HEAD, *PCMD_HEAD __attribute__((aligned(1)));
// ÐÄÌøÃüÁî
// Heartbeat command
typedef struct {
uint8_t bMajVer; // main version
uint8_t bMinVer; // Sub version number
uint8_t bVerStr[32]; // Version string
}CMD_KEEP_ALIVE, *PCMD_KEEP_ALIVE __attribute__ ((aligned (1)));
uint8_t bMajVer; // main version
uint8_t bMinVer; // Sub version number
uint8_t bVerStr[32]; // Version string
} CMD_KEEP_ALIVE, *PCMD_KEEP_ALIVE __attribute__((aligned(1)));
// ´®¿ÚÊý¾Ý·¢ËÍ
// Serial data transmission
typedef struct {
uint16_t wBitCount; // Length of data sent, unit: bit
uint8_t bFlag; // Generate check bit, CRC and other flags
}CMD_SEND_DATA, *PCMD_SEND_DATA __attribute__ ((aligned (1)));
uint16_t wBitCount; // Length of data sent, unit: bit
uint8_t bFlag; // Generate check bit, CRC and other flags
} CMD_SEND_DATA, *PCMD_SEND_DATA __attribute__((aligned(1)));
uint8_t GetChkSum(PCMD_HEAD pCmdHead, uint8_t* DataPtr);
uint8_t GetChkSum(PCMD_HEAD pCmdHead, uint8_t *DataPtr);
//#pragma pack(pop)