uart protocol function

Signed-off-by: huhui <huhui@sharkgulf.com>

Application/app/protocol.c

@@ -3,27 +3,44 @@
 #include "bsp/uart.h"
 static uint16_t _check_sum(uint8_t*data,uint16_t size);
 static uart_enum_t current_uart = SHARK_UART0;
-/*
- * 调用 protocol_send_xxx 接口的时候，需要注意需要多分配can_head_t 大小的内存，并且
- * 需要offset掉can_head_t 大小, 这样设计的原因是避免多次拷贝
-*/
+
 void protocol_send_bms_info(protocol_head_t *head){
-	can_head_t *can = (can_head_t *)(((uint8_t *)head) - sizeof(can_head_t));
-	can->can_addr = 0x42;
-	can->size = head->size;
+	can_head_t can_head;
+	can_head.can_addr = 0x42;
+	can_head.size = head->size;
+	
 	head->checksum = 0;
 	head->checksum = _check_sum((uint8_t *)head, head->size);
 
-	shark_uart_write_frame(current_uart, (uint8_t *)can, sizeof(can_head_t) + head->size);
+	shark_uart_frame_start(current_uart, (uint8_t *)&can_head, sizeof(can_head));
+	shark_uart_frame_continue(current_uart, (uint8_t *)head, head->size);
+	shark_uart_frame_end(current_uart);
 }
 
 
