Browse Source

update

master
zhaohe 1 year ago
parent
commit
a744dabe1f
  1. 8
      logger.h
  2. 1
      sdk.hpp
  3. 4
      stm32/critical.c
  4. 114
      zgpio.cpp
  5. 137
      zgpio.hpp
  6. 100
      zthread.cpp
  7. 58
      zthread.hpp

8
logger.h

@ -2,6 +2,10 @@
#include <stdbool.h>
#include <stdio.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "cmsis_os.h"
#include "main.h"
extern bool g_enable_log;
@ -53,3 +57,7 @@ void zlog(const char* fmt, ...);
void zlog_raw(const char* info);
void zlog_init(UART_HandleTypeDef* huart);
void zlog_enable(bool enable);
#ifdef __cplusplus
}
#endif

1
sdk.hpp

@ -8,4 +8,5 @@ extern "C" {
#include "mutex.hpp"
#include "ticket.hpp"
#include "critical_context.hpp"
#include "zthread.hpp"
void sdkinit();

4
stm32/critical.c

@ -1,13 +1,13 @@
#include "main.h"
static uint8_t g_port_exit_critical_count;
void chip_critical_enter(void) {
void stm32_critical_enter(void) {
if (g_port_exit_critical_count == 0) {
__disable_irq();
}
g_port_exit_critical_count++;
}
void chip_critical_exit(void) {
void stm32_critical_exit(void) {
g_port_exit_critical_count--;
if (g_port_exit_critical_count == 0) {
__enable_irq();

114
zgpio.cpp

@ -373,3 +373,117 @@ IRQn_Type ZGPIO::getEXTIIRQn() {
*/
} // namespace iflytop
using namespace iflytop;
ZGPIO IO_PA0(PA0);
ZGPIO IO_PA1(PA1);
ZGPIO IO_PA2(PA2);
ZGPIO IO_PA3(PA3);
ZGPIO IO_PA4(PA4);
ZGPIO IO_PA5(PA5);
ZGPIO IO_PA6(PA6);
ZGPIO IO_PA7(PA7);
ZGPIO IO_PA8(PA8);
ZGPIO IO_PA9(PA9);
ZGPIO IO_PA10(PA10);
ZGPIO IO_PA11(PA11);
ZGPIO IO_PA12(PA12);
ZGPIO IO_PA13(PA13);
ZGPIO IO_PA14(PA14);
ZGPIO IO_PA15(PA15);
ZGPIO IO_PB0(PB0);
ZGPIO IO_PB1(PB1);
ZGPIO IO_PB2(PB2);
ZGPIO IO_PB3(PB3);
ZGPIO IO_PB4(PB4);
ZGPIO IO_PB5(PB5);
ZGPIO IO_PB6(PB6);
ZGPIO IO_PB7(PB7);
ZGPIO IO_PB8(PB8);
ZGPIO IO_PB9(PB9);
ZGPIO IO_PB10(PB10);
ZGPIO IO_PB11(PB11);
ZGPIO IO_PB12(PB12);
ZGPIO IO_PB13(PB13);
ZGPIO IO_PB14(PB14);
ZGPIO IO_PB15(PB15);
ZGPIO IO_PC0(PC0);
ZGPIO IO_PC1(PC1);
ZGPIO IO_PC2(PC2);
ZGPIO IO_PC3(PC3);
ZGPIO IO_PC4(PC4);
ZGPIO IO_PC5(PC5);
ZGPIO IO_PC6(PC6);
ZGPIO IO_PC7(PC7);
ZGPIO IO_PC8(PC8);
ZGPIO IO_PC9(PC9);
ZGPIO IO_PC10(PC10);
ZGPIO IO_PC11(PC11);
ZGPIO IO_PC12(PC12);
ZGPIO IO_PC13(PC13);
ZGPIO IO_PC14(PC14);
ZGPIO IO_PC15(PC15);
ZGPIO IO_PD0(PD0);
ZGPIO IO_PD1(PD1);
ZGPIO IO_PD2(PD2);
ZGPIO IO_PD3(PD3);
ZGPIO IO_PD4(PD4);
ZGPIO IO_PD5(PD5);
ZGPIO IO_PD6(PD6);
ZGPIO IO_PD7(PD7);
ZGPIO IO_PD8(PD8);
ZGPIO IO_PD9(PD9);
ZGPIO IO_PD10(PD10);
ZGPIO IO_PD11(PD11);
ZGPIO IO_PD12(PD12);
ZGPIO IO_PD13(PD13);
ZGPIO IO_PD14(PD14);
ZGPIO IO_PD15(PD15);
ZGPIO IO_PE0(PE0);
ZGPIO IO_PE1(PE1);
ZGPIO IO_PE2(PE2);
ZGPIO IO_PE3(PE3);
ZGPIO IO_PE4(PE4);
ZGPIO IO_PE5(PE5);
ZGPIO IO_PE6(PE6);
ZGPIO IO_PE7(PE7);
ZGPIO IO_PE8(PE8);
ZGPIO IO_PE9(PE9);
ZGPIO IO_PE10(PE10);
ZGPIO IO_PE11(PE11);
ZGPIO IO_PE12(PE12);
ZGPIO IO_PE13(PE13);
ZGPIO IO_PE14(PE14);
ZGPIO IO_PE15(PE15);
ZGPIO IO_PF0(PF0);
ZGPIO IO_PF1(PF1);
ZGPIO IO_PF2(PF2);
ZGPIO IO_PF3(PF3);
ZGPIO IO_PF4(PF4);
ZGPIO IO_PF5(PF5);
ZGPIO IO_PF6(PF6);
ZGPIO IO_PF7(PF7);
ZGPIO IO_PF8(PF8);
ZGPIO IO_PF9(PF9);
ZGPIO IO_PF10(PF10);
ZGPIO IO_PF11(PF11);
ZGPIO IO_PF12(PF12);
ZGPIO IO_PF13(PF13);
ZGPIO IO_PF14(PF14);
ZGPIO IO_PF15(PF15);
ZGPIO IO_PG0(PG0);
ZGPIO IO_PG1(PG1);
ZGPIO IO_PG2(PG2);
ZGPIO IO_PG3(PG3);
ZGPIO IO_PG4(PG4);
ZGPIO IO_PG5(PG5);
ZGPIO IO_PG6(PG6);
ZGPIO IO_PG7(PG7);
ZGPIO IO_PG8(PG8);
ZGPIO IO_PG9(PG9);
ZGPIO IO_PG10(PG10);
ZGPIO IO_PG11(PG11);
ZGPIO IO_PG12(PG12);
ZGPIO IO_PG13(PG13);
ZGPIO IO_PG14(PG14);
ZGPIO IO_PG15(PG15);

137
zgpio.hpp

@ -1,6 +1,10 @@
#pragma once
#include <functional>
#include "stm32/stm32.hpp"
extern "C" {
#include "logger.h"
}
namespace iflytop {
using namespace std;
@ -58,9 +62,14 @@ class ZGPIO {
onirq_t m_onirq;
bool m_initflag;
bool m_preset_pin = false;
public:
ZGPIO(){};
ZGPIO(Pin_t pin) {
m_pin = pin;
m_preset_pin = true;
};
void initAsInput(Pin_t pin, GPIOMode_t mode, GPIOIrqType_t irqtype, bool mirror);
void initAsOutput(Pin_t pin, GPIOMode_t mode, bool mirror, bool initLevel);
@ -69,6 +78,18 @@ class ZGPIO {
initAsOutput(outputcfg->pin, outputcfg->mode, outputcfg->mirror, outputcfg->initLevel);
}
void initAsInput(InputGpioCfg_t *inputcfg) { initAsInput(inputcfg->pin, inputcfg->mode, inputcfg->irqtype, inputcfg->mirror); }
void initAsInput(GPIOMode_t mode, GPIOIrqType_t irqtype, bool mirror) {
ZASSERT(m_preset_pin);
initAsInput(m_pin, mode, irqtype, mirror);
}
void initAsOutput(GPIOMode_t mode, bool mirror, bool initLevel) {
ZASSERT(m_preset_pin);
initAsOutput(m_pin, mode, mirror, initLevel);
}
void enableTrace(bool enable) { m_log_when_setstate = enable; }
void regListener(onirq_t listener);
@ -97,4 +118,118 @@ class ZGPIO {
private:
bool enableClock();
};
} // namespace iflytop
} // namespace iflytop
extern iflytop::ZGPIO IO_PA0;
extern iflytop::ZGPIO IO_PA1;
extern iflytop::ZGPIO IO_PA2;
extern iflytop::ZGPIO IO_PA3;
extern iflytop::ZGPIO IO_PA4;
extern iflytop::ZGPIO IO_PA5;
extern iflytop::ZGPIO IO_PA6;
extern iflytop::ZGPIO IO_PA7;
extern iflytop::ZGPIO IO_PA8;
extern iflytop::ZGPIO IO_PA9;
extern iflytop::ZGPIO IO_PA10;
extern iflytop::ZGPIO IO_PA11;
extern iflytop::ZGPIO IO_PA12;
extern iflytop::ZGPIO IO_PA13;
extern iflytop::ZGPIO IO_PA14;
extern iflytop::ZGPIO IO_PA15;
extern iflytop::ZGPIO IO_PB0;
extern iflytop::ZGPIO IO_PB1;
extern iflytop::ZGPIO IO_PB2;
extern iflytop::ZGPIO IO_PB3;
extern iflytop::ZGPIO IO_PB4;
extern iflytop::ZGPIO IO_PB5;
extern iflytop::ZGPIO IO_PB6;
extern iflytop::ZGPIO IO_PB7;
extern iflytop::ZGPIO IO_PB8;
extern iflytop::ZGPIO IO_PB9;
extern iflytop::ZGPIO IO_PB10;
extern iflytop::ZGPIO IO_PB11;
extern iflytop::ZGPIO IO_PB12;
extern iflytop::ZGPIO IO_PB13;
extern iflytop::ZGPIO IO_PB14;
extern iflytop::ZGPIO IO_PB15;
extern iflytop::ZGPIO IO_PC0;
extern iflytop::ZGPIO IO_PC1;
extern iflytop::ZGPIO IO_PC2;
extern iflytop::ZGPIO IO_PC3;
extern iflytop::ZGPIO IO_PC4;
extern iflytop::ZGPIO IO_PC5;
extern iflytop::ZGPIO IO_PC6;
extern iflytop::ZGPIO IO_PC7;
extern iflytop::ZGPIO IO_PC8;
extern iflytop::ZGPIO IO_PC9;
extern iflytop::ZGPIO IO_PC10;
extern iflytop::ZGPIO IO_PC11;
extern iflytop::ZGPIO IO_PC12;
extern iflytop::ZGPIO IO_PC13;
extern iflytop::ZGPIO IO_PC14;
extern iflytop::ZGPIO IO_PC15;
extern iflytop::ZGPIO IO_PD0;
extern iflytop::ZGPIO IO_PD1;
extern iflytop::ZGPIO IO_PD2;
extern iflytop::ZGPIO IO_PD3;
extern iflytop::ZGPIO IO_PD4;
extern iflytop::ZGPIO IO_PD5;
extern iflytop::ZGPIO IO_PD6;
extern iflytop::ZGPIO IO_PD7;
extern iflytop::ZGPIO IO_PD8;
extern iflytop::ZGPIO IO_PD9;
extern iflytop::ZGPIO IO_PD10;
extern iflytop::ZGPIO IO_PD11;
extern iflytop::ZGPIO IO_PD12;
extern iflytop::ZGPIO IO_PD13;
extern iflytop::ZGPIO IO_PD14;
extern iflytop::ZGPIO IO_PD15;
extern iflytop::ZGPIO IO_PE0;
extern iflytop::ZGPIO IO_PE1;
extern iflytop::ZGPIO IO_PE2;
extern iflytop::ZGPIO IO_PE3;
extern iflytop::ZGPIO IO_PE4;
extern iflytop::ZGPIO IO_PE5;
extern iflytop::ZGPIO IO_PE6;
extern iflytop::ZGPIO IO_PE7;
extern iflytop::ZGPIO IO_PE8;
extern iflytop::ZGPIO IO_PE9;
extern iflytop::ZGPIO IO_PE10;
extern iflytop::ZGPIO IO_PE11;
extern iflytop::ZGPIO IO_PE12;
extern iflytop::ZGPIO IO_PE13;
extern iflytop::ZGPIO IO_PE14;
extern iflytop::ZGPIO IO_PE15;
extern iflytop::ZGPIO IO_PF0;
extern iflytop::ZGPIO IO_PF1;
extern iflytop::ZGPIO IO_PF2;
extern iflytop::ZGPIO IO_PF3;
extern iflytop::ZGPIO IO_PF4;
extern iflytop::ZGPIO IO_PF5;
extern iflytop::ZGPIO IO_PF6;
extern iflytop::ZGPIO IO_PF7;
extern iflytop::ZGPIO IO_PF8;
extern iflytop::ZGPIO IO_PF9;
extern iflytop::ZGPIO IO_PF10;
extern iflytop::ZGPIO IO_PF11;
extern iflytop::ZGPIO IO_PF12;
extern iflytop::ZGPIO IO_PF13;
extern iflytop::ZGPIO IO_PF14;
extern iflytop::ZGPIO IO_PF15;
extern iflytop::ZGPIO IO_PG0;
extern iflytop::ZGPIO IO_PG1;
extern iflytop::ZGPIO IO_PG2;
extern iflytop::ZGPIO IO_PG3;
extern iflytop::ZGPIO IO_PG4;
extern iflytop::ZGPIO IO_PG5;
extern iflytop::ZGPIO IO_PG6;
extern iflytop::ZGPIO IO_PG7;
extern iflytop::ZGPIO IO_PG8;
extern iflytop::ZGPIO IO_PG9;
extern iflytop::ZGPIO IO_PG10;
extern iflytop::ZGPIO IO_PG11;
extern iflytop::ZGPIO IO_PG12;
extern iflytop::ZGPIO IO_PG13;
extern iflytop::ZGPIO IO_PG14;
extern iflytop::ZGPIO IO_PG15;

100
zthread.cpp

@ -0,0 +1,100 @@
#include "zthread.hpp"
#include "mutex.hpp"
#include"logger.h"
using namespace iflytop;
using namespace std;
static bool s_map_inited = false;
static ZThread g_default_thread;
static void zosthread_default_task(void const *argument) {
ZThread *thread = (ZThread *)argument;
ZASSERT(thread);
thread->threadcb();
};
void ZThread::zthread_module_init() {
if (s_map_inited) return;
s_map_inited = true;
}
void ZThread::threadcb() {
m_status = kidle;
while (true) {
if (m_threadisworkingFlagCallSide) {
m_status = kworking;
if (m_taskfunction) m_taskfunction();
if (m_taskfunction_exitcb) m_taskfunction_exitcb();
m_status = kdead;
while (m_threadisworkingFlagCallSide) {
vTaskDelay(10);
}
m_status = kidle;
}
vTaskDelay(10);
}
}
void ZThread::init(const char *threadname, int stack_size, osPriority priority) {
// int r_task_create = 0;
ZASSERT(threadname);
m_lock = xSemaphoreCreateMutex();
ZASSERT(m_lock);
m_stacksize = stack_size;
m_uxPriority = osPriorityNormal;
m_taskfunction = nullptr;
m_zthreadstartworkevent = xEventGroupCreate();
m_name = threadname;
osThreadDef(zosthread_default_task, zosthread_default_task, m_uxPriority, 0, m_stacksize);
m_defaultTaskHandle = osThreadCreate(osThread(zosthread_default_task), this);
ZASSERT(m_defaultTaskHandle != NULL);
}
void ZThread::start(zosthread_cb_t cb) { start(cb, nullptr); }
void ZThread::start(zosthread_cb_t cb, zosthread_cb_t exitcb) {
stop();
m_taskfunction = cb;
m_taskfunction_exitcb = exitcb;
ZASSERT(m_taskfunction);
xSemaphoreTake(m_lock, portMAX_DELAY);
m_threadisworkingFlagCallSide = true;
// xEventGroupSetBits(m_zthreadstartworkevent, 0x01);
while (m_status == kidle) {
xTaskNotifyGive(m_defaultTaskHandle);
vTaskDelay(1);
}
xSemaphoreGive(m_lock);
}
void ZThread::stop() {
xSemaphoreTake(m_lock, portMAX_DELAY);
m_threadisworkingFlagCallSide = false;
// xEventGroupSetBits(m_zthreadstartworkevent, 0x01);
while (m_status != kidle) {
xTaskNotifyGive(m_defaultTaskHandle);
vTaskDelay(1);
}
xSemaphoreGive(m_lock);
}
void ZThread::sleep(uint32_t ms) { ulTaskNotifyTake(pdFALSE, pdMS_TO_TICKS(ms)); }
void ZThread::wake() {
BaseType_t state;
if (xPortIsInsideInterrupt()) {
vTaskNotifyGiveFromISR(m_defaultTaskHandle, &state);
} else {
xTaskNotifyGive(m_defaultTaskHandle);
}
}

58
zthread.hpp

@ -0,0 +1,58 @@
#pragma once
#include <functional>
extern "C" {
#include "cmsis_os.h"
}
namespace iflytop {
using namespace std;
typedef function<void()> zosthread_cb_t;
class ZThread {
public:
typedef enum {
kidle,
kworking,
kdead,
} status_t;
const char* m_name;
uint32_t m_stacksize;
osPriority m_uxPriority;
status_t m_status = kidle;
bool m_threadisworkingFlagCallSide = false;
zosthread_cb_t m_taskfunction;
zosthread_cb_t m_taskfunction_exitcb;
EventGroupHandle_t m_zthreadstartworkevent;
osThreadId m_defaultTaskHandle;
SemaphoreHandle_t m_lock;
public:
/**
* @brief init in zos.cpp, called by zos_init
*/
static void zthread_module_init();
void init(const char* threadname, int stack_size = 512, osPriority priority = osPriorityNormal);
void start(zosthread_cb_t cb);
void start(zosthread_cb_t cb, zosthread_cb_t exitcb);
void stop();
bool getExitFlag() { return !m_threadisworkingFlagCallSide; }
bool isworking() { return m_status == kworking; }
void wake();
static void sleep(uint32_t ms);
public:
void threadcb();
};
} // namespace iflytop
Loading…
Cancel
Save