From 2a87ed7595d298a192f53d279233f939a168ceae Mon Sep 17 00:00:00 2001 From: graduateDesign Date: Fri, 1 Oct 2021 20:00:15 +0800 Subject: [PATCH] add package --- package/PikaPiZero/PikaPiZero.py | 21 + package/PikaPiZero/PikaPiZero_RGB.c | 95 +++++ package/PikaPiZero/RGB_ASM.c | 38 ++ package/PikaPiZero/RGB_ASM.h | 3 + package/PikaPiZero/RGB_ASM.lib | Bin 0 -> 4380 bytes package/PikaStdDevice/PikaStdDeivce_GPIO.c | 80 ++++ package/PikaStdDevice/PikaStdDevice.py | 149 +++++++ package/PikaStdDevice/PikaStdDevice_ADC.c | 30 ++ package/PikaStdDevice/PikaStdDevice_PWM.c | 52 +++ package/PikaStdDevice/PikaStdDevice_Time.c | 11 + package/PikaStdDevice/PikaStdDevice_UART.c | 40 ++ package/PikaStdLib/PikaStdLib.py | 27 ++ package/PikaStdLib/PikaStdLib_MemChecker.c | 14 + package/PikaStdLib/PikaStdLib_SysObj.c | 98 +++++ package/STM32/STM32.py | 71 ++++ package/STM32/STM32_ADC.c | 167 ++++++++ package/STM32/STM32_Code.c | 137 +++++++ package/STM32/STM32_GPIO.c | 142 +++++++ package/STM32/STM32_PWM.c | 366 +++++++++++++++++ package/STM32/STM32_Time.c | 14 + package/STM32/STM32_UART.c | 434 +++++++++++++++++++++ package/STM32/STM32_common.c | 161 ++++++++ package/STM32/STM32_common.h | 75 ++++ packages/packages.toml | 3 - 24 files changed, 2225 insertions(+), 3 deletions(-) create mode 100644 package/PikaPiZero/PikaPiZero.py create mode 100644 package/PikaPiZero/PikaPiZero_RGB.c create mode 100644 package/PikaPiZero/RGB_ASM.c create mode 100644 package/PikaPiZero/RGB_ASM.h create mode 100644 package/PikaPiZero/RGB_ASM.lib create mode 100644 package/PikaStdDevice/PikaStdDeivce_GPIO.c create mode 100644 package/PikaStdDevice/PikaStdDevice.py create mode 100644 package/PikaStdDevice/PikaStdDevice_ADC.c create mode 100644 package/PikaStdDevice/PikaStdDevice_PWM.c create mode 100644 package/PikaStdDevice/PikaStdDevice_Time.c create mode 100644 package/PikaStdDevice/PikaStdDevice_UART.c create mode 100644 package/PikaStdLib/PikaStdLib.py create mode 100644 package/PikaStdLib/PikaStdLib_MemChecker.c create mode 100644 package/PikaStdLib/PikaStdLib_SysObj.c create mode 100644 package/STM32/STM32.py create mode 100644 package/STM32/STM32_ADC.c create mode 100644 package/STM32/STM32_Code.c create mode 100644 package/STM32/STM32_GPIO.c create mode 100644 package/STM32/STM32_PWM.c create mode 100644 package/STM32/STM32_Time.c create mode 100644 package/STM32/STM32_UART.c create mode 100644 package/STM32/STM32_common.c create mode 100644 package/STM32/STM32_common.h delete mode 100644 packages/packages.toml diff --git a/package/PikaPiZero/PikaPiZero.py b/package/PikaPiZero/PikaPiZero.py new file mode 100644 index 000000000..64e6c69fb --- /dev/null +++ b/package/PikaPiZero/PikaPiZero.py @@ -0,0 +1,21 @@ +from PikaObj import * +import PikaStdLib +import STM32 + +class RGB(PikaStdLib.SysObj): + pin = STM32.GPIO() + def init(): + pass + def enable(): + pass + def red(): + pass + def green(): + pass + def blue(): + pass + def white(): + pass + def flow(): + pass + diff --git a/package/PikaPiZero/PikaPiZero_RGB.c b/package/PikaPiZero/PikaPiZero_RGB.c new file mode 100644 index 000000000..140c2b953 --- /dev/null +++ b/package/PikaPiZero/PikaPiZero_RGB.c @@ -0,0 +1,95 @@ +#include "PikaPiZero_RGB.h" +#include +#include "BaseObj.h" +#include "RGB_ASM.h" +#include "STM32_common.h" +#include "dataStrs.h" + +void RGB_reset() { + GPIOB->BRR = GPIO_PIN_12; // reset + delay_us(50); +} + +#define RED 0x000100 +#define GREEN 0x010000 +#define BLUE 0x000001 +#define WHITE 0x010101 +#define CUTDOWN 0x000000 + +void RGB_setVoid() { + __asm("nop"); +} + +void PikaPiZero_RGB_enable(PikaObj* self) { + obj_run(self, "pin.init()"); + obj_run(self, "pin.setPin('PB12')"); + obj_run(self, "pin.setMode('out')"); + obj_run(self, "pin.enable()"); +} +void PikaPiZero_RGB_init(PikaObj* self) {} + +void PikaPiZero_RGB_red(PikaObj* self) { + RGB_set(RED); + RGB_set(RED); + RGB_set(RED); + RGB_set(RED); +} + +void PikaPiZero_RGB_blue(PikaObj* self) { + RGB_set(BLUE); + RGB_set(BLUE); + RGB_set(BLUE); + RGB_set(BLUE); +} + +void PikaPiZero_RGB_green(PikaObj* self) { + RGB_set(GREEN); + RGB_set(GREEN); + RGB_set(GREEN); + RGB_set(GREEN); +} + +void PikaPiZero_RGB_white(PikaObj* self) { + RGB_set(WHITE); + RGB_set(WHITE); + RGB_set(WHITE); + RGB_set(WHITE); +} + +void PikaPiZero_RGB_flow(PikaObj* self) { + if (!obj_isArgExist(self, "flowState")) { + obj_setInt(self, "flowState", 0); + } + int flowState = obj_getInt(self, "flowState"); + if (0 == flowState) { + RGB_set(RED); + RGB_set(BLUE); + RGB_set(GREEN); + RGB_set(WHITE); + goto exit; + } + if (1 == flowState) { + RGB_set(BLUE); + RGB_set(GREEN); + RGB_set(WHITE); + RGB_set(RED); + goto exit; + } + if (2 == flowState) { + RGB_set(GREEN); + RGB_set(WHITE); + RGB_set(RED); + RGB_set(BLUE); + goto exit; + } + if (3 == flowState) { + RGB_set(WHITE); + RGB_set(RED); + RGB_set(BLUE); + RGB_set(GREEN); + goto exit; + } + +exit: + obj_setInt(self, "flowState", (flowState + 1) % 4); +} \ No newline at end of file diff --git a/package/PikaPiZero/RGB_ASM.c b/package/PikaPiZero/RGB_ASM.c new file mode 100644 index 000000000..774cb37d5 --- /dev/null +++ b/package/PikaPiZero/RGB_ASM.c @@ -0,0 +1,38 @@ +#include "RGB_ASM.h" +#include "STM32_common.h" + +static void RGB_setUp() { + GPIOB->BSRR = GPIO_PIN_12; // set + int i; + i++; + i++; + i++; + i++; + i++; + i++; + i++; + i++; + GPIOB->BRR = GPIO_PIN_12; // reset +} + +static void RGB_setDown() { + GPIOB->BSRR = GPIO_PIN_12; // set + int i; + i++; + i++; + i++; + GPIOB->BRR = GPIO_PIN_12; +} + +void RGB_set(uint32_t G8R8B8) { + int i; + uint8_t byte = 0; + for (i = 23; i >= 0; i--) { + byte = ((G8R8B8 >> i) & 0x01); + if (byte) { + RGB_setUp(); + } else { + RGB_setDown(); + } + } +} \ No newline at end of file diff --git a/package/PikaPiZero/RGB_ASM.h b/package/PikaPiZero/RGB_ASM.h new file mode 100644 index 000000000..7f8309777 --- /dev/null +++ b/package/PikaPiZero/RGB_ASM.h @@ -0,0 +1,3 @@ +#include + +void RGB_set(uint32_t G8R8B8); \ No newline at end of file diff --git a/package/PikaPiZero/RGB_ASM.lib b/package/PikaPiZero/RGB_ASM.lib new file mode 100644 index 0000000000000000000000000000000000000000..fa5b0e35e4752cdb6a11c2f456d6d24daa168456 GIT binary patch literal 4380 zcmbVQYiJ}{6+XABtGko#^dy-_GLMbD!{~-_rqbzTl1yB)NvAWhC&?ys64+gP==7tK zl+!P|E7=}cb=Fz%0m{rTXOV>!{ITi}10sSC9K|2{%M}J$P;eEN_(xO?r$gT6d-#vBf+*8$g^66Z?uszi|6g^5YMQzFIH5wfrlK~r@L?kfQ(({RI!*Zy; zmCxoHWwYvm4v&q*hp&&v$FE1DD#~yyHZ}&F(fEjmw$b_7xy2hoFkFiS4Z7e`_k~@_ z7uPl75g1ZqTc#3-sWFUwMw$tIa>U(eI;` zK@3LyUzl>%@j0SLd^mE_&?DV_=OaC0y^lycL#dN`WHR)z5Rra~^vF~w1krZ_b|Rzg zHi-NuMJR+wh=DFdrcSalf#~2hH@ZUzp49myv~ie2j28+`K@6K%yw^Y7-&*Ubv(KC* z>M}_43_LF~dPF^ObPDeK%eZkLZvgq+hZ?4FS0l1L&P*G|<+~W-8T}hz0nPVuFe8P_ zdCb#J2>%sL7l9wa@M{ds5EOVzDt_S${9Y;n5e)20B`CsyKTD-UbO+v*N~bs#_?uKh zqCfBtsf5LazyXv$VQ5_<8t6j??xGPfNWtH*`471K3PVimKLZQ+Iyj*7uefLw(lH?z za4YpD2i+QkK|kN6JqX`$CB}$o4}wdqJ@F#0(0r?`4SWVyI)On+3~?*QRv-N2M*BIs z<-g?mC)wZI_MdY7`ZBDBPx~U+CWe^Op92eGfH)~8UVw>#B+XXKwQ9wxIFr$t^iq^n zyJXd)V2;T?OdZ!w`-0fUM<=Ap%r*m z>=&$hHN!n(W_8Id(ClPpyo3tfaL`ve|ij zy(TTm>WdYcpGZ$6CQ##?L;j9q9cES7&eh$tCXf~VpW8jdk1l8B@-~S{h_i7scAbm@ zw!>;(Eyrr5od)^Cfu$gIhzQ{vYp1l+)F=AIS#eGb_%G5&1Q!`^rwBmk7Ss)P0P^9) zikBkcF6jLjlDKRVk>FRv=e0xx4vv?!2q6*i9kE^UY#XRLAN>FtI{QB(UCg);F+_4Q zvtZe!?C!M;QsFVXIP>g$CSg}HrkSxTh0;#Z;_^z??Ol}1(CpG`YIP`S?b-!vXmt&L zOC$05ShG2lIt)InqW@ltL=C5i=VNYjChaU`Y@ zEf^hs)95h`!!&yRTgC-wXHDZnH;u?mBkUi7+68mRg3%Q-jBTS|Zz9&eX$ZgGVQSc7 z(FQ$j^mN`c{IRVT8Qu2`G33{4n_5r}(|bfaP{wTCbYnO*l`irId*q{c54i8hp*e&6G-dHh=*|Gvk6?(yGx{Er^zS0m&7i#gvX zHiLDv36~Fe{EEjXnB%?^p1$aDe(oCXJMZZwk2gJj&*NY6IF@tQUouCWn?L+>ye{ly7OniwRyLQ<*R5SL z(MBCI3)ONNuR=2GR>?$fGOeavY`RWUz5rYwhaXxvGUqsTJHO*tjn?cId>yYkwzRZ{ zQ-42byi?u-E^RFUyRun*KLqz(^d5|swNiB~bN<=&s|_btxUD8xvMcDge9Ns>HtV^v zrSwA+c{{m0nTQ5tib3ec}TlTd0}w?C_y73}p!==> z=ep%H47}Rsz?tr1uwCXX*ByXO#d`xm9LIS0aCdto>tDlA^ZNpHu4_pW@2fDVczc*E z^W)aVag6tA3^l*Uo?UiViFXHf74H!y^L);a?Glea!PWeJ2mK0$B#FnpM#cMuk{@?+ ziT4x8YJU9n%InH*FY$hO4DT%^KOFTo9_PkG68Ex4QURB~?p7}s99$If3uL7Cpu#f3w;8i3DbQXD> z_PC7u3lieKC`rcgZz5$nJ;g<*ko0k_VX2yQaon0zz-8QN2vTPEONe_;iIdN*2SMun z#+3WzzApFAIEMEactvFaDe_09ipT$%U>x2*ey>WrQN+o!3^Prj;5T4n9NsgI>&EyG DD0@J# literal 0 HcmV?d00001 diff --git a/package/PikaStdDevice/PikaStdDeivce_GPIO.c b/package/PikaStdDevice/PikaStdDeivce_GPIO.c new file mode 100644 index 000000000..46847842c --- /dev/null +++ b/package/PikaStdDevice/PikaStdDeivce_GPIO.c @@ -0,0 +1,80 @@ +#include "BaseObj.h" +#include "PikaStdDevice_GPIO.h" + +void PikaStdDevice_GPIO_init(PikaObj* self) { + obj_setInt(self, "isEnable", 0); + obj_setStr(self, "pin", "PA0"); + obj_setStr(self, "mode", "out"); + obj_setInt(self, "isOn", 0); +} + +void PikaStdDevice_GPIO_disable(PikaObj* self) { + obj_setInt(self, "isEnable", 0); + obj_run(self, "platformDisable()"); +} + +void PikaStdDevice_GPIO_enable(PikaObj* self) { + obj_setInt(self, "isEnable", 1); + obj_run(self, "platformEnable()"); +} + +char* PikaStdDevice_GPIO_getMode(PikaObj* self) { + return obj_getStr(self, "mode"); +} + +char* PikaStdDevice_GPIO_getPin(PikaObj* self) { + return obj_getStr(self, "pin"); +} + +void PikaStdDevice_GPIO_low(PikaObj* self) { + obj_setInt(self, "isOn", 0); + obj_run(self, "platformLow()"); +} + +void PikaStdDevice_GPIO_high(PikaObj* self) { + obj_setInt(self, "isOn", 1); + obj_run(self, "platformHigh()"); +} + +void PikaStdDevice_GPIO_setMode(PikaObj* self, char* mode) { + obj_setStr(self, "mode", mode); + obj_run(self, "platformSetMode(mode)"); +} + +void PikaStdDevice_GPIO_setPin(PikaObj* self, char* pinName) { + obj_setStr(self, "pin", pinName); +} + +void PikaStdDevice_GPIO_platformDisable(PikaObj* self) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} + +void PikaStdDevice_GPIO_platformEnable(PikaObj* self) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} +void PikaStdDevice_GPIO_platformLow(PikaObj* self) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} + +void PikaStdDevice_GPIO_platformHigh(PikaObj* self) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} + +void PikaStdDevice_GPIO_platformSetMode(PikaObj* self, char* mode) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} + +void PikaStdDevice_GPIO_platformOff(PikaObj* self) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} + +void PikaStdDevice_GPIO_platformOn(PikaObj* self) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} diff --git a/package/PikaStdDevice/PikaStdDevice.py b/package/PikaStdDevice/PikaStdDevice.py new file mode 100644 index 000000000..3d39ed4c6 --- /dev/null +++ b/package/PikaStdDevice/PikaStdDevice.py @@ -0,0 +1,149 @@ +from PikaObj import * + + +class GPIO(TinyObj): + def init(): + pass + + def setPin(pinName: str): + pass + + def getPin() -> str: + pass + + def setMode(mode: str): + pass + + def getMode() -> str: + pass + + def enable(): + pass + + def disable(): + pass + + def high(): + pass + + def low(): + pass + + # need be overrid + def platformHigh(): + pass + + # need override + def platformLow(): + pass + + # need override + def platformEnable(): + pass + + # need override + def platformDisable(): + pass + + # need override + def platformSetMode(mode: str): + pass + + +class Time(TinyObj): + # need override + def sleep_s(s: int): + pass + + # need override + def sleep_ms(ms: int): + pass + + +class ADC(TinyObj): + def init(): + pass + + def setPin(pin: str): + pass + + def enable(): + pass + + def read() -> float: + pass + + # need override + def platformEnable(pin: str): + pass + + # need override + def platformRead(pin: str) -> float: + pass + + +class UART(TinyObj): + def init(): + pass + + def setBaudRate(baudRate: int): + pass + + def setId(id: int): + pass + + def enable(): + pass + + def write(data: str): + pass + + def read(length: int) -> str: + pass + + # need override + def platformEnable(id: int, baudRate: int): + pass + + # need override + def platformWrite(id: int, data: str): + pass + + # need override + def platformRead(id: int, length: int) -> str: + pass + + +class PWM(TinyObj): + def init(): + pass + + def setPin(pin: str): + pass + + def setFrequency(freq: int): + pass + + def setDuty(duty: float): + pass + + def enable(): + pass + + def getFrequency() -> int: + pass + + def getDuty() -> float: + pass + + # need override + def platformEnable(pin: str, freq: int, duty: float): + pass + + # need override + def platformSetFrequency(pin: str, freq: int): + pass + + # need override + def platformSetDuty(pin: str, duty: float): + pass diff --git a/package/PikaStdDevice/PikaStdDevice_ADC.c b/package/PikaStdDevice/PikaStdDevice_ADC.c new file mode 100644 index 000000000..5b6a80d61 --- /dev/null +++ b/package/PikaStdDevice/PikaStdDevice_ADC.c @@ -0,0 +1,30 @@ +#include "PikaStdDevice_ADC.h" +#include "BaseObj.h" + +void PikaStdDevice_ADC_enable(PikaObj* self) { + obj_run(self, "platformEnable(pin)"); +} + +void PikaStdDevice_ADC_init(PikaObj* self) { + obj_setStr(self, "pin", "PA0"); +} + +float PikaStdDevice_ADC_read(PikaObj* self) { + obj_run(self, "val = platformRead(pin)"); + return obj_getFloat(self, "val"); +} + +void PikaStdDevice_ADC_setPin(PikaObj* self, char* pin) { + obj_setStr(self, "pin", pin); +} + +void PikaStdDevice_ADC_platformEnable(PikaObj* self, char* pin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} + +float PikaStdDevice_ADC_platformRead(PikaObj* self, char* pin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); + return -1; +} \ No newline at end of file diff --git a/package/PikaStdDevice/PikaStdDevice_PWM.c b/package/PikaStdDevice/PikaStdDevice_PWM.c new file mode 100644 index 000000000..deb50da70 --- /dev/null +++ b/package/PikaStdDevice/PikaStdDevice_PWM.c @@ -0,0 +1,52 @@ +#include "PikaStdDevice_PWM.h" +#include "BaseObj.h" + +void PikaStdDevice_PWM_init(PikaObj* self) { + obj_setStr(self, "pin", "PA8"); + obj_setInt(self, "freq", 1000); + obj_setFloat(self, "duty", 0.5f); +} + +void PikaStdDevice_PWM_setPin(PikaObj* self, char* pin) { + obj_setStr(self, "pin", pin); +} + +void PikaStdDevice_PWM_setFrequency(PikaObj* self, int freq) { + obj_setInt(self, "freq", freq); + obj_run(self, "platformSetFrequency(pin, freq)"); +} + +void PikaStdDevice_PWM_setDuty(PikaObj* self, float duty) { + obj_setFloat(self, "duty", duty); + obj_run(self, "platformSetDuty(pin, duty)"); +} + +void PikaStdDevice_PWM_enable(PikaObj* self) { + obj_run(self, "platformEnable(pin, freq, duty)"); +} + +float PikaStdDevice_PWM_getDuty(PikaObj* self) { + return obj_getFloat(self, "duty"); +} + +int PikaStdDevice_PWM_getFrequency(PikaObj* self) { + return obj_getInt(self, "freq"); +} + +void PikaStdDevice_PWM_platformEnable(PikaObj* self, + float dute, + int freq, + char* pin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} +void PikaStdDevice_PWM_platformSetDuty(PikaObj* self, float duty, char* pin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} +void PikaStdDevice_PWM_platformSetFrequency(PikaObj* self, + int freq, + char* pin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} diff --git a/package/PikaStdDevice/PikaStdDevice_Time.c b/package/PikaStdDevice/PikaStdDevice_Time.c new file mode 100644 index 000000000..aa1492be7 --- /dev/null +++ b/package/PikaStdDevice/PikaStdDevice_Time.c @@ -0,0 +1,11 @@ +#include "PikaStdDevice_Time.h" +#include "BaseObj.h" + +void PikaStdDevice_Time_sleep_ms(PikaObj* self, int ms) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} +void PikaStdDevice_Time_sleep_s(PikaObj* self, int s) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} \ No newline at end of file diff --git a/package/PikaStdDevice/PikaStdDevice_UART.c b/package/PikaStdDevice/PikaStdDevice_UART.c new file mode 100644 index 000000000..60b51c0a9 --- /dev/null +++ b/package/PikaStdDevice/PikaStdDevice_UART.c @@ -0,0 +1,40 @@ +#include "PikaStdDevice_UART.h" +#include "BaseObj.h" + +void PikaStdDevice_UART_enable(PikaObj* self) { + obj_run(self, "platformEnable(id, baudRate)"); +} +void PikaStdDevice_UART_init(PikaObj* self) { + obj_setInt(self, "baudRate", 115200); + obj_setInt(self, "id", 1); + obj_setStr(self, "readBuff", ""); +} +char* PikaStdDevice_UART_read(PikaObj* self, int length) { + obj_setInt(self, "length", length); + obj_run(self, "readData = platformRead(id, length)"); + return obj_getStr(self, "readData"); +} +void PikaStdDevice_UART_setBaudRate(PikaObj* self, int baudRate) { + obj_setInt(self, "baudRate", baudRate); +} +void PikaStdDevice_UART_setId(PikaObj* self, int id) { + obj_setInt(self, "id", id); +} +void PikaStdDevice_UART_write(PikaObj* self, char* data) { + obj_setStr(self, "writeData", data); + obj_run(self, "platformWrite(id, writeData)"); +} + +void PikaStdDevice_UART_platformEnable(PikaObj* self, int baudRate, int id) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} +char* PikaStdDevice_UART_platformRead(PikaObj* self, int id, int length) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); + return NULL; +} +void PikaStdDevice_UART_platformWrite(PikaObj* self, char* data, int id) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] platform method need to be override."); +} \ No newline at end of file diff --git a/package/PikaStdLib/PikaStdLib.py b/package/PikaStdLib/PikaStdLib.py new file mode 100644 index 000000000..801b6d9e7 --- /dev/null +++ b/package/PikaStdLib/PikaStdLib.py @@ -0,0 +1,27 @@ +from PikaObj import * + + +class MemChecker(BaseObj): + def max(): + pass + + def now(): + pass + + def resetMax(): + pass + + +class SysObj(BaseObj): + + def type(argPath: str): + pass + + def ls(objPath: str): + pass + + def remove(argPath: str): + pass + + def new(objPath: str, classPath: str): + pass diff --git a/package/PikaStdLib/PikaStdLib_MemChecker.c b/package/PikaStdLib/PikaStdLib_MemChecker.c new file mode 100644 index 000000000..b9f17f036 --- /dev/null +++ b/package/PikaStdLib/PikaStdLib_MemChecker.c @@ -0,0 +1,14 @@ +#include "BaseObj.h" +#include "dataStrs.h" + +void PikaStdLib_MemChecker_max(PikaObj* self) { + obj_sysPrintf(self, "%0.2f kB", pikaMemMax() / 1024.0); +} + +void PikaStdLib_MemChecker_now(PikaObj* self) { + obj_sysPrintf(self, "%0.2f kB", pikaMemNow() / 1024.0); +} + +void PikaStdLib_MemChecker_resetMax(PikaObj* self) { + pikaMemMaxReset(); +} diff --git a/package/PikaStdLib/PikaStdLib_SysObj.c b/package/PikaStdLib/PikaStdLib_SysObj.c new file mode 100644 index 000000000..6a61965da --- /dev/null +++ b/package/PikaStdLib/PikaStdLib_SysObj.c @@ -0,0 +1,98 @@ +#include "BaseObj.h" +#include "dataStrs.h" + +static int32_t __foreach_listEachArg(Arg* argEach, Args* handleArgs) { + Args* buffs = handleArgs; + if (NULL == handleArgs) { + /* error: not handleArgs input */ + return 1; + } + + char* argName = strsCopy(buffs, arg_getName(argEach)); + if (strIsStartWith(argName, "[")) { + /* skip */ + return 0; + } + + char* stringOut = args_getStr(handleArgs, "stringOut"); + if (NULL == stringOut) { + // stringOut no found + return 1; + } + + stringOut = strsAppend(buffs, stringOut, argName); + stringOut = strsAppend(buffs, stringOut, " "); + args_setStr(handleArgs, "stringOut", stringOut); + return 0; +} + +void PikaStdLib_SysObj_ls(PikaObj* self, char* objPath) { + obj_setErrorCode(self, 0); + Args* args = New_args(NULL); + args_setStr(args, "stringOut", ""); + obj_setSysOut(self, ""); + if (NULL == objPath) { + /* no input obj path, use current obj */ + args_foreach(self->attributeList, __foreach_listEachArg, args); + obj_setSysOut(self, args_getStr(args, "stringOut")); + goto exit; + } + PikaObj* obj = obj_getObj(self, objPath, 0); + if (NULL == obj) { + /* do not find obj */ + obj_setSysOut(self, "[error] list: object no found."); + obj_setErrorCode(self, 1); + goto exit; + } + /* list args */ + args_foreach(obj->attributeList, __foreach_listEachArg, args); + obj_setSysOut(self, args_getStr(args, "stringOut")); +exit: + args_deinit(args); +} + +void PikaStdLib_SysObj_new(PikaObj* self, char* classPath, char* objPath) { + int32_t res = obj_newObj(self, objPath, classPath); + if (1 == res) { + obj_setSysOut(self, "[error] new: class not found ."); + obj_setErrorCode(self, 1); + return; + } +} + +void PikaStdLib_SysObj_remove(PikaObj* self, char* argPath) { + obj_setErrorCode(self, 0); + int32_t res = obj_removeArg(self, argPath); + if (1 == res) { + obj_setSysOut(self, "[error] del: object no found."); + obj_setErrorCode(self, 1); + return; + } + if (2 == res) { + obj_setSysOut(self, "[error] del: arg not match."); + obj_setErrorCode(self, 2); + return; + } +} + +void PikaStdLib_SysObj_type(PikaObj* self, char* argPath) { + if (NULL == argPath) { + /* no input obj path, use current obj */ + PikaObj* objHost = obj_getContext(self); + Arg* objArg = obj_getArg(objHost, obj_getStr(self, "_n")); + if (NULL == objArg) { + obj_setSysOut(self, "[error] type: arg no found."); + obj_setErrorCode(self, 1); + return; + } + obj_setSysOut(self, arg_getType(objArg)); + return; + } + Arg* arg = obj_getArg(self, argPath); + if (NULL == arg) { + obj_setSysOut(self, "[error] type: arg no found."); + obj_setErrorCode(self, 1); + return; + } + obj_setSysOut(self, arg_getType(arg)); +} diff --git a/package/STM32/STM32.py b/package/STM32/STM32.py new file mode 100644 index 000000000..3c1c4295c --- /dev/null +++ b/package/STM32/STM32.py @@ -0,0 +1,71 @@ +from typing import overload +import PikaStdDevice + + +class GPIO(PikaStdDevice.GPIO): + # override + def platformHigh(): + pass + + # override + def platformLow(): + pass + + # override + def platformEnable(): + pass + + # override + def platformDisable(): + pass + + # override + def platformSetMode(mode: str): + pass + + +class Time(PikaStdDevice.Time): + # override + def sleep_s(s: int): + pass + + # override + def sleep_ms(ms: int): + pass + + +class ADC(PikaStdDevice.ADC): + # override + def platformEnable(pin: str): + pass + + # override + def platformRead(pin: str) -> float: + pass + + +class UART(PikaStdDevice.UART): + # override + def platformEnable(id: int, baudRate: int): + pass + + # override + def platformWrite(id: int, data: str): + pass + + # override + def platformRead(id: int, length: int) -> str: + pass + +class PWM(PikaStdDevice.PWM): + # override + def platformEnable(pin: str, freq: int, duty: float): + pass + + # override + def platformSetFrequency(pin: str, freq: int): + pass + + # override + def platformSetDuty(pin: str, duty: float): + pass \ No newline at end of file diff --git a/package/STM32/STM32_ADC.c b/package/STM32/STM32_ADC.c new file mode 100644 index 000000000..2abebb324 --- /dev/null +++ b/package/STM32/STM32_ADC.c @@ -0,0 +1,167 @@ +#include "STM32_ADC.h" +#include +#include "BaseObj.h" +#include "STM32_common.h" +#include "dataStrs.h" + +ADC_HandleTypeDef pika_hadc1 = {0}; + +uint16_t Get_Adc(ADC_HandleTypeDef* hadc, uint32_t ch) { + ADC_ChannelConfTypeDef ADC_ChanConf; + ADC_ChanConf.Channel = ch; + ADC_ChanConf.Rank = ADC_REGULAR_RANK_1; +#if (defined STM32G070xx) || (defined STM32G030xx) + ADC_ChanConf.SamplingTime = ADC_SAMPLINGTIME_COMMON_1; +#endif +#ifdef STM32F103xB + ADC_ChanConf.SamplingTime = ADC_SAMPLETIME_239CYCLES_5; +#endif + HAL_ADC_ConfigChannel(hadc, &ADC_ChanConf); + HAL_ADC_Start(hadc); + HAL_ADC_PollForConversion(hadc, 10); + return (uint16_t)HAL_ADC_GetValue(hadc); +} + +void STM32_ADC_platformEnable(PikaObj* self, char* pin) { + if (!strIsStartWith(pin, "PA")) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match adc pin."); + return; + } + +/* MSP Init */ +#if (defined STM32G070xx) || (defined STM32G030xx) + __HAL_RCC_ADC_CLK_ENABLE(); +#endif +#ifdef STM32F103xB + __HAL_RCC_ADC1_CLK_ENABLE(); +#endif + if (0 != enableClk(pin)) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + return; + } + + GPIO_InitTypeDef GPIO_InitStruct = {0}; + GPIO_InitStruct.Pin = getGpioPin(pin); + GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(getGpioPort(pin), &GPIO_InitStruct); + + /* init ADC */ + pika_hadc1.Instance = ADC1; +#if (defined STM32G070xx) || (defined STM32G030xx) + pika_hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4; + pika_hadc1.Init.Resolution = ADC_RESOLUTION_12B; + pika_hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV; + pika_hadc1.Init.LowPowerAutoWait = DISABLE; + pika_hadc1.Init.LowPowerAutoPowerOff = DISABLE; +#endif + pika_hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE; + pika_hadc1.Init.ContinuousConvMode = DISABLE; + pika_hadc1.Init.DiscontinuousConvMode = DISABLE; + pika_hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START; + pika_hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT; + pika_hadc1.Init.NbrOfConversion = 1; +#if (defined STM32G070xx) || (defined STM32G030xx) + pika_hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; + pika_hadc1.Init.DMAContinuousRequests = DISABLE; + pika_hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED; + pika_hadc1.Init.SamplingTimeCommon1 = ADC_SAMPLETIME_1CYCLE_5; + pika_hadc1.Init.SamplingTimeCommon2 = ADC_SAMPLETIME_1CYCLE_5; + pika_hadc1.Init.OversamplingMode = DISABLE; + pika_hadc1.Init.TriggerFrequencyMode = ADC_TRIGGER_FREQ_HIGH; +#endif + + HAL_StatusTypeDef state = HAL_ADC_Init(&pika_hadc1); + if (state != HAL_OK) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] adc init faild."); + return; + } + + /* Run the ADC calibration */ + if (HAL_ADCEx_Calibration_Start(&pika_hadc1) != HAL_OK) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] adc calibratie faild."); + return; + } +} + +uint32_t getChannel(char* pin) { + Args* buffs = New_strBuff(); + uint32_t channel = 0; + + pin = strsCopy(buffs, pin + 2); + if (strEqu(pin, "0")) { + channel = ADC_CHANNEL_0; + goto exit; + } + if (strEqu(pin, "1")) { + channel = ADC_CHANNEL_1; + goto exit; + } + if (strEqu(pin, "2")) { + channel = ADC_CHANNEL_2; + goto exit; + } + if (strEqu(pin, "3")) { + channel = ADC_CHANNEL_3; + goto exit; + } + if (strEqu(pin, "4")) { + channel = ADC_CHANNEL_4; + goto exit; + } + if (strEqu(pin, "5")) { + channel = ADC_CHANNEL_5; + goto exit; + } + if (strEqu(pin, "6")) { + channel = ADC_CHANNEL_6; + goto exit; + } + if (strEqu(pin, "7")) { + channel = ADC_CHANNEL_7; + goto exit; + } + if (strEqu(pin, "8")) { + channel = ADC_CHANNEL_8; + goto exit; + } + if (strEqu(pin, "9")) { + channel = ADC_CHANNEL_9; + goto exit; + } + if (strEqu(pin, "10")) { + channel = ADC_CHANNEL_10; + goto exit; + } + if (strEqu(pin, "11")) { + channel = ADC_CHANNEL_11; + goto exit; + } + if (strEqu(pin, "12")) { + channel = ADC_CHANNEL_12; + goto exit; + } + if (strEqu(pin, "13")) { + channel = ADC_CHANNEL_13; + goto exit; + } + if (strEqu(pin, "14")) { + channel = ADC_CHANNEL_14; + goto exit; + } + if (strEqu(pin, "15")) { + channel = ADC_CHANNEL_15; + goto exit; + } +exit: + args_deinit(buffs); + return channel; +} + +float STM32_ADC_platformRead(PikaObj* self, char* pin) { + return 3.3f * Get_Adc(&pika_hadc1, getChannel(pin)) / 4096.0f; +} diff --git a/package/STM32/STM32_Code.c b/package/STM32/STM32_Code.c new file mode 100644 index 000000000..36155a785 --- /dev/null +++ b/package/STM32/STM32_Code.c @@ -0,0 +1,137 @@ +#include +#include "BaseObj.h" +#include "STM32_common.h" +#include "dataStrs.h" +#include +CodeHeap codeHeap; + +void STM32_Code_Init() { + codeHeap.size = 0; + codeHeap.content = pikaMalloc(codeHeap.size + 1); + codeHeap.ena = 0; +} + +uint8_t STM32_Code_reciveHandler(char* data, uint32_t rxSize) { + char buff[RX_BUFF_LENGTH] = {0}; + if (0 == codeHeap.ena) { + char* strLine = strGetLastLine(buff, data); + if (strIsStartWith(strLine, "import ")) { + codeHeap.reciveTime = uwTick; + codeHeap.ena = 1; + data = strLine; + rxSize = strGetSize(strLine); + } + } + if (1 == codeHeap.ena) { + codeHeap.reciveTime = uwTick; + codeHeap.oldSize = codeHeap.size; + codeHeap.size += rxSize; + codeHeap.content = realloc(codeHeap.content , codeHeap.size + 1); + memcpy(codeHeap.content + codeHeap.oldSize, data, rxSize); + codeHeap.content[codeHeap.size] = 0; + /* reciving code */ + return 1; + } + /* not work */ + return 0; +} + +uint32_t GetPage(uint32_t Addr) { + return (Addr - FLASH_BASE) / FLASH_PAGE_SIZE; +} + +void STM32_Code_flashHandler() { + if (!codeHeap.ena){ + /* recive not activate */ + return; + } + if ( uwTick - codeHeap.reciveTime < 200 ){ + /* still reciving */ + return; + } + + /* transmite is finished */ + uint32_t FirstPage = 0, NbOfPages = 0; + uint32_t PageError = 0; + __IO uint32_t data32 = 0, MemoryProgramStatus = 0; + static FLASH_EraseInitTypeDef EraseInitStruct = {0}; + + printf("==============[Programer]==============\r\n"); + printf("[info]: Recived byte: %d\r\n", codeHeap.size); + printf("[info]: Programing... \r\n"); + HAL_FLASH_Unlock(); + /* Get the 1st page to erase */ + FirstPage = GetPage(FLASH_CODE_START_ADDR); + + /* Get the number of pages to erase from 1st page */ + NbOfPages = GetPage(FLASH_USER_END_ADDR) - FirstPage + 1; + + /* Fill EraseInit structure*/ + EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES; + EraseInitStruct.Page = FirstPage; + EraseInitStruct.NbPages = NbOfPages; + printf("[info]: Erasing flash... \r\n"); + + if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) { + printf("[error]: Erase faild! \r\n"); + while (1) { + } + } + printf("[ OK ]: Erase flash ok! \r\n"); + + printf("[info]: Writing flash... \r\n"); + uint32_t baseAddress = FLASH_CODE_START_ADDR; + uint32_t writeAddress = 0; + uint64_t writeData64 = 0; + while (writeAddress < codeHeap.size + 1) { + writeData64 = 0; + for (int i = 7; i >= 0; i--) { + char ch = codeHeap.content[writeAddress + i]; + writeData64 = writeData64 << 8; + writeData64 += ch; + } + if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, + baseAddress + writeAddress, + writeData64) == HAL_OK) { + writeAddress = writeAddress + 8; + } else { + printf("[error]: Write flash faild. \r\n"); + while (1) { + } + } + } + HAL_FLASH_Lock(); + printf("[ OK ]: Write flash ok! \r\n"); + + baseAddress = FLASH_CODE_START_ADDR; + MemoryProgramStatus = 0x0; + + printf("[info]: Checking flash... \r\n"); + char* codeInFlash = (char*)baseAddress; + printf("\r\n"); + printf("----[code in flash]-----\r\n"); + printf("%s", codeInFlash); + printf("----[code in flash]-----\r\n"); + printf("\r\n"); + + if (!strEqu(codeInFlash, codeHeap.content)) { + printf("[error]: Check flash faild.\r\n"); + printf("\r\n"); + + printf("\r\n\r\n"); + printf("---------[code in heap]----------\r\n"); + printf("\r\n"); + printf("%s", codeHeap.content); + printf("\r\n\r\n"); + printf("---------[code in heap]----------\r\n"); + while (1) { + } + } + printf("[ OK ]: Checking flash ok! \r\n"); + printf("[ OK ]: Programing ok! \r\n"); + printf("[info]: Restarting... \r\n"); + printf("==============[Programer]==============\r\n"); + + printf("\r\n"); + HAL_NVIC_SystemReset(); +} \ No newline at end of file diff --git a/package/STM32/STM32_GPIO.c b/package/STM32/STM32_GPIO.c new file mode 100644 index 000000000..2f6794769 --- /dev/null +++ b/package/STM32/STM32_GPIO.c @@ -0,0 +1,142 @@ +#include "STM32_GPIO.h" +#include +#include "BaseObj.h" +#include "STM32_common.h" +#include "dataStrs.h" + +void STM32_GPIO_platformDisable(PikaObj* self) { + char* pin = obj_getStr(self, "pin"); + char* mode = obj_getStr(self, "mode"); + + GPIO_TypeDef* gpioPort = getGpioPort(pin); + + if (NULL == gpioPort) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + } + + uint16_t gpioPin = getGpioPin(pin); + + if (0 == gpioPin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio pin."); + } + + HAL_GPIO_DeInit(gpioPort, gpioPin); +} + +void STM32_GPIO_platformEnable(PikaObj* self) { + char* pin = obj_getStr(self, "pin"); + char* mode = obj_getStr(self, "mode"); + + if (0 != enableClk(pin)) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + return; + } + + GPIO_TypeDef* gpioPort = getGpioPort(pin); + + if (NULL == gpioPort) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + } + + uint16_t gpioPin = getGpioPin(pin); + + if (0 == gpioPin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio pin."); + } + + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_RESET); + + uint32_t pinMode = getPinMode(mode); + if (NULL == pinMode) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio mode."); + } + + GPIO_InitTypeDef GPIO_InitStruct = {0}; + /*Configure GPIO*/ + GPIO_InitStruct.Pin = gpioPin; + GPIO_InitStruct.Mode = pinMode; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + HAL_GPIO_Init(gpioPort, &GPIO_InitStruct); +} +void STM32_GPIO_platformLow(PikaObj* self) { + char* pin = obj_getStr(self, "pin"); + GPIO_TypeDef* gpioPort = getGpioPort(pin); + + if (NULL == gpioPort) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + } + + uint16_t gpioPin = getGpioPin(pin); + + if (0 == gpioPin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio pin."); + } + HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_RESET); +} +void STM32_GPIO_platformHigh(PikaObj* self) { + char* pin = obj_getStr(self, "pin"); + GPIO_TypeDef* gpioPort = getGpioPort(pin); + + if (NULL == gpioPort) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + } + + uint16_t gpioPin = getGpioPin(pin); + + if (0 == gpioPin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio pin."); + } + HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_SET); +} +void STM32_GPIO_platformSetMode(PikaObj* self, char* mode) { + char* pin = obj_getStr(self, "pin"); + + if (0 != enableClk(pin)) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + return; + } + + GPIO_TypeDef* gpioPort = getGpioPort(pin); + + if (NULL == gpioPort) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio port."); + } + + uint16_t gpioPin = getGpioPin(pin); + + if (0 == gpioPin) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio pin."); + } + + /*Configure GPIO pin Output Level */ + HAL_GPIO_WritePin(gpioPort, gpioPin, GPIO_PIN_RESET); + + uint32_t pinMode = getPinMode(mode); + if (NULL == pinMode) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] not match gpio mode."); + } + + GPIO_InitTypeDef GPIO_InitStruct = {0}; + /*Configure GPIO*/ + GPIO_InitStruct.Pin = gpioPin; + GPIO_InitStruct.Mode = pinMode; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; + HAL_GPIO_Init(gpioPort, &GPIO_InitStruct); +} \ No newline at end of file diff --git a/package/STM32/STM32_PWM.c b/package/STM32/STM32_PWM.c new file mode 100644 index 000000000..62532ac14 --- /dev/null +++ b/package/STM32/STM32_PWM.c @@ -0,0 +1,366 @@ +#include "STM32_PWM.h" +#include +#include "BaseObj.h" +#include "STM32_common.h" +#include "dataStrs.h" + +#ifdef TIM1_EXIST +TIM_HandleTypeDef pika_tim1; +#endif +#ifdef TIM2_EXIST +TIM_HandleTypeDef pika_tim2; +#endif +#ifdef TIM3_EXIST +TIM_HandleTypeDef pika_tim3; +#endif +#ifdef TIM4_EXIST +TIM_HandleTypeDef pika_tim4; +#endif +#ifdef TIM14_EXIST +TIM_HandleTypeDef pika_tim14; +#endif +#ifdef TIM16_EXIST +TIM_HandleTypeDef pika_tim16; +#endif +#ifdef TIM17_EXIST +TIM_HandleTypeDef pika_tim17; +#endif + +static TIM_HandleTypeDef* getTimHandle(char* pin) { +#ifdef TIM1_EXIST + if (strEqu("PA8", pin) || strEqu("PA9", pin) || strEqu("PA10", pin) || + strEqu("PA11", pin)) { + return &pika_tim1; + } +#endif +#ifdef TIM2_EXIST + if (strEqu("PA0", pin) || strEqu("PA1", pin) || strEqu("PA2", pin) || + strEqu("PA3", pin)) { + return &pika_tim2; + } +#endif +#ifdef TIM3_EXIST + if (strEqu("PA6", pin) || strEqu("PA7", pin) || strEqu("PB0", pin) || + strEqu("PB1", pin)) { + return &pika_tim3; + } +#endif +#ifdef TIM4_EXIST + if (strEqu("PB6", pin) || strEqu("PB7", pin) || strEqu("PB8", pin) || + strEqu("PB9", pin)) { + return &pika_tim3; + } +#endif +#ifdef TIM14_EXIST + if (strEqu("PA4", pin)) { + return &pika_tim14; + } +#endif +#ifdef TIM16_EXIST + if (strEqu("PD0", pin)) { + return &pika_tim16; + } +#endif +#ifdef TIM17_EXIST + if (strEqu("PD1", pin)) { + return &pika_tim17; + } +#endif + return NULL; +} + +static TIM_TypeDef* getTimInstance(char* pin) { +#ifdef TIM1_EXIST + if (strEqu("PA8", pin) || strEqu("PA9", pin) || strEqu("PA10", pin) || + strEqu("PA11", pin)) { + return TIM1; + } +#endif +#ifdef TIM2_EXIST + if (strEqu("PA0", pin) || strEqu("PA1", pin) || strEqu("PA2", pin) || + strEqu("PA3", pin)) { + return TIM2; + } +#endif +#ifdef TIM3_EXIST + if (strEqu("PA6", pin) || strEqu("PA7", pin) || strEqu("PB0", pin) || + strEqu("PB1", pin)) { + return TIM3; + } +#endif +#ifdef TIM4_EXIST + if (strEqu("PB6", pin) || strEqu("PB7", pin) || strEqu("PB8", pin) || + strEqu("PB9", pin)) { + return TIM4; + } +#endif +#ifdef TIM14_EXIST + if (strEqu("PA4", pin)) { + return TIM14; + } +#endif +#ifdef TIM16_EXIST + if (strEqu("PD0", pin)) { + return TIM16; + } +#endif +#ifdef TIM17_EXIST_EXIST + if (strEqu("PD1", pin)) { + return TIM17; + } +#endif + return NULL; +} + +#if (defined STM32G030xx) || (defined STM32G070xx) +static uint32_t getGPIO_AlternateForTim(TIM_TypeDef* timInstance) { +#ifdef TIM1_EXIST + if (TIM1 == timInstance) { + return GPIO_AF2_TIM1; + } +#endif +#ifdef TIM3_EXIST + if (TIM3 == timInstance) { + return GPIO_AF1_TIM3; + } +#endif +#ifdef TIM14_EXIST + if (TIM14 == timInstance) { + return GPIO_AF4_TIM14; + } +#endif +#ifdef TIM16_EXIST + if (TIM16 == timInstance) { + return GPIO_AF2_TIM16; + } +#endif +#ifdef TIM17_EXIST + if (TIM17 == timInstance) { + return GPIO_AF2_TIM17; + } +#endif + return 0; +} +#endif + +static void PWM_TimClockEnable(TIM_TypeDef* timInstance) { +#ifdef TIM1_EXIST + if (TIM1 == timInstance) { + __HAL_RCC_TIM1_CLK_ENABLE(); + return; + } +#endif +#ifdef TIM2_EXIST + if (TIM2 == timInstance) { + __HAL_RCC_TIM2_CLK_ENABLE(); + return; + } +#endif +#ifdef TIM3_EXIST + if (TIM3 == timInstance) { + __HAL_RCC_TIM3_CLK_ENABLE(); + return; + } +#endif +#ifdef TIM4_EXIST + if (TIM4 == timInstance) { + __HAL_RCC_TIM4_CLK_ENABLE(); + return; + } +#endif +#ifdef TIM14_EXIST + if (TIM14 == timInstance) { + __HAL_RCC_TIM14_CLK_ENABLE(); + return; + } +#endif +#ifdef TIM16_EXIST + if (TIM16 == timInstance) { + __HAL_RCC_TIM16_CLK_ENABLE(); + return; + } +#endif +#ifdef TIM17_EXIST + if (TIM17 == timInstance) { + __HAL_RCC_TIM17_CLK_ENABLE(); + return; + } +#endif +} + +uint8_t PWM_MspInit(char* pin) { + TIM_TypeDef* timInstance = getTimInstance(pin); + if (NULL == timInstance) { + /* this Pin do not match any PWM generator */ + return 1; + } + enableClk(pin); + GPIO_InitTypeDef GPIO_InitStruct = {0}; + GPIO_InitStruct.Pin = getGpioPin(pin); + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; +#if (defined STM32G030xx) || (defined STM32G070xx) + GPIO_InitStruct.Alternate = getGPIO_AlternateForTim(timInstance); +#endif + HAL_GPIO_Init(getGpioPort(pin), &GPIO_InitStruct); + PWM_TimClockEnable(timInstance); + return 0; +} + +uint32_t getTimChennel(char* pin) { + if (strEqu("PA8", pin) || strEqu("PA0", pin) || strEqu("PA6", pin) || + strEqu("PB6", pin) || strEqu("PA4", pin) || strEqu("PD0", pin) || + strEqu("PD1", pin)) { + return TIM_CHANNEL_1; + } + if (strEqu("PA9", pin) || strEqu("PA1", pin) || strEqu("PB7", pin) || + strEqu("PA7", pin)) { + return TIM_CHANNEL_2; + } + if (strEqu("PA10", pin) || strEqu("PA2", pin) || strEqu("PB8", pin) || + strEqu("PB0", pin)) { + return TIM_CHANNEL_3; + } + if (strEqu("PA11", pin) || strEqu("PA3", pin) || strEqu("PB9", pin) || + strEqu("PB1", pin)) { + return TIM_CHANNEL_4; + } + /* Chennel not match */ + return 99999; +} + +void STM32_PWM_platformEnable(PikaObj* self, float duty, int freq, char* pin) { + TIM_ClockConfigTypeDef sClockSourceConfig = {0}; + TIM_MasterConfigTypeDef sMasterConfig = {0}; + TIM_OC_InitTypeDef sConfigOC = {0}; + TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0}; + + if (0 != PWM_MspInit(pin)) { + obj_setSysOut(self, "[error]: init PWM port faild."); + obj_setErrorCode(self, 1); + return; + } + + TIM_HandleTypeDef* pika_tim = getTimHandle(pin); + if (NULL == pika_tim) { + obj_setSysOut(self, "[error]: can not found PWM hardware."); + obj_setErrorCode(self, 1); + return; + } + + pika_tim->Instance = getTimInstance(pin); +#if (defined STM32G030xx) || (defined STM32G070xx) + pika_tim->Init.Prescaler = 64 - 1; +#endif +#if (defined STM32F103xB) + pika_tim->Init.Prescaler = 72 - 1; +#endif + pika_tim->Init.CounterMode = TIM_COUNTERMODE_UP; + /* calculate period */ + pika_tim->Init.Period = (uint32_t)((float)(1000 * 1000) / (float)freq) - 1; + pika_tim->Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; + pika_tim->Init.RepetitionCounter = 0; + pika_tim->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; + + if (HAL_TIM_Base_Init(pika_tim) != HAL_OK) { + obj_setSysOut(self, "[error]: init PWM faild."); + obj_setErrorCode(self, 1); + return; + } + sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; + if (HAL_TIM_ConfigClockSource(pika_tim, &sClockSourceConfig) != HAL_OK) { + obj_setSysOut(self, "[error]: init PWM faild."); + obj_setErrorCode(self, 1); + return; + } + if (HAL_TIM_PWM_Init(pika_tim) != HAL_OK) { + obj_setSysOut(self, "[error]: init PWM faild."); + obj_setErrorCode(self, 1); + return; + } + if (HAL_TIM_OC_Init(pika_tim) != HAL_OK) { + obj_setSysOut(self, "[error]: init PWM faild."); + obj_setErrorCode(self, 1); + return; + } + sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; +#if (defined STM32G030xx) || (defined STM32G070xx) + sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET; +#endif + sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; + if (HAL_TIMEx_MasterConfigSynchronization(pika_tim, &sMasterConfig) != + HAL_OK) { + obj_setSysOut(self, "[error]: init PWM faild."); + obj_setErrorCode(self, 1); + return; + } + sConfigOC.OCMode = TIM_OCMODE_PWM1; + /* calculate pulse by duty and freq */ + sConfigOC.Pulse = (uint32_t)(pika_tim->Init.Period * duty); + sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH; + sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH; + sConfigOC.OCFastMode = TIM_OCFAST_DISABLE; + sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET; + sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET; + if (HAL_TIM_PWM_ConfigChannel(pika_tim, &sConfigOC, getTimChennel(pin)) != + HAL_OK) { + obj_setSysOut(self, "[error]: init PWM faild."); + obj_setErrorCode(self, 1); + return; + } + + sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE; + sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE; + sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF; + sBreakDeadTimeConfig.DeadTime = 0; + sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE; + sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH; +#if (defined STM32G030xx) || (defined STM32G070xx) + sBreakDeadTimeConfig.BreakFilter = 0; + sBreakDeadTimeConfig.BreakAFMode = TIM_BREAK_AFMODE_INPUT; + sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE; + sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH; + sBreakDeadTimeConfig.Break2Filter = 0; + sBreakDeadTimeConfig.Break2AFMode = TIM_BREAK_AFMODE_INPUT; + sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE; +#endif + if (HAL_TIMEx_ConfigBreakDeadTime(pika_tim, &sBreakDeadTimeConfig) != + HAL_OK) { + obj_setSysOut(self, "[error]: init PWM faild."); + obj_setErrorCode(self, 1); + return; + } + HAL_TIM_PWM_Start(pika_tim, getTimChennel(pin)); +} + +void STM32_PWM_platformSetDuty(PikaObj* self, float duty, char* pin) { + TIM_HandleTypeDef* pika_tim = getTimHandle(pin); + if (NULL == pika_tim) { + obj_setSysOut(self, "[error]: can not found PWM hardware."); + obj_setErrorCode(self, 1); + return; + } + /* update duty in run time */ + if (NULL != pika_tim->Instance) { + __HAL_TIM_SET_COMPARE(pika_tim, getTimChennel(pin), + (uint32_t)(pika_tim->Init.Period * duty)); + } +} + +void STM32_PWM_platformSetFrequency(PikaObj* self, int freq, char* pin) { + TIM_HandleTypeDef* pika_tim = getTimHandle(pin); + if (NULL == pika_tim) { + obj_setSysOut(self, "[error]: can not found PWM hardware."); + obj_setErrorCode(self, 1); + return; + } + /* update frequency in run time */ + if (NULL != pika_tim->Instance) { + __HAL_TIM_SET_AUTORELOAD( + pika_tim, (uint32_t)((float)(1000 * 1000) / (float)freq) - 1); + float duty = obj_getFloat(self, "duty"); + __HAL_TIM_SET_COMPARE(pika_tim, getTimChennel(pin), + (uint32_t)(pika_tim->Init.Period * duty)); + } +} diff --git a/package/STM32/STM32_Time.c b/package/STM32/STM32_Time.c new file mode 100644 index 000000000..477c0252b --- /dev/null +++ b/package/STM32/STM32_Time.c @@ -0,0 +1,14 @@ +#include "STM32_Time.h" +#include +#include "BaseObj.h" + +#include "STM32_common.h" + +void STM32_Time_sleep_ms(PikaObj* self, int ms) { + HAL_Delay(ms); +} +void STM32_Time_sleep_s(PikaObj* self, int s) { + for (int i = 0; i < s; i++) { + HAL_Delay(1000); + } +} \ No newline at end of file diff --git a/package/STM32/STM32_UART.c b/package/STM32/STM32_UART.c new file mode 100644 index 000000000..2e6996d36 --- /dev/null +++ b/package/STM32/STM32_UART.c @@ -0,0 +1,434 @@ +#include "STM32_UART.h" +#include +#include "BaseObj.h" +#include "STM32_common.h" +#include "dataStrs.h" + +#ifdef UART1_EXIST +pika_uart_t pika_uart1; +#endif +#ifdef UART2_EXIST +pika_uart_t pika_uart2; +#endif +#ifdef UART3_EXIST +pika_uart_t pika_uart3; +#endif +#ifdef UART4_EXIST +pika_uart_t pika_uart4; +#endif + +static pika_uart_t* getPikaUart(uint8_t id) { + if (1 == id) { + return &pika_uart1; + } + if (2 == id) { + return &pika_uart2; + } +#ifdef UART3_EXIST + if (3 == id) { + return &pika_uart3; + } +#endif +#ifdef UART4_EXIST + if (4 == id) { + return &pika_uart4; + } +#endif + return NULL; +} + +static void setUartObj(uint8_t id, PikaObj* obj) { + pika_uart_t* pika_uart = getPikaUart(id); + pika_uart->obj = obj; +} + +static PikaObj* getUartObj(uint8_t id) { + pika_uart_t* pika_uart = getPikaUart(id); + if (NULL == pika_uart) { + return NULL; + } + return pika_uart->obj; +} + +static USART_TypeDef* getUartInstance(uint8_t id) { +#ifdef UART1_EXIST + if (1 == id) { + return USART1; + } +#endif +#ifdef UART2_EXIST + if (2 == id) { + return USART2; + } +#endif +#ifdef UART3_EXIST + if (3 == id) { + return USART3; + } +#endif +#ifdef UART4_EXIST + if (4 == id) { + return USART4; + } +#endif + return NULL; +} + +static uint8_t getUartId(UART_HandleTypeDef* huart) { +#ifdef UART1_EXIST + if (huart == &pika_uart1.huart) { + return 1; + } +#endif +#ifdef UART2_EXIST + if (huart == &pika_uart2.huart) { + return 2; + } +#endif +#ifdef UART3_EXIST + if (huart == &pika_uart3.huart) { + return 3; + } +#endif +#ifdef UART4_EXIST + if (huart == &pika_uart4.huart) { + return 4; + } +#endif + return 0; +} + +static UART_HandleTypeDef* getUartHandle(uint8_t id) { + pika_uart_t* pika_uart = getPikaUart(id); + if (NULL == pika_uart) { + return NULL; + } + return &(pika_uart->huart); +} + +static char* getUartRxBuff(uint8_t id) { + pika_uart_t* pika_uart = getPikaUart(id); + if (NULL == pika_uart) { + return NULL; + } + return pika_uart->rxBuff; +} + +static uint8_t USART_UART_Init(uint32_t baudRate, uint8_t id) { + uint8_t errCode = 0; + UART_HandleTypeDef* huart = getUartHandle(id); + huart->Instance = getUartInstance(id); + if (NULL == huart->Instance) { + errCode = 5; + goto exit; + } + huart->Init.BaudRate = baudRate; + huart->Init.WordLength = UART_WORDLENGTH_8B; + huart->Init.StopBits = UART_STOPBITS_1; + huart->Init.Parity = UART_PARITY_NONE; + huart->Init.Mode = UART_MODE_TX_RX; + huart->Init.HwFlowCtl = UART_HWCONTROL_NONE; + huart->Init.OverSampling = UART_OVERSAMPLING_16; +#if (defined STM32G070xx) || (defined STM32G030xx) + huart->Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; + huart->Init.ClockPrescaler = UART_PRESCALER_DIV1; + huart->AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; +#endif + if (HAL_UART_Init(huart) != HAL_OK) { + errCode = 1; + goto exit; + } +#if (defined STM32G070xx) || (defined STM32G030xx) + if (HAL_UARTEx_SetTxFifoThreshold(huart, UART_TXFIFO_THRESHOLD_1_8) != + HAL_OK) { + errCode = 2; + goto exit; + } + if (HAL_UARTEx_SetRxFifoThreshold(huart, UART_RXFIFO_THRESHOLD_1_8) != + HAL_OK) { + errCode = 3; + goto exit; + } + if (HAL_UARTEx_DisableFifoMode(huart) != HAL_OK) { + errCode = 4; + goto exit; + } +#endif +exit: + return errCode; +} + +static void UART_MspInit(UART_HandleTypeDef* uartHandle) { + GPIO_InitTypeDef GPIO_InitStruct = {0}; +#ifdef UART1_EXIST + if (uartHandle->Instance == USART1) { + /* USART1 clock enable */ + __HAL_RCC_USART1_CLK_ENABLE(); + + __HAL_RCC_GPIOA_CLK_ENABLE(); +/**USART1 GPIO Configuration +PA9 ------> USART1_TX +PA10 ------> USART1_RX +*/ +#if (defined STM32G070xx) || (defined STM32G030xx) + GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF1_USART1; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); +#endif +#ifdef STM32F103xB + GPIO_InitStruct.Pin = GPIO_PIN_9; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + GPIO_InitStruct.Pin = GPIO_PIN_10; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); +#endif + /* USART1 interrupt Init */ + HAL_NVIC_SetPriority(USART1_IRQn, 0, 0); + HAL_NVIC_EnableIRQ(USART1_IRQn); + } +#endif +#ifdef UART2_EXIST + if (uartHandle->Instance == USART2) { + /* USART2 clock enable */ + __HAL_RCC_USART2_CLK_ENABLE(); + + __HAL_RCC_GPIOA_CLK_ENABLE(); +/**USART2 GPIO Configuration +PA2 ------> USART2_TX +PA3 ------> USART2_RX +*/ +#if (defined STM32G070xx) || (defined STM32G030xx) + GPIO_InitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_3; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF1_USART2; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); +#endif +#ifdef STM32F103xB + GPIO_InitStruct.Pin = GPIO_PIN_2; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + GPIO_InitStruct.Pin = GPIO_PIN_3; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); +#endif + /* USART2 interrupt Init */ + HAL_NVIC_SetPriority(USART2_IRQn, 0, 0); + HAL_NVIC_EnableIRQ(USART2_IRQn); + } +#endif +#ifdef UART3_EXIST + if (uartHandle->Instance == USART3) { + /* USART3 clock enable */ + __HAL_RCC_USART3_CLK_ENABLE(); + + __HAL_RCC_GPIOA_CLK_ENABLE(); + __HAL_RCC_GPIOB_CLK_ENABLE(); +/**USART3 GPIO Configuration +PA5 ------> USART3_TX +PB0 ------> USART3_RX +*/ +#if (defined STM32G070xx) + GPIO_InitStruct.Pin = GPIO_PIN_5; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF4_USART3; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + GPIO_InitStruct.Pin = GPIO_PIN_0; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF4_USART3; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); +#endif + +#ifdef STM32F103xB + /**USART3 GPIO Configuration + PB10 ------> USART3_TX + PB11 ------> USART3_RX + */ + GPIO_InitStruct.Pin = GPIO_PIN_10; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); + + GPIO_InitStruct.Pin = GPIO_PIN_11; + GPIO_InitStruct.Mode = GPIO_MODE_INPUT; + GPIO_InitStruct.Pull = GPIO_NOPULL; + HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); +#endif + + /* USART3 interrupt Init */ +#if (defined STM32G070xx) || (defined STM32G030xx) + HAL_NVIC_SetPriority(USART3_4_IRQn, 0, 0); + HAL_NVIC_EnableIRQ(USART3_4_IRQn); +#endif +#ifdef STM32F103xB + HAL_NVIC_SetPriority(USART3_IRQn, 0, 0); + HAL_NVIC_EnableIRQ(USART3_IRQn); +#endif + } +#endif +#ifdef UART4_EXIST +#if (defined STM32G070xx) + if (uartHandle->Instance == USART4) { + /* USART4 clock enable */ + __HAL_RCC_USART4_CLK_ENABLE(); + + __HAL_RCC_GPIOA_CLK_ENABLE(); + /**USART4 GPIO Configuration + PA0 ------> USART4_TX + PA1 ------> USART4_RX + */ + GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1; + GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; + GPIO_InitStruct.Pull = GPIO_NOPULL; + GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; + GPIO_InitStruct.Alternate = GPIO_AF4_USART4; + HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); + + /* USART4 interrupt Init */ + HAL_NVIC_SetPriority(USART3_4_IRQn, 0, 0); + HAL_NVIC_EnableIRQ(USART3_4_IRQn); + } +#endif +#endif +} + +/* Msp handle interrupt */ +#ifdef UART1_EXIST +void USART1_IRQHandler(void) { + HAL_UART_IRQHandler(&pika_uart1.huart); +} +#endif +#ifdef UART2_EXIST +void USART2_IRQHandler(void) { + HAL_UART_IRQHandler(&pika_uart2.huart); +} +#endif +#ifdef UART3_EXIST +#ifdef STM32F103xB +void USART3_IRQHandler(void) { + HAL_UART_IRQHandler(&pika_uart3.huart); +} +#endif +#endif + +#if (defined UART3_EXIST) && (defined UART4_EXIST) +#if defined STM32G070xx +void USART3_4_IRQHandler(void) { + HAL_UART_IRQHandler(&pika_uart3.huart); + HAL_UART_IRQHandler(&pika_uart4.huart); +} +#endif +#endif + +void STM32_UART_platformEnable(PikaObj* self, int baudRate, int id) { + STM32_Code_Init(); + setUartObj(id, self); + UART_HandleTypeDef* huart = getUartHandle(id); + huart->Instance = getUartInstance(id); + UART_MspInit(huart); + int errCode = USART_UART_Init(baudRate, id); + if (0 != errCode) { + obj_setErrorCode(self, 1); + obj_setSysOut(self, "[error] uart init faild."); + return; + } + HAL_UART_Receive_IT(getUartHandle(id), (uint8_t*)getUartRxBuff(id), 1); +} + +char* STM32_UART_platformRead(PikaObj* self, int id, int length) { + Args* buffs = New_strBuff(); + char* readBuff = NULL; + pika_uart_t* pika_uart = getPikaUart(id); + if (length >= pika_uart->rxBuffOffset) { + /* not enough str */ + length = pika_uart->rxBuffOffset; + } + readBuff = args_getBuff(buffs, length); + memcpy(readBuff, pika_uart->rxBuff, length); + obj_setStr(self, "readBuff", readBuff); + readBuff = obj_getStr(self, "readBuff"); + + /* update rxBuff */ + memcpy(pika_uart->rxBuff, pika_uart->rxBuff + length, + pika_uart->rxBuffOffset - length); + pika_uart->rxBuffOffset -= length; + pika_uart->rxBuff[pika_uart->rxBuffOffset] = 0; + + UART_Start_Receive_IT( + &pika_uart->huart, + (uint8_t*)(pika_uart->rxBuff + pika_uart->rxBuffOffset), 1); +exit: + args_deinit(buffs); + return readBuff; +} + +void STM32_UART_platformWrite(PikaObj* self, char* data, int id) { + HAL_UART_Transmit(getUartHandle(id), (uint8_t*)data, strGetSize(data), 100); +} + +void STM32_UART_clearRxBuff(pika_uart_t* pika_uart) { + pika_uart->rxBuffOffset = 0; + pika_uart->rxBuff[pika_uart->rxBuffOffset] = 0; + UART_Start_Receive_IT( + &pika_uart->huart, + (uint8_t*)(pika_uart->rxBuff + pika_uart->rxBuffOffset), 1); +} + +/* Recive Interrupt Handler */ +void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) { + uint8_t id = getUartId(huart); + pika_uart_t* pika_uart = getPikaUart(id); + char inputChar = pika_uart->rxBuff[pika_uart->rxBuffOffset]; + + if ((id == 1) && ('\n' == inputChar)) { + uint8_t res = STM32_Code_reciveHandler(pika_uart->rxBuff, + pika_uart->rxBuffOffset + 1); + /* handler is working */ + if (0 != res) { + STM32_UART_clearRxBuff(pika_uart); + return; + } + } + /* avoid recive buff overflow */ + if (pika_uart->rxBuffOffset + 2 > RX_BUFF_LENGTH) { + memmove(pika_uart->rxBuff, pika_uart->rxBuff + 1, RX_BUFF_LENGTH); + UART_Start_Receive_IT( + huart, (uint8_t*)(pika_uart->rxBuff + pika_uart->rxBuffOffset), 1); + return; + } + + /* recive next char */ + pika_uart->rxBuffOffset++; + pika_uart->rxBuff[pika_uart->rxBuffOffset] = 0; + UART_Start_Receive_IT( + huart, (uint8_t*)(pika_uart->rxBuff + pika_uart->rxBuffOffset), 1); +} + +/* support prinf */ +int fputc(int ch, FILE* f) { + HAL_UART_Transmit(&pika_uart1.huart, (uint8_t*)&ch, 1, 0xffff); + return ch; +} + +/* support scanf */ +int fgetc(FILE* f) { + uint8_t ch = 0; + HAL_UART_Receive(&pika_uart1.huart, &ch, 1, 0xffff); + return ch; +} \ No newline at end of file diff --git a/package/STM32/STM32_common.c b/package/STM32/STM32_common.c new file mode 100644 index 000000000..f0b984ac5 --- /dev/null +++ b/package/STM32/STM32_common.c @@ -0,0 +1,161 @@ +#include "STM32_common.h" +#include "dataStrs.h" + +void delay_unit(uint32_t delays) { + /* one unit is 1/64 us */ + uint32_t startval, tickn, wait; + + startval = SysTick->VAL; + tickn = HAL_GetTick(); + if (delays > startval) { + while (HAL_GetTick() == tickn) { + } + wait = 64000 + startval - delays; + while (wait < SysTick->VAL) { + } + } else { + wait = startval - delays; + while (wait < SysTick->VAL && HAL_GetTick() == tickn) { + } + } +} + +void delay_us(uint32_t udelay) { + uint32_t startval, tickn, delays, wait; + + startval = SysTick->VAL; + tickn = HAL_GetTick(); + delays = udelay * 64; // delay 1us when delays = 64 + if (delays > startval) { + while (HAL_GetTick() == tickn) { + } + wait = 64000 + startval - delays; + while (wait < SysTick->VAL) { + } + } else { + wait = startval - delays; + while (wait < SysTick->VAL && HAL_GetTick() == tickn) { + } + } +} + +GPIO_TypeDef* getGpioPort(char* pin) { + if (strIsStartWith(pin, "PA")) { + return GPIOA; + } + if (strIsStartWith(pin, "PB")) { + return GPIOB; + } + if (strIsStartWith(pin, "PC")) { + return GPIOC; + } + if (strIsStartWith(pin, "PD")) { + return GPIOD; + } + return NULL; +} + +uint16_t getGpioPin(char* pin) { + Args* buffs = New_strBuff(); + uint16_t gpioPin = 0; + + pin = strsCopy(buffs, pin + 2); + if (strEqu(pin, "0")) { + gpioPin = GPIO_PIN_0; + goto exit; + } + if (strEqu(pin, "1")) { + gpioPin = GPIO_PIN_1; + goto exit; + } + if (strEqu(pin, "2")) { + gpioPin = GPIO_PIN_2; + goto exit; + } + if (strEqu(pin, "3")) { + gpioPin = GPIO_PIN_3; + goto exit; + } + if (strEqu(pin, "4")) { + gpioPin = GPIO_PIN_4; + goto exit; + } + if (strEqu(pin, "5")) { + gpioPin = GPIO_PIN_5; + goto exit; + } + if (strEqu(pin, "6")) { + gpioPin = GPIO_PIN_6; + goto exit; + } + if (strEqu(pin, "7")) { + gpioPin = GPIO_PIN_7; + goto exit; + } + if (strEqu(pin, "8")) { + gpioPin = GPIO_PIN_8; + goto exit; + } + if (strEqu(pin, "9")) { + gpioPin = GPIO_PIN_9; + goto exit; + } + if (strEqu(pin, "10")) { + gpioPin = GPIO_PIN_10; + goto exit; + } + if (strEqu(pin, "11")) { + gpioPin = GPIO_PIN_11; + goto exit; + } + if (strEqu(pin, "12")) { + gpioPin = GPIO_PIN_12; + goto exit; + } + if (strEqu(pin, "13")) { + gpioPin = GPIO_PIN_13; + goto exit; + } + if (strEqu(pin, "14")) { + gpioPin = GPIO_PIN_14; + goto exit; + } + if (strEqu(pin, "15")) { + gpioPin = GPIO_PIN_15; + goto exit; + } + +exit: + args_deinit(buffs); + return gpioPin; +} + +uint32_t getPinMode(char* mode) { + if (strEqu(mode, "out")) { + return GPIO_MODE_OUTPUT_PP; + } + if (strEqu(mode, "in")) { + return GPIO_MODE_INPUT; + } + return NULL; +} + +uint8_t enableClk(char* pin) { + if (strIsStartWith(pin, "PA")) { + __HAL_RCC_GPIOA_CLK_ENABLE(); + return 0; + } + if (strIsStartWith(pin, "PB")) { + __HAL_RCC_GPIOB_CLK_ENABLE(); + return 0; + } + if (strIsStartWith(pin, "PC")) { + __HAL_RCC_GPIOC_CLK_ENABLE(); + return 0; + } + if (strIsStartWith(pin, "PD")) { + __HAL_RCC_GPIOD_CLK_ENABLE(); + return 0; + } + return 1; +} \ No newline at end of file diff --git a/package/STM32/STM32_common.h b/package/STM32/STM32_common.h new file mode 100644 index 000000000..9a2c1b999 --- /dev/null +++ b/package/STM32/STM32_common.h @@ -0,0 +1,75 @@ +#ifndef __STM32__COMMON__H +#define __STM32__COMMON__H +#include "PikaObj.h" + +#ifdef STM32G070xx +#include "stm32g0xx_hal.h" +#define UART1_EXIST +#define UART2_EXIST +#define UART3_EXIST +#define UART4_EXIST +#endif + +#ifdef STM32F103xB +#include "stm32f1xx_hal.h" +#define UART1_EXIST +#define UART2_EXIST +#define UART3_EXIST + +#define TIM1_EXIST +#define TIM2_EXIST +#define TIM3_EXIST +#define TIM4_EXIST +#endif + +#ifdef STM32G030xx +#include "stm32g0xx_hal.h" +#define UART1_EXIST +#define UART2_EXIST + +#define TIM1_EXIST +#define TIM3_EXIST +#define TIM14_EXIST +#define TIM16_EXIST +#define TIM17_EXIST +#endif + +#define RX_BUFF_LENGTH 64 + +#define FLASH_CODE_START_ADDR \ + (FLASH_BASE + \ + ((FLASH_PAGE_NB - 1) * FLASH_PAGE_SIZE)) /* Start @ of user Flash area */ +#define FLASH_USER_END_ADDR \ + (FLASH_BASE + FLASH_SIZE - 1) /* End @ of user Flash area */ +uint32_t GetPage(uint32_t Addr); +#define DATA_64 ((uint64_t)0x1234567812345678) +#define DATA_32 ((uint32_t)0x12345678) + +typedef struct { + UART_HandleTypeDef huart; + uint8_t id; + char rxBuff[RX_BUFF_LENGTH]; + uint16_t rxBuffOffset; + PikaObj* obj; +} pika_uart_t; + +typedef struct _CodeHeap{ + char *content; + uint32_t size; + uint8_t ena; + uint32_t reciveTime; + + uint32_t oldSize; +}CodeHeap; + +GPIO_TypeDef* getGpioPort(char* pin); +uint16_t getGpioPin(char* pin); +uint32_t getPinMode(char* mode); +uint8_t enableClk(char* pin); +void delay_us(uint32_t delay); +void delay_unit(uint32_t delay); +void STM32_UART_clearRxBuff(pika_uart_t* pika_uart); +uint8_t STM32_Code_reciveHandler(char *data, uint32_t rxSize); +void STM32_Code_Init(); +void STM32_Code_flashHandler(); +#endif \ No newline at end of file diff --git a/packages/packages.toml b/packages/packages.toml deleted file mode 100644 index 9a89c5094..000000000 --- a/packages/packages.toml +++ /dev/null @@ -1,3 +0,0 @@ -[[package]] -name = "STM32" -