-void protocol_send_debug_info(uint8_t dest, uint8_t *data, int size){
-	can_head_t *can = (can_head_t *)(data - sizeof(can_head_t));
-	can->can_addr = dest;
-	can->size = size;
+void protocol_send_debug_info(uint8_t dest, uint8_t *data, int size){	
+	can_head_t can_head;
+	can_head.can_addr = dest;
+	can_head.size = size;
+	shark_uart_frame_start(current_uart, (uint8_t *)&can_head, sizeof(can_head));
+	shark_uart_frame_continue(current_uart, data, size);
+	shark_uart_frame_end(current_uart);
+}
 
-	shark_uart_write_frame(current_uart, (uint8_t *)can, sizeof(can_head_t) + size);
+/*如果接收到的数据frame，无法识别为新的protocol，认为是老协议，这里通过老协议发送给PSxxx,告知
+  只支持新协议
+*/
+void protocol_notify_old_frame(uart_enum_t uart_no){
+	current_uart = uart_no;
+	protocol_head_t head;
+	memset(&head, 0, sizeof(head));
+	head.size = sizeof(head);
+	head.protocol = 'C';
+	head.type = 0x30;
+	head.dir = 0x16;
+	head.cmd = 0x10;
+	head.checksum = _check_sum((uint8_t *)&head, head.size);
+	shark_uart_write_frame(current_uart, (uint8_t *)&head, head.size);
 }
 
 void protocol_recv_frame(uart_enum_t uart_no, uint8_t *data, int len){

Application/app/sox/measure_task.c

@@ -1,6 +1,7 @@
 #include "bsp/gpio.h"
 #include "app/sox/measure.h"
 #include "libs/shark_task.h"
+#include "libs/logger.h"
 #include "measure_task.h"
 #include "state.h"
 
@@ -27,6 +28,7 @@ void measure_task_init(measure_notify cn, measure_notify vn, measure_notify tn){
 	init_pack_current_task();
 	init_cell_task();
 	init_temp_task();
+	set_log_level(MOD_MEASURE, L_debug);
 }
 
 measure_value_t * measure_value(void){
@@ -40,7 +42,7 @@ static struct means_task _pack_current_task;
 static u32 pack_current_task_handler(void);
 static void init_pack_current_task(void){
 	_pack_current_task._task.handler = pack_current_task_handler;
-	_pack_current_task.delay = 30;
+	_pack_current_task.delay = 1000;
 	_pack_current_task.index = 0;
 	_measure_value.load_current = get_pack_current();
 	shark_task_add(&_pack_current_task._task);
@@ -49,6 +51,7 @@ static void init_pack_current_task(void){
 static u32 pack_current_task_handler(void){
 	_measure_value.load_current = get_pack_current();
 	_current_notify();//֪ͨbms state ÓÐеĵçÁ÷Êý¾Ý
+	measure_debug("load current = %f\n", _measure_value.load_current);
 	return _pack_current_task.delay;
 }
 

Application/bsp/uart.c

@@ -6,14 +6,14 @@
 #define SHARK_UART_BAUDRATE				38400
 
 #define SHARK_UART0_com					USART0
-#define SHARK_UART0_tx_port				GPIOA
-#define SHARK_UART0_tx_pin				GPIO_PIN_9
-#define SHARK_UART0_rx_port				GPIOA
-#define SHARK_UART0_rx_pin				GPIO_PIN_10
+#define SHARK_UART0_tx_port				GPIOB
+#define SHARK_UART0_tx_pin				GPIO_PIN_6
+#define SHARK_UART0_rx_port				GPIOB
+#define SHARK_UART0_rx_pin				GPIO_PIN_7
 #define SHARK_UART0_irq					USART0_IRQn
 #define SHARK_UART0_clk					RCU_USART0
-#define SHARK_UART0_tx_gpio_clk			RCU_GPIOA
-#define SHARK_UART0_rx_gpio_clk			RCU_GPIOA
+#define SHARK_UART0_tx_gpio_clk			RCU_GPIOB
+#define SHARK_UART0_rx_gpio_clk			RCU_GPIOB
 #define SHARK_UART0_tx_dma				DMA
 #define SHARK_UART0_tx_dma_ch			DMA_CH1
 #define SHARK_UART0_tx_dma_clk			RCU_DMA
@@ -48,6 +48,7 @@ static bool new_prococol = false;
 static u64 _rx_time;
 #define update_dma_w_pos(uart) circle_update_write_position(&uart->rx_queue, SHARK_UART_RX_MEM_SIZE - DMA_CHCNT(uart->rx_dma_ch))
 extern void protocol_recv_frame(uart_enum_t uart_no, char *data, int len);
+extern void protocol_notify_old_frame(uart_enum_t uart_no);
 // ================================================================================
 static uart_enum_t _uart_index(uint32_t com){
 	return com == SHARK_UART0_com?SHARK_UART0:SHARK_UART1;
@@ -71,9 +72,9 @@ static void shark_uart_rx(shark_uart_t *uart){
 		update_dma_w_pos(uart);
 		if (circle_get_one_data(&uart->rx_queue, &data) != 1) {
 			if (!new_prococol){//通过老协议发送过来的，需要回复一个信息，告知使用新协议,霍尔移除，通信超时需要reset new_protocol
-				if (shark_get_mseconds() - _rx_time >= 30) {
+				if (shark_get_mseconds() >= (30 + _rx_time)) {
 					_rx_time = 0xFFFFFFFFFFFFL;
-					protocol_recv_frame(_uart_index(uart->uart_com), NULL, 0);
+					protocol_notify_old_frame(_uart_index(uart->uart_com));
 				}
 			}
 			break;
@@ -170,42 +171,84 @@ static void shark_uart_write_byte(shark_uart_t *uart, u8 value)
 	shark_uart_write(uart, &value, 1);
 }
 
-void shark_uart_dma_init(dma_channel_enum channelx, u8 direction, u32 periph_addr, void *memory_addr, u16 length)
-{
-	u32 ctl;
-
-	DMA_CHCTL(channelx) &= ~DMA_CHXCTL_CHEN;
 
-	/* configure peripheral base address */
-	DMA_CHPADDR(channelx) = periph_addr;
+static void shark_uart_tx_dma_init(shark_uart_t *uart){
+	dma_parameter_struct dma_init_struct;
+	rcu_periph_clock_enable(_uart_index(uart->uart_com)== SHARK_UART0?SHARK_UART0_tx_dma_clk:SHARK_UART1_tx_dma_clk);
+	dma_deinit(uart->tx_dma_ch);
+	dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
+	dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
+	dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
+	dma_init_struct.periph_addr = (u32) &USART_TDATA(uart->uart_com);
+	dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
+	dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
+	dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
+	dma_init(uart->tx_dma_ch, &dma_init_struct);
+	dma_circulation_disable(uart->tx_dma_ch);
+	dma_memory_to_memory_disable(uart->tx_dma_ch);
+	usart_dma_transmit_config(uart->uart_com, USART_DENT_ENABLE);
+}
 
-	/* configure memory base address */
-	DMA_CHMADDR(channelx) = (u32) memory_addr;
 
-	/* configure the number of remaining data to be transferred */
-	DMA_CHCNT(channelx) = length;
+static void shark_uart_rx_dma_init(shark_uart_t *uart){
+	dma_parameter_struct dma_init_struct;
+	rcu_periph_clock_enable(_uart_index(uart->uart_com)== SHARK_UART0?SHARK_UART0_rx_dma_clk:SHARK_UART1_rx_dma_clk);
+	dma_deinit(uart->rx_dma_ch);
+	dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
+	dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
+	dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
+	dma_init_struct.memory_addr = (u32)uart->rx_queue.buffer;
+	dma_init_struct.number = uart->rx_queue.buffer_len;
+	dma_init_struct.periph_addr = (u32) &USART_RDATA(uart->uart_com);
+	dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
+	dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
+	dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
+	dma_init(uart->rx_dma_ch, &dma_init_struct);
+	dma_circulation_enable(uart->rx_dma_ch);
+	dma_memory_to_memory_disable(uart->rx_dma_ch);
+	dma_channel_enable(uart->rx_dma_ch);
+	usart_dma_receive_config(uart->uart_com, USART_DENR_ENABLE);
+}
 
-	/* configure peripheral transfer width,memory transfer width and priority */
-	ctl = DMA_CHCTL(channelx);
-	ctl &= ~(DMA_CHXCTL_PWIDTH | DMA_CHXCTL_MWIDTH | DMA_CHXCTL_PRIO);
-	ctl |= (DMA_PERIPHERAL_WIDTH_8BIT | DMA_MEMORY_WIDTH_8BIT | DMA_PRIORITY_ULTRA_HIGH);
-	DMA_CHCTL(channelx) = ctl;
+static void shark_uart_pin_init(shark_uart_t *uart){
+	if (_uart_index(uart->uart_com) == SHARK_UART0) {
+		rcu_periph_clock_enable(SHARK_UART0_clk);
+		rcu_periph_clock_enable(SHARK_UART0_rx_gpio_clk);
+		rcu_periph_clock_enable(SHARK_UART0_tx_gpio_clk);
+		gpio_af_set(SHARK_UART0_tx_port, GPIO_AF_0,SHARK_UART0_tx_pin);
+		gpio_mode_set(SHARK_UART0_tx_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, SHARK_UART0_tx_pin);
+		gpio_output_options_set(SHARK_UART0_tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, SHARK_UART0_tx_pin);
+		gpio_af_set(SHARK_UART0_rx_port, GPIO_AF_0,SHARK_UART0_rx_pin);
+		gpio_mode_set(SHARK_UART0_rx_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, SHARK_UART0_rx_pin);
+		gpio_output_options_set(SHARK_UART0_rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,SHARK_UART0_rx_pin);
+	}else {
+		rcu_periph_clock_enable(SHARK_UART1_clk);
+		rcu_periph_clock_enable(SHARK_UART1_rx_gpio_clk);
+		rcu_periph_clock_enable(SHARK_UART1_tx_gpio_clk);
+		gpio_af_set(SHARK_UART1_tx_port, GPIO_AF_1,SHARK_UART1_tx_pin);
+		gpio_mode_set(SHARK_UART1_tx_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, SHARK_UART1_tx_pin);
+		gpio_output_options_set(SHARK_UART1_tx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, SHARK_UART1_tx_pin);
+		gpio_af_set(SHARK_UART1_rx_port, GPIO_AF_1,SHARK_UART1_rx_pin);
+		gpio_mode_set(SHARK_UART1_rx_port, GPIO_MODE_AF, GPIO_PUPD_PULLUP, SHARK_UART1_rx_pin);
+		gpio_output_options_set(SHARK_UART1_rx_port, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,SHARK_UART1_rx_pin);
+	}
 
-	/* configure peripheral increasing mode */
-	DMA_CHCTL(channelx) &= ~DMA_CHXCTL_PNAGA;
+}
 
-	/* configure memory increasing mode */
-	DMA_CHCTL(channelx) |= DMA_CHXCTL_MNAGA;
+static void shark_uart_device_init(shark_uart_t *uart){
+	usart_deinit(uart->uart_com);
+	usart_baudrate_set(uart->uart_com, SHARK_UART_BAUDRATE);
 
-	/* configure the direction of data transfer */
-	if (DMA_PERIPHERAL_TO_MEMORY == direction) {
-		DMA_CHCTL(channelx) &= ~DMA_CHXCTL_DIR;
-	} else {
-		DMA_CHCTL(channelx) |= DMA_CHXCTL_DIR;
-	}
+	usart_word_length_set(uart->uart_com, USART_WL_8BIT);
+	usart_stop_bit_set(uart->uart_com, USART_STB_1BIT);
+	usart_parity_config(uart->uart_com, USART_PM_NONE);
+	usart_hardware_flow_rts_config(uart->uart_com, USART_RTS_DISABLE);
+	usart_hardware_flow_cts_config(uart->uart_com, USART_CTS_DISABLE);
+	usart_receive_config(uart->uart_com, USART_RECEIVE_ENABLE);
+	usart_transmit_config(uart->uart_com, USART_TRANSMIT_ENABLE);
+	
 }
 
-
 static u32 shark_uart_handler(void)
 {
 	shark_uart_t *uart = _shark_uart + SHARK_UART0;
@@ -228,6 +271,7 @@ static u8 *tx_cache_addr(uart_enum_t uart_no){
 void shark_uart_deinit(uart_enum_t uart_no){
 	shark_uart_t *uart = _shark_uart + uart_no;
 	if (uart->uart_com != 0) {
+		usart_disable(uart->uart_com);
 		usart_deinit(uart->uart_com);
 		rcu_periph_clock_enable(uart_no == SHARK_UART0?SHARK_UART0_clk:SHARK_UART1_clk);
 		dma_channel_disable(uart->rx_dma_ch);
@@ -258,47 +302,12 @@ void shark_uart_init(uart_enum_t uart_no)
 	uart->rx_dma_ch = (uart_no == SHARK_UART0)?SHARK_UART0_rx_dma_ch:SHARK_UART1_rx_dma_ch;
 	uart->tx_dma_ch = (uart_no == SHARK_UART0)?SHARK_UART0_tx_dma_ch:SHARK_UART1_tx_dma_ch;
 
-	if (uart_no == SHARK_UART0) {
-		rcu_periph_clock_enable(SHARK_UART0_clk);
-		rcu_periph_clock_enable(SHARK_UART0_rx_gpio_clk);
-		rcu_periph_clock_enable(SHARK_UART0_tx_gpio_clk);
-
-		gpio_mode_set(SHARK_UART0_tx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, SHARK_UART0_tx_pin);
-		gpio_mode_set(SHARK_UART0_rx_port, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, SHARK_UART0_rx_pin);
-	}else {
-		rcu_periph_clock_enable(SHARK_UART1_clk);
-		rcu_periph_clock_enable(SHARK_UART1_rx_gpio_clk);
-		rcu_periph_clock_enable(SHARK_UART1_tx_gpio_clk);
-
-		gpio_mode_set(SHARK_UART1_tx_port, GPIO_MODE_AF, GPIO_PUPD_NONE, SHARK_UART1_tx_pin);
-		gpio_mode_set(SHARK_UART1_rx_port, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, SHARK_UART1_rx_pin);
-
-	}
-	
-	usart_deinit(uart->uart_com);
-	usart_baudrate_set(uart->uart_com, SHARK_UART_BAUDRATE);
-
-	usart_word_length_set(uart->uart_com, USART_WL_8BIT);
-	usart_stop_bit_set(uart->uart_com, USART_STB_1BIT);
-	usart_parity_config(uart->uart_com, USART_PM_NONE);
-	usart_hardware_flow_rts_config(uart->uart_com, USART_RTS_DISABLE);
-	usart_hardware_flow_cts_config(uart->uart_com, USART_CTS_DISABLE);
-	usart_receive_config(uart->uart_com, USART_RECEIVE_ENABLE);
-	usart_transmit_config(uart->uart_com, USART_TRANSMIT_ENABLE);
-
-	
-	rcu_periph_clock_enable(uart_no == SHARK_UART0?SHARK_UART0_tx_dma_clk:SHARK_UART1_tx_dma_clk);
-	shark_uart_dma_init(uart->tx_dma_ch, DMA_MEMORY_TO_PERIPHERAL, uart->uart_com + 0x04, tx_cache_addr(uart_no), 0);
-	dma_circulation_disable(uart->tx_dma_ch);
-	usart_dma_transmit_config(uart->uart_com, USART_DENT_ENABLE);
-
-	rcu_periph_clock_enable(uart_no == SHARK_UART0?SHARK_UART0_rx_dma_clk:SHARK_UART1_rx_dma_clk);
-	shark_uart_dma_init(uart->rx_dma_ch, DMA_PERIPHERAL_TO_MEMORY, uart->uart_com + 0x04, shark_uart_rx_cache, SHARK_UART_TX_MEM_SIZE);
-	dma_circulation_enable(uart->rx_dma_ch);
-	dma_channel_enable(uart->rx_dma_ch);
-	usart_dma_receive_config(uart->uart_com, USART_DENR_ENABLE);
-
+	shark_uart_pin_init(uart);
+	shark_uart_device_init(uart);
+	shark_uart_rx_dma_init(uart);
+	shark_uart_tx_dma_init(uart);
 	usart_enable(uart->uart_com);
+	
 	if (_uart_task.handler == NULL) {
 		_uart_task.handler = shark_uart_handler;
 		shark_task_add(&_uart_task);
@@ -367,3 +376,19 @@ void shark_uart_write_frame(uart_enum_t uart_no, uint8_t *bytes, int len){
 	shark_uart_tx_end(uart);
 }
 
+void shark_uart_frame_start(uart_enum_t uart_no, uint8_t *bytes, int len){
+	shark_uart_t *uart = _shark_uart + uart_no;
+	shark_uart_tx_start(uart);
+	shark_uart_tx_continue(uart, bytes, len);
+}
+
+void shark_uart_frame_continue(uart_enum_t uart_no, uint8_t *bytes, int len){
+	shark_uart_t *uart = _shark_uart + uart_no;
+	shark_uart_tx_continue(uart, bytes, len);
+}
+
+void shark_uart_frame_end(uart_enum_t uart_no){
+	shark_uart_tx_end(_shark_uart + uart_no);
+}
+
+

Application/bsp/uart.h

@@ -40,4 +40,9 @@ typedef struct {
 void shark_uart_init(uart_enum_t uart_no);
 void shark_uart_deinit(uart_enum_t uart_no);
 void shark_uart_write_frame(uart_enum_t uart_no, uint8_t *bytes, int len);
+void shark_uart_frame_start(uart_enum_t uart_no, uint8_t *bytes, int len);
+void shark_uart_frame_continue(uart_enum_t uart_no, uint8_t *bytes, int len);
+void shark_uart_frame_end(uart_enum_t uart_no);
+
+
 

Application/libs/logger.c

@@ -50,16 +50,16 @@ void log_error(int mod, char *fmt, ...){
 }
 //rewrite the fputc, so that the printf,vprintf can log the info the can
 static uint8_t log_buffer[64];
-static int log_index = sizeof(can_head_t);
+static int log_index = 0;
 int fputc(int c, FILE *fp){
 	if (c == '\n'){ //don't send '\n'
-		if ((log_index - sizeof(can_head_t)) != 0){
+		if (log_index != 0){
 			protocol_send_debug_info(0x72, log_buffer, log_index);
 		}
-		log_index = sizeof(can_head_t);
-	}else if (log_index == sizeof(log_buffer)){
+		log_index = 0;
+	}else if (log_index == 64){
 		protocol_send_debug_info(0x70 ,log_buffer, log_index);
-		log_index = sizeof(can_head_t);
+		log_index = 0;
 		log_buffer[log_index++] = c;
 	}else{
 		log_buffer[log_index++] = c;

Application/libs/logger.h

@@ -3,9 +3,9 @@
 #include <stdarg.h>
 
 #define L_disable 0
-#define L_debug  1
-#define L_warning 2
-#define L_error 3
+#define L_debug  3
+#define L_warning 1
+#define L_error 1
 
 #define LEVEL_MASK 0x03
 
@@ -27,24 +27,24 @@ extern void log_warning(int mod, char *fmt, ...);
 extern void log_error(int mod, char *fmt, ...);
 
 /* logger functions */
-#define io_debug(fmt, args...) log_debug(MOD_IO, "[IO:D]"fmt, ##args)
-#define io_warning(fmt, args...) log_warning(MOD_IO, "[IO:W]"fmt, ##args)
-#define io_error(fmt, args...) log_error(MOD_IO, "[IO:E]"fmt, ##args)
+#define io_debug(fmt, args...) log_debug(MOD_IO, "D"fmt, ##args)
+#define io_warning(fmt, args...) log_warning(MOD_IO, "W"fmt, ##args)
+#define io_error(fmt, args...) log_error(MOD_IO, "E"fmt, ##args)
 
-#define health_debug(fmt, args...) log_debug(MOD_HEALTH, "[HEALTH:D]"fmt, ##args)
-#define health_warning(fmt, args...) log_warning(MOD_HEALTH, "[HEALTH:W]"fmt, ##args)
-#define health_error(fmt, args...) log_error(MOD_HEALTH, "[HEALTH:E]"fmt, ##args)
+#define health_debug(fmt, args...) log_debug(MOD_HEALTH, "D"fmt, ##args)
+#define health_warning(fmt, args...) log_warning(MOD_HEALTH, "W"fmt, ##args)
+#define health_error(fmt, args...) log_error(MOD_HEALTH, "E"fmt, ##args)
 
-#define measure_debug(fmt, args...) log_debug(MOD_MEASURE, "[MEASURE:D]"fmt, ##args)
-#define measure_warning(fmt, args...) log_warning(MOD_MEASURE, "[MEASURE:W]"fmt, ##args)
-#define measure_error(fmt, args...) log_error(MOD_MEASURE, "[MEASURE:E]"fmt, ##args)
+#define measure_debug(fmt, args...) log_debug(MOD_MEASURE, "D"fmt, ##args)
+#define measure_warning(fmt, args...) log_warning(MOD_MEASURE, "W"fmt, ##args)
+#define measure_error(fmt, args...) log_error(MOD_MEASURE, "E"fmt, ##args)
 
-#define state_debug(fmt, args...) log_debug(MOD_STATE, "[STATE:D]"fmt, ##args)
-#define state_warning(fmt, args...) log_warning(MOD_STATE, "[STATE:W]"fmt, ##args)
-#define state_error(fmt, args...) log_error(MOD_STATE, fmt, "[STATE:E]"##args)
+#define state_debug(fmt, args...) log_debug(MOD_STATE, "D"fmt, ##args)
+#define state_warning(fmt, args...) log_warning(MOD_STATE, "W"fmt, ##args)
+#define state_error(fmt, args...) log_error(MOD_STATE, fmt, "E"##args)
 
-#define sys_debug(fmt, args...) log_debug(MOD_SYSTEM, fmt, "[SYS:D]"##args)
-#define sys_warning(fmt, args...) log_warning(MOD_SYSTEM, "[SYS:W]"fmt, ##args)
-#define sys_error(fmt, args...) log_error(MOD_SYSTEM, fmt, "[SYS:E]"##args)
+#define sys_debug(fmt, args...) log_debug(MOD_SYSTEM, fmt, "D"##args)
+#define sys_warning(fmt, args...) log_warning(MOD_SYSTEM, "W"fmt, ##args)
+#define sys_error(fmt, args...) log_error(MOD_SYSTEM, fmt, "E"##args)
 #endif /* _Shark_Logger_h__ */