#include "log.h"

#ifdef LOG_ENABLE
//日志缓冲区定义
LogQueue logQueue={LOG_MAX_QUEUE_SIZE};
#endif

#ifndef _LOG_H_
#define _LOG_H_

/**************↓配置区↓**************/

//标准库头文件
//若不希望使用对应函数可注释头文件后修改下方函数宏实现相应功能
#include <stdio.h> //使用sprintf
#include <string.h> //使用memcpy、strlen
//标准库函数移植宏
#define LOG_MEMCPY(dst,src,len) memcpy(dst,src,len) //内存拷贝
#define LOG_SPRINTF(buf,fmt,...) sprintf(buf,fmt,##__VA_ARGS__) //格式化字符串
#define LOG_STRLEN(str) strlen(str) //计算字符串长度

//日志缓冲区大小，总大小为下列两个值的乘积
#define LOG_MAX_LEN 100 //单条日志缓冲区大小，包含日志内容、时间戳、函数名等信息，建议不小于100
#define LOG_MAX_QUEUE_SIZE 10 //缓冲区可存日志条数

//获取时间戳接口(启动后经过的毫秒数)
#define LOG_GET_MS() HAL_GetTick() //本例使用STM32-HAL

//获取语句所在函数名的宏(一般由编译器提供)
#define LOG_GET_FUNC_NAME() (__FUNCTION__)

//是否开启日志输出(注释掉则所有输出语句会替换为空语句)
#define LOG_ENABLE

/**************↑配置区↑**************/

/**************↓日志输出接口↓**************/
//信息日志
#define LOG_INFO(tag,msg,...) LOG_ADD_FORMAT('i',(tag),(msg),##__VA_ARGS__)
//调试日志
#define LOG_DEBUG(tag,msg,...) LOG_ADD_FORMAT('d',(tag),(msg),##__VA_ARGS__)
//警告日志
#define LOG_WARN(tag,msg,...) LOG_ADD_FORMAT('w',(tag),(msg),##__VA_ARGS__)
//错误日志
#define LOG_ERROR(tag,msg,...) LOG_ADD_FORMAT('e',(tag),(msg),##__VA_ARGS__)
/**************↑日志输出接口↑**************/

//日志缓冲区类型，以队列方式存储
typedef struct{
	int maxSize; //队列最大长度，初始化时须赋值为LOG_MAX_QUEUE_SIZE
	char buf[LOG_MAX_QUEUE_SIZE][LOG_MAX_LEN]; //实际存储空间
	int lenBuf[LOG_MAX_QUEUE_SIZE]; //与buf一一对应，表示存储的日志长度
	int size,startPos;//当前队列长度和队头位置
}LogQueue;

#ifdef LOG_ENABLE
//日志输出集中处理，添加一条日志到缓冲区
#define LOG_ADD_FORMAT(attr,tag,msg,...) if(logQueue.size<LOG_MAX_QUEUE_SIZE){ \
	int index=(logQueue.startPos+logQueue.size+1)%LOG_MAX_QUEUE_SIZE; \
	char *bufStartAddr=logQueue.buf[index],*buf=bufStartAddr; int termLen=0; \
	*buf=attr; buf+=1; \
	termLen=LOG_STRLEN(tag)+1; LOG_MEMCPY(buf,tag,termLen); buf+=termLen; \
	LOG_SPRINTF(buf,msg,##__VA_ARGS__); termLen=LOG_STRLEN(buf)+1; buf+=termLen; \
	LOG_SPRINTF(buf,"%d",LOG_GET_MS()); termLen=LOG_STRLEN(buf)+1; buf+=termLen; \
	termLen=LOG_STRLEN(LOG_GET_FUNC_NAME())+1; LOG_MEMCPY(buf,LOG_GET_FUNC_NAME(),termLen); buf+=termLen; buf+=termLen; \
	logQueue.lenBuf[index]=buf-bufStartAddr; logQueue.size++; \
}
//声明缓冲区定义，实际定义可在任意一个源文件中
extern LogQueue logQueue;
#else
#define LOG_ADD_FORMAT(attr,tag,msg,...)
#endif

#endif

// debug.c
#include <stdint.h>

#include "usart.h" //本例使用STM32，其他平台无需引用此头文件

