1. Introduction to Zorb
The Zorb Framework is a lightweight embedded framework built on the principles of object-oriented design.
The purpose of building the Zorb Framework is to enable rapid application development on chips that cannot run Linux, avoiding the need to reinvent the wheel.
The initial design features of the Zorb Framework include:
1. Time system functionality zf_time
2. Circular buffer functionality zf_buffer
3. List functionality zf_list
4. Finite state machine functionality zf_fsm
5. Event functionality zf_event
6. Timer functionality zf_timer
The first six functionalities can achieve pure event-driven programming and generally meet the development needs of small to medium-sized embedded applications. The addition of task functionality is to satisfy certain programs that require high real-time performance.
Of course, the first six functionalities can also be trimmed out and run on existing embedded systems, which can also meet real-time requirements.
2. Setting Up the Embedded Environment
We use the STM32F429 development board as the hardware runtime environment, utilizing hardware resources from UART1 and SysTick, where UART1 provides debugging print functionality, and SysTick provides system time counting functionality.
There is not much to say about setting up the hardware environment; you can refer to the examples provided by the development board to set it up. The board-level initialization has completed the debugging UART and SysTick initialization.
/******************************************************************************
* Description: Hardware environment initialization
* Parameters: None
* Return: None
******************************************************************************/
void BSP_init(void)
{
/* Select the group for nested vector interrupt controller */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
/* Initialize debugging UART */
Debug_USART_init();
/* SysTick initialization */
SystemTick_init();
}
/******************************************************************************
* Description: Low-level hardware program
* Parameters: None
* Return: None
******************************************************************************/
void BSP_process(void)
{
}
3. Debug Output
When developing a program, the first and most important step is to set up a debugging environment. We use UART1 as the debugging output (mapped to printf), and then categorize the debugging information into three levels, which can be highlighted by the upper computer based on different levels:
/**
*****************************************************************************
* @file zf_debug.h
* @author Zorb
* @version V1.0.0
* @date 2018-06-28
* @brief Header file for debugging output
*****************************************************************************
* @history
*
* 1. Date:2018-06-28
* Author:Zorb
* Modification: Created file
*
*****************************************************************************
*/
#ifndef __ZF_DEBUG_H__
#define __ZF_DEBUG_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "stdio.h"
#include "stdbool.h"
#define LOG_D 0; /* Info level: Normal */
#define LOG_W 1; /* Info level: Warning */
#define LOG_E 2; /* Info level: Error */
#define _ZF_DEBUG /* Define debugging functionality */
#define ZF_DEBUG_ON true /* Enable debugging functionality */
#ifdef _ZF_DEBUG
#if ZF_DEBUG_ON
#define ZF_DEBUG(rank, x...) do \
{ \
char code[10] = "[rank=0]"; \
code[6] = '0' + (char)rank; \
if (code[6] != '0') \
{ \
printf("%s", code); \
} \
printf(x); \
} while(0)
#else
#define ZF_DEBUG(rank, x...)
#endif /* ZF_DEBUG_ON */
#endif /* _ZF_DEBUG */
#ifdef __cplusplus
}
#endif
#endif /* __ZF_DEBUG_H__ */
/******************************** END OF FILE ********************************/
4. Implementing Assertions
During development, placing assertions in key locations can facilitate bug location.
/**
*****************************************************************************
* @file zf_assert.h
* @author Zorb
* @version V1.0.0
* @date 2018-06-28
* @brief Header file for assertions
*****************************************************************************
* @history
*
* 1. Date:2018-06-28
* Author:Zorb
* Modification: Created file
*
*****************************************************************************
*/
#ifndef __ZF_ASSERT_H__
#define __ZF_ASSERT_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "stdint.h"
#define _ZF_ASSERT /* Define assertion functionality */
#define ZF_ASSERT_ON true /* Enable assertion functionality */
#ifdef _ZF_ASSERT
#if ZF_ASSERT_ON
#define ZF_ASSERT(expression_) ((expression_) ?\
(void)0 : ZF_assertHandle((uint8_t *)__FILE__, (int)__LINE__));
#else
#define ZF_ASSERT(expression_)
#endif /* ZF_ASSERT_ON */
#endif /* _ZF_ASSERT */
/* Handling when an assertion occurs */
void ZF_assertHandle(uint8_t *pFileName, int line);
#ifdef __cplusplus
}
#endif
#endif /* __ZF_ASSERT_H__ */
/******************************** END OF FILE ********************************/
The handling of assertions is simple; it just tells us which file and line the error occurred in, implemented as follows:
/**
*****************************************************************************
* @file zf_assert.c
* @author Zorb
* @version V1.0.0
* @date 2018-06-28
* @brief Implementation of assertions
*****************************************************************************
* @history
*
* 1. Date:2018-06-28
* Author:Zorb
* Modification: Created file
*
*****************************************************************************
*/
#include "zf_assert.h"
#include "zf_debug.h"
/******************************************************************************
* Description: Handling when an assertion occurs
* Parameters: (in)-pFileName File name
* (in)-line Line number
* Return: None
******************************************************************************/
void ZF_assertHandle(uint8_t *pFileName, int line)
{
ZF_DEBUG(LOG_E, "file:%s line:%d:asserted\r\n", pFileName, line);
while (1);
}
/******************************** END OF FILE ********************************/
5. Establishing a Time System
To reduce the framework’s resource consumption, we initially set the minimum time cycle of the framework to 1ms, so we need to set the SysTick timer period to 1ms, and then count for our framework each time an interrupt occurs.
/******************************************************************************
* Description: SysTick interrupt service routine
* Parameters: None
* Return: None
******************************************************************************/
void SysTick_Handler(void)
{
/* Provide timing for the zorb framework */
ZF_timeTick();
}
The functionality provided by the time system is currently basic, with only system tick counting and system blocking delay. We will expand the time system when developing timer functionality and task functionality.
/**
*****************************************************************************
* @file zf_time.h
* @author Zorb
* @version V1.0.0
* @date 2018-06-28
* @brief Header file for system time
*****************************************************************************
* @history
*
* 1. Date:2018-06-28
* Author:Zorb
* Modification: Created file
*
*****************************************************************************
*/
#ifndef __ZF_TIME_H__
#define __ZF_TIME_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "stdbool.h"
#include "stdint.h"
/* System tick period (ms) */
#define ZF_TICK_PERIOD 1
/* Get system tick count */
#define ZF_SYSTICK() ZF_getSystemTick()
/* Get system time (ms) */
#define ZF_SYSTIME_MS() ZF_getSystemTimeMS()
/* System delay (ms) */
#define ZF_DELAY_MS(ms_) do \
{ \
if (ms_ % ZF_TICK_PERIOD) \
{ \
ZF_delayTick((ms_ / ZF_TICK_PERIOD) + 1); \
} \
else \
{ \
ZF_delayTick(ms_ / ZF_TICK_PERIOD); \
} \
} while(0)
/* Get system tick count */
uint32_t ZF_getSystemTick(void);
/* Get system time (ms) */
uint32_t ZF_getSystemTimeMS(void);
/* System delay */
void ZF_delayTick(uint32_t tick);
/* System tick program (needs to be hooked into hardware time interrupt) */
void ZF_timeTick (void);
#ifdef __cplusplus
}
#endif
#endif /* __ZF_TIME_H__ */
/******************************** END OF FILE ********************************/
6. Conclusion
The functionalities implemented in this article are quite basic, yet they lay the foundation for the development of the entire framework. All subsequent extended functionalities will need to be developed within this environment.
Establishing a good debugging output environment can help us quickly locate the source of bugs, thereby improving development efficiency.
Github Address
https://github.com/54zorb/Zorb-Framework
Source: https://github.com/54zorb/Zorb-Framework
This article is published by Together Playing Embedded, copyright belongs to the original author. If there is any infringement, please contact for deletion.
Lastly,
The author has gathered some embedded learning materials,
Reply 【1024】 in the public account to get the download link~
Recommended good articles, click on the blue text to jump:
☞ Collection | Comprehensive Programming in Linux Applications
☞ Collection | Learn Some Network Knowledge
☞ Collection | Handwritten C Language
☞ Collection | Handwritten C++ Language
☞ Collection | Experience Sharing
☞ Collection | From Microcontrollers to Linux
☞ Collection | Power Control Technology
☞ Collection | Essential Mathematics for Embedded Systems
☞ Collection | MCU Advanced Collection
☞ Collection | Advanced Embedded C Language Collection
☞ Collection | Experience Sharing