/**************↓配置区↓**************/
//串口发送语句，需实现将buf指向的len个字节通过串口发出
#define DEBUG_SEND(buf,len) HAL_UART_Transmit_IT(&huart1,(buf),(len))
//复位指令，若设备不支持或无需此功能可不定义
#define DEBUG_RESET() { \
	__set_FAULTMASK(1); \
	NVIC_SystemReset(); \
}
//读地址限制条件，若请求的地址addr不符合条件则返回0x00，无需限制可不定义
#define DEBUG_READ_ADDR_RANGE(addr) (addr>=0x20000000 && addr<=0x20001000)
//写地址限制条件，若请求的地址addr不符合条件则不会写入，无需限制可不定义
#define DEBUG_WRITE_ADDR_RANGE(addr) (addr>=0x20000000 && addr<=0x20001000)
//读写偏移地址，无偏移可不定义
#define DEBUG_ADDR_OFFSET 0x00000000
/**************↑配置区↑**************/

//接收缓存区（循环队列）大小，不建议修改
#define DEBUG_RXBUF_SIZE 30
//发送缓存区大小，不建议修改
#define DEBUG_TXBUF_SIZE 30

//数据帧格式：帧头1B+帧长1B+命令码1B+数据
//固定帧头
#define DEBUG_FRAME_HEADER 0xDB
//命令码枚举，用于标记数据帧类型
typedef enum{
	SerialCMD_ReadMem, //读内存数据
	SerialCMD_WriteMem, //写内存数据
	SerialCMD_Reset //复位
}SerialCMD;

//串口发送缓存区
uint8_t debugTxBuf[DEBUG_TXBUF_SIZE];

//以下实现了一个循环队列用于串口接收，无溢出检查
struct{
	uint8_t buf[DEBUG_RXBUF_SIZE]; //缓存区
	uint16_t startPos,endPos; //队头队尾指针
}debugRxQueue={0};
//入队一个字符
#define DEBUG_QUEUE_PUSH(ch) { \
	debugRxQueue.buf[debugRxQueue.endPos++]=(ch); \
	if(debugRxQueue.endPos>=DEBUG_RXBUF_SIZE) \
		debugRxQueue.endPos-=DEBUG_RXBUF_SIZE; \
}
//出队一个字符
#define DEBUG_QUEUE_POP() { \
	debugRxQueue.startPos++; \
	if(debugRxQueue.startPos>=DEBUG_RXBUF_SIZE) \
		debugRxQueue.startPos-=DEBUG_RXBUF_SIZE; \
}
//获取队头字符
#define DEBUG_QUEUE_TOP() (debugRxQueue.buf[debugRxQueue.startPos])
//获取队列大小
#define DEBUG_QUEUE_SIZE() \
	(debugRxQueue.startPos<=debugRxQueue.endPos? \
	debugRxQueue.endPos-debugRxQueue.startPos: \
	debugRxQueue.endPos+DEBUG_RXBUF_SIZE-debugRxQueue.startPos)
//获取队列第pos个元素
#define DEBUG_QUEUE_AT(pos) \
	(debugRxQueue.startPos+(pos)<DEBUG_RXBUF_SIZE? \
	debugRxQueue.buf[debugRxQueue.startPos+(pos)]: \
	debugRxQueue.buf[debugRxQueue.startPos+(pos)-DEBUG_RXBUF_SIZE])

//函数声明
void Debug_SerialRecv(uint8_t *buf,uint16_t len);
void Debug_ParseBuffer(void);

//串口收到数据后传入本函数进行解析，需被外部调用
void Debug_SerialRecv(uint8_t *buf,uint16_t len)
{
	for(uint16_t i=0;i<len;i++) //将收到的数据依次入队
		DEBUG_QUEUE_PUSH(buf[i]);
	Debug_ParseBuffer(); //进入解析
}

//解析串口数据
void Debug_ParseBuffer()
{
	if(DEBUG_QUEUE_AT(0)==DEBUG_FRAME_HEADER) //第一个字节为帧头，可以继续解析
	{
		if(DEBUG_QUEUE_SIZE()>2 && DEBUG_QUEUE_SIZE()>=DEBUG_QUEUE_AT(1)) //帧长足够，可以解析
		{
			uint16_t frameLen=DEBUG_QUEUE_AT(1);//读出帧长
			uint8_t cmd=DEBUG_QUEUE_AT(2); //读出命令码
			if(cmd==SerialCMD_ReadMem) //若要读取内存数据
			{
				uint8_t byteNum=DEBUG_QUEUE_AT(3); //要读取的字节数
				if(byteNum>DEBUG_TXBUF_SIZE-3) //限制读取的字节数不能使帧长超过发送缓冲区大小
					byteNum=DEBUG_TXBUF_SIZE-3;
				uint32_t addr=0; //计算目标地址
				for(uint8_t i=0;i<4;i++)
					addr|=((uint32_t)DEBUG_QUEUE_AT(4+i))<<(i*8);
				#ifdef DEBUG_ADDR_OFFSET
					addr+=DEBUG_ADDR_OFFSET;
				#endif
				debugTxBuf[0]=DEBUG_FRAME_HEADER; //构建发送数据帧
				debugTxBuf[1]=byteNum+3;
				debugTxBuf[2]=SerialCMD_ReadMem;
				for(uint8_t i=0;i<byteNum;i++) //依次写入指定地址的数据
				{
					uint8_t byte=0;
					#ifdef DEBUG_READ_ADDR_RANGE
					if(DEBUG_READ_ADDR_RANGE((addr+i)))
					#endif
						byte=*(uint8_t*)(addr+i);
					debugTxBuf[i+3]=byte;
				}
				DEBUG_SEND(debugTxBuf,byteNum+3); //串口发送
				for(uint8_t i=0;i<frameLen;i++) //将本帧出队
					DEBUG_QUEUE_POP();
			}
			else if(cmd==SerialCMD_WriteMem) //若要写入内存数据
			{
				uint8_t byteNum=frameLen-7; //要写入的字节数
				uint32_t addr=0; //计算目标地址
				for(uint8_t i=0;i<4;i++)
					addr|=((uint32_t)DEBUG_QUEUE_AT(3+i))<<(i*8);
				#ifdef DEBUG_ADDR_OFFSET
					addr+=DEBUG_ADDR_OFFSET;
				#endif
				for(uint8_t i=0;i<byteNum;i++) //依次写入数据
				{
					#ifdef DEBUG_WRITE_ADDR_RANGE
					if(DEBUG_WRITE_ADDR_RANGE((addr+i)))
					#endif
						*(uint8_t*)(addr+i)=DEBUG_QUEUE_AT(7+i);
				}
				for(uint8_t i=0;i<frameLen;i++) //将本帧出队
					DEBUG_QUEUE_POP();
			}
			else if(cmd==SerialCMD_Reset) //若要复位
			{
				#ifdef DEBUG_RESET
				DEBUG_RESET();
				#endif
			}
			if(DEBUG_QUEUE_SIZE()>0) //若后面还有数据，进行递归解析
				Debug_ParseBuffer();
		}
	}
	else //数据帧错误
	{
		while(DEBUG_QUEUE_AT(0)!=DEBUG_FRAME_HEADER && DEBUG_QUEUE_SIZE()>0) //将错误数据出队
			DEBUG_QUEUE_POP();
		if(DEBUG_QUEUE_SIZE()>0) //若后面还有数据，继续解析
			Debug_ParseBuffer();
	}
}

/****Debug.c****/
//...
//串口发送指令（使用串口1）
#define DEBUG_SEND(buf,len) HAL_UART_Transmit_IT(&huart1,(buf),(len))
//复位指令
#define DEBUG_RESET() { \
    __set_FAULTMASK(1); \
    NVIC_SystemReset(); \
}
//...

/****main.c****/
//...
int main(void)
{
    //...(需先进行串口初始化)
    __HAL_UART_ENABLE_IT(&huart1,UART_IT_RXNE); //使能串口RXNE中断
    //...
    while(1)
    {
        //...
    }
}
//...

/****stm32f1xx_it.c****/
//...
void USART1_IRQHandler(void) //串口中断服务函数
{
    if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_RXNE)!=RESET) //判定为RXNE中断
    {
        uint8_t ch=huart1.Instance->DR; //读出收到的字节
        Debug_SerialRecv(&ch,1); //进行解析
    }
}
//...