From c0fd4fb10a4a931fedf2d68c5e8ba63f1f635cf9 Mon Sep 17 00:00:00 2001 From: Edward Emelianov Date: Thu, 27 Oct 2022 11:33:02 +0300 Subject: [PATCH] Add full ringbuffer @PL2303 --- F0:F030,F042,F072/PL2303_ringbuffer/Makefile | 154 +++++++ .../PL2303_ringbuffer/PL2303.bin | Bin 0 -> 6576 bytes .../PL2303_ringbuffer/hardware.c | 35 ++ .../PL2303_ringbuffer/hardware.h | 43 ++ F0:F030,F042,F072/PL2303_ringbuffer/main.c | 57 +++ .../PL2303_ringbuffer/openocd.cfg | 96 +++++ F0:F030,F042,F072/PL2303_ringbuffer/proto.c | 273 +++++++++++++ F0:F030,F042,F072/PL2303_ringbuffer/proto.h | 31 ++ .../PL2303_ringbuffer/ringbuffer.c | 124 ++++++ .../PL2303_ringbuffer/ringbuffer.h | 39 ++ F0:F030,F042,F072/PL2303_ringbuffer/usb.c | 158 ++++++++ F0:F030,F042,F072/PL2303_ringbuffer/usb.h | 36 ++ F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.c | 381 ++++++++++++++++++ F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.h | 184 +++++++++ F0:F030,F042,F072/PL2303_ringbuffer/usbhw.c | 128 ++++++ F0:F030,F042,F072/PL2303_ringbuffer/usbhw.h | 104 +++++ .../PL2303_ringbuffer/version.inc | 2 + 17 files changed, 1845 insertions(+) create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/Makefile create mode 100755 F0:F030,F042,F072/PL2303_ringbuffer/PL2303.bin create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/hardware.c create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/hardware.h create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/main.c create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/openocd.cfg create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/proto.c create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/proto.h create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.c create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.h create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/usb.c create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/usb.h create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.c create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.h create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/usbhw.c create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/usbhw.h create mode 100644 F0:F030,F042,F072/PL2303_ringbuffer/version.inc diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/Makefile b/F0:F030,F042,F072/PL2303_ringbuffer/Makefile new file mode 100644 index 0000000..b6f4bf4 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/Makefile @@ -0,0 +1,154 @@ +BINARY = PL2303 +BOOTPORT ?= /dev/ttyUSB0 +BOOTSPEED ?= 115200 +INDEPENDENT_HEADERS= +# MCU FAMILY +FAMILY ?= F0 +# MCU code +MCU ?= F042x6 +# change this linking script depending on particular MCU model, +LDSCRIPT ?= stm32f042x6.ld + +# autoincremental version & build date +VERSION_FILE = version.inc +NEXTVER := $(shell expr $$(awk '/#define BUILD_NUMBER/' $(VERSION_FILE) | tr -cd "[0-9]") + 1) +BUILDDATE := $(shell date +%Y-%m-%d) + +FP_FLAGS ?= -msoft-float +# -mfloat-abi=soft +ASM_FLAGS ?= -mthumb -mcpu=cortex-m0 -march=armv6-m -mtune=cortex-m0 +ARCH_FLAGS = $(ASM_FLAGS) $(FP_FLAGS) + +############################################################################### +# Executables +#PREFIX ?= arm-none-eabi +# gcc from arm web site +PREFIX ?= /opt/bin/arm-none-eabi +TOOLCHLIB ?= /opt/arm-none-eabi/lib +RM := rm -f +RMDIR := rmdir +CC := $(PREFIX)-gcc +LD := $(PREFIX)-gcc +AR := $(PREFIX)-ar +AS := $(PREFIX)-as +SIZE := $(PREFIX)-size +OBJCOPY := $(PREFIX)-objcopy +OBJDUMP := $(PREFIX)-objdump +GDB := $(PREFIX)-gdb +STFLASH := $(shell which st-flash) +STBOOT := $(shell which stm32flash) +DFUUTIL := $(shell which dfu-util) + +############################################################################### +# Source files +OBJDIR := mk +SRC := $(wildcard *.c) +OBJS := $(addprefix $(OBJDIR)/, $(SRC:%.c=%.o)) +STARTUP = $(OBJDIR)/startup.o +OBJS += $(STARTUP) +MAP = $(OBJDIR)/$(BINARY).map +# dependencies: we need them to recompile files if their headers-dependencies changed +DEPS := $(OBJS:.o=.d) + +INC_DIR ?= ../inc + +INCLUDE := -I$(INC_DIR)/Fx -I$(INC_DIR)/cm +LIB_DIR := $(INC_DIR)/ld + +############################################################################### +# C flags +CFLAGS += -O2 -g -MD -D__thumb2__=1 +CFLAGS += -Wall -Werror -Wextra -Wshadow -Wimplicit-function-declaration -Wredundant-decls +CFLAGS += -fno-common -ffunction-sections -fdata-sections +# -fno-stack-protector -fshort-enums +CFLAGS += $(ARCH_FLAGS) $(INCLUDE) + +############################################################################### +# Linker flags +LDFLAGS += -nostartfiles --static -Wl,--print-memory-usage +# --specs=nano.specs -nostdlib +LDFLAGS += -Wl,-Map=$(MAP) -Wl,--gc-sections +LDFLAGS += -L$(LIB_DIR) -L$(TOOLCHLIB) +LDFLAGS += -T$(LDSCRIPT) $(ARCH_FLAGS) + +############################################################################### +# Used libraries +LDLIBS += -Wl,--start-group -lc -lgcc -Wl,--end-group $(shell $(CC) $(CFLAGS) -print-libgcc-file-name) + +DEFS += -DSTM32$(FAMILY) -DSTM32$(MCU) + +ELF := $(OBJDIR)/$(BINARY).elf +LIST := $(OBJDIR)/$(BINARY).list +BIN := $(BINARY).bin +HEX := $(BINARY).hex + +all: bin list size + +elf: $(ELF) +bin: $(BIN) +hex: $(HEX) +list: $(LIST) + +ifneq ($(MAKECMDGOALS),clean) +-include $(DEPS) +endif + +$(OBJDIR): + mkdir $(OBJDIR) + +$(STARTUP): $(INC_DIR)/startup/vector.c + $(CC) $(CFLAGS) $(DEFS) $(INCLUDE) -o $@ -c $< + +$(VERSION_FILE): *.[ch] + @echo " Generate version: $(NEXTVER) for date $(BUILDDATE)" + @sed -i "s/#define BUILD_NUMBER.*/#define BUILD_NUMBER \"$(NEXTVER)\"/" $(VERSION_FILE) + @sed -i "s/#define BUILD_DATE.*/#define BUILD_DATE \"$(BUILDDATE)\"/" $(VERSION_FILE) + +$(OBJDIR)/proto.o: proto.c $(VERSION_FILE) + +$(OBJDIR)/%.o: %.c + @echo " CC $<" + $(CC) $(CFLAGS) $(DEFS) $(INCLUDE) -o $@ -c $< + +$(BIN): $(ELF) + @echo " OBJCOPY $(BIN)" + $(OBJCOPY) -Obinary $(ELF) $(BIN) + +$(HEX): $(ELF) + @echo " OBJCOPY $(HEX)" + $(OBJCOPY) -Oihex $(ELF) $(HEX) + +$(LIST): $(ELF) + @echo " OBJDUMP $(LIST)" + $(OBJDUMP) -S $(ELF) > $(LIST) + +$(ELF): $(OBJDIR) $(OBJS) + @echo " LD $(ELF)" + $(LD) $(LDFLAGS) $(OBJS) $(LDLIBS) -o $(ELF) + +size: $(ELF) + $(SIZE) $(ELF) + +clean: + @echo " CLEAN" + $(RM) $(OBJS) $(DEPS) $(ELF) $(HEX) $(LIST) $(MAP) + @rmdir $(OBJDIR) 2>/dev/null || true + +flash: $(BIN) + @echo " FLASH $(BIN)" + $(STFLASH) --reset write $(BIN) 0x8000000 + +boot: $(BIN) + @echo " LOAD $(BIN) through bootloader" + $(STBOOT) -b$(BOOTSPEED) $(BOOTPORT) -w $(BIN) + +dfuboot: $(BIN) + @echo " LOAD $(BIN) THROUGH DFU" + $(DFUUTIL) -a0 -D $(BIN) -s 0x08000000 + +openocd: + openocd -f openocd.cfg +dbg: + arm-none-eabi-gdb $(ELF) -ex 'target remote localhost:3333' -ex 'monitor reset halt' + +.PHONY: clean flash boot dfuboot size dbg openocd diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/PL2303.bin b/F0:F030,F042,F072/PL2303_ringbuffer/PL2303.bin new file mode 100755 index 0000000000000000000000000000000000000000..2ccd7a8a944d2a728decdc5c37e3bb3710d003c2 GIT binary patch literal 6576 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 literal 0 HcmV?d00001 diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/hardware.c b/F0:F030,F042,F072/PL2303_ringbuffer/hardware.c new file mode 100644 index 0000000..7a1c8f2 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/hardware.c @@ -0,0 +1,35 @@ +/* + * This file is part of the pl2303 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "hardware.h" + +static inline void gpio_setup(){ + // here we turn on clocking for all periph. + RCC->AHBENR |= RCC_AHBENR_GPIOBEN; + LED_off(LED0); + LED_off(LED1); + // Set LEDs (PB0/1) as output + GPIOB->MODER = (GPIOB->MODER & ~(GPIO_MODER_MODER0 | GPIO_MODER_MODER1) + ) | + GPIO_MODER_MODER0_O | GPIO_MODER_MODER1_O; +} + +void hw_setup(){ + gpio_setup(); +} + diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/hardware.h b/F0:F030,F042,F072/PL2303_ringbuffer/hardware.h new file mode 100644 index 0000000..8238952 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/hardware.h @@ -0,0 +1,43 @@ +/* + * This file is part of the pl2303 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once +#ifndef __HARDWARE_H__ +#define __HARDWARE_H__ + +#include + +#define CONCAT(a,b) a ## b +#define STR_HELPER(s) #s +#define STR(s) STR_HELPER(s) + +// LED0 - PB0, blinking each second; LED1 - PB1 +#define LED0_port GPIOB +#define LED0_pin (1<<0) +#define LED1_port GPIOB +#define LED1_pin (1<<1) + +#define LED_blink(x) pin_toggle(x ## _port, x ## _pin) +#define LED_on(x) pin_clear(x ## _port, x ## _pin) +#define LED_off(x) pin_set(x ## _port, x ## _pin) + +extern volatile uint32_t Tms; + +void hw_setup(); + +#endif // __HARDWARE_H__ diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/main.c b/F0:F030,F042,F072/PL2303_ringbuffer/main.c new file mode 100644 index 0000000..5af86c4 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/main.c @@ -0,0 +1,57 @@ +/* + * This file is part of the pl2303 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "hardware.h" +#include "proto.h" +#include "ringbuffer.h" +#include "usb.h" + +#define MAXSTRLEN 128 +static char inbuff[MAXSTRLEN]; + +volatile uint32_t Tms = 0; + +void sys_tick_handler(void){ + ++Tms; +} + +int main(void){ + sysreset(); + SysTick_Config(6000, 1); + hw_setup(); + USB_setup(); + + uint32_t ctr = Tms, msgctr = Tms; + while(1){ + if(Tms - ctr > 499){ + ctr = Tms; + LED_blink(LED0); + } + if(Tms - msgctr > 3999){ + msgctr = Tms; + USB_sendstr("Test ping message\n"); + } + USB_proc(); + int len = USB_receivestr(inbuff, MAXSTRLEN); + if(len < 0) USB_sendstr("ERROR: USB buffer overflow or string was too long\n"); + else if(len){ + const char *ans = parse_cmd(inbuff); + if(ans) USB_sendstr(ans); + } + } +} diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/openocd.cfg b/F0:F030,F042,F072/PL2303_ringbuffer/openocd.cfg new file mode 100644 index 0000000..4d268f6 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/openocd.cfg @@ -0,0 +1,96 @@ +# script for stm32f0x family + +# +# stm32 devices support SWD transports only. +# +source [find interface/stlink-v2-1.cfg] +source [find target/swj-dp.tcl] +source [find mem_helper.tcl] + +if { [info exists CHIPNAME] } { + set _CHIPNAME $CHIPNAME +} else { + set _CHIPNAME stm32f0x +} + +set _ENDIAN little + +# Work-area is a space in RAM used for flash programming +# By default use 4kB +if { [info exists WORKAREASIZE] } { + set _WORKAREASIZE $WORKAREASIZE +} else { + set _WORKAREASIZE 0x1000 +} + +# Allow overriding the Flash bank size +if { [info exists FLASH_SIZE] } { + set _FLASH_SIZE $FLASH_SIZE +} else { + # autodetect size + set _FLASH_SIZE 0 +} + +#jtag scan chain +if { [info exists CPUTAPID] } { + set _CPUTAPID $CPUTAPID +} else { + # See STM Document RM0091 + # Section 29.5.3 + set _CPUTAPID 0x0bb11477 +} + +swj_newdap $_CHIPNAME cpu -irlen 4 -ircapture 0x1 -irmask 0xf -expected-id $_CPUTAPID +dap create $_CHIPNAME.dap -chain-position $_CHIPNAME.cpu + +set _TARGETNAME $_CHIPNAME.cpu +target create $_TARGETNAME cortex_m -endian $_ENDIAN -dap $_CHIPNAME.dap + +$_TARGETNAME configure -work-area-phys 0x20000000 -work-area-size $_WORKAREASIZE -work-area-backup 0 + +# flash size will be probed +set _FLASHNAME $_CHIPNAME.flash +flash bank $_FLASHNAME stm32f1x 0x08000000 $_FLASH_SIZE 0 0 $_TARGETNAME + +# adapter speed should be <= F_CPU/6. F_CPU after reset is 8MHz, so use F_JTAG = 1MHz +adapter speed 1000 + +adapter srst delay 100 + +reset_config srst_nogate + +if {![using_hla]} { + # if srst is not fitted use SYSRESETREQ to + # perform a soft reset + cortex_m reset_config sysresetreq +} + +proc stm32f0x_default_reset_start {} { + # Reset clock is HSI (8 MHz) + adapter speed 1000 +} + +proc stm32f0x_default_examine_end {} { + # Enable debug during low power modes (uses more power) + mmw 0x40015804 0x00000006 0 ;# DBGMCU_CR |= DBG_STANDBY | DBG_STOP + + # Stop watchdog counters during halt + mmw 0x40015808 0x00001800 0 ;# DBGMCU_APB1_FZ |= DBG_IWDG_STOP | DBG_WWDG_STOP +} + +proc stm32f0x_default_reset_init {} { + # Configure PLL to boost clock to HSI x 6 (48 MHz) + mww 0x40021004 0x00100000 ;# RCC_CFGR = PLLMUL[2] + mmw 0x40021000 0x01000000 0 ;# RCC_CR[31:16] |= PLLON + mww 0x40022000 0x00000011 ;# FLASH_ACR = PRFTBE | LATENCY[0] + sleep 10 ;# Wait for PLL to lock + mmw 0x40021004 0x00000002 0 ;# RCC_CFGR |= SW[1] + + # Boost JTAG frequency + adapter speed 8000 +} + +# Default hooks +$_TARGETNAME configure -event examine-end { stm32f0x_default_examine_end } +$_TARGETNAME configure -event reset-start { stm32f0x_default_reset_start } +$_TARGETNAME configure -event reset-init { stm32f0x_default_reset_init } diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/proto.c b/F0:F030,F042,F072/PL2303_ringbuffer/proto.c new file mode 100644 index 0000000..2e70caf --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/proto.c @@ -0,0 +1,273 @@ +/* + * This file is part of the pl2303 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "proto.h" +#include "ringbuffer.h" +#include "usb.h" +#include "version.inc" + +extern uint32_t Tms; + +const char *test = "123456789A123456789B123456789C123456789D123456789E123456789F123456789G123456789H123456789I123456789J123456789K123456789L123456789M123456789N123456789O123456789P123456789Q123456789R123456789S123456789T123456789U123456789V123456789W123456789X123456789Y"; + +char *omit_spaces(const char *buf){ + while(*buf){ + if(*buf > ' ') break; + ++buf; + } + return (char*)buf; +} + +// In case of overflow return `buf` and N==0xffffffff +// read decimal number & return pointer to next non-number symbol +static char *getdec(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + if(c < '0' || c > '9'){ + break; + } + if(num > 429496729 || (num == 429496729 && c > '5')){ // overflow + *N = 0xffffff; + return start; + } + num *= 10; + num += c - '0'; + ++buf; + } + *N = num; + return (char*)buf; +} +// read hexadecimal number (without 0x prefix!) +static char *gethex(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + uint8_t M = 0; + if(c >= '0' && c <= '9'){ + M = '0'; + }else if(c >= 'A' && c <= 'F'){ + M = 'A' - 10; + }else if(c >= 'a' && c <= 'f'){ + M = 'a' - 10; + } + if(M){ + if(num & 0xf0000000){ // overflow + *N = 0xffffff; + return start; + } + num <<= 4; + num += c - M; + }else{ + break; + } + ++buf; + } + *N = num; + return (char*)buf; +} +// read octal number (without 0 prefix!) +static char *getoct(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + if(c < '0' || c > '7'){ + break; + } + if(num & 0xe0000000){ // overflow + *N = 0xffffff; + return start; + } + num <<= 3; + num += c - '0'; + ++buf; + } + *N = num; + return (char*)buf; +} +// read binary number (without b prefix!) +static char *getbin(const char *buf, uint32_t *N){ + char *start = (char*)buf; + uint32_t num = 0; + while(*buf){ + char c = *buf; + if(c < '0' || c > '1'){ + break; + } + if(num & 0x80000000){ // overflow + *N = 0xffffff; + return start; + } + num <<= 1; + if(c == '1') num |= 1; + ++buf; + } + *N = num; + return (char*)buf; +} + +/** + * @brief getnum - read uint32_t from string (dec, hex or bin: 127, 0x7f, 0b1111111) + * @param buf - buffer with number and so on + * @param N - the number read + * @return pointer to first non-number symbol in buf + * (if it is == buf, there's no number or if *N==0xffffffff there was overflow) + */ +char *getnum(const char *txt, uint32_t *N){ + char *nxt = NULL; + char *s = omit_spaces(txt); + if(*s == '0'){ // hex, oct or 0 + if(s[1] == 'x' || s[1] == 'X'){ // hex + nxt = gethex(s+2, N); + if(nxt == s+2) nxt = (char*)txt; + }else if(s[1] > '0'-1 && s[1] < '8'){ // oct + nxt = getoct(s+1, N); + if(nxt == s+1) nxt = (char*)txt; + }else{ // 0 + nxt = s+1; + *N = 0; + } + }else if(*s == 'b' || *s == 'B'){ + nxt = getbin(s+1, N); + if(nxt == s+1) nxt = (char*)txt; + }else{ + nxt = getdec(s, N); + if(nxt == s) nxt = (char*)txt; + } + return nxt; +} + +const char* helpmsg = + "https://github.com/eddyem/stm32samples/tree/master/F0-nolib/PL2303_ringbuffer build#" BUILD_NUMBER " @ " BUILD_DATE "\n" + "'i' - print USB->ISTR state\n" + "'N' - read number (dec, 0xhex, 0oct, bbin) and show it in decimal\n" + "'R' - software reset\n" + "'T' - test usb sending a very large message\n" + "'U' - get USB status\n" +; + +static char stbuf[256], *bptr = NULL; +static int blen = 0; +static void initbuf(){bptr = stbuf; blen = 255; *bptr = 0;} +static void add2buf(const char *s){ + while(blen && *s){ + *bptr++ = *s++; + --blen; + } + *bptr = 0; +} + +extern uint8_t usbON; +const char *parse_cmd(const char *buf){ + uint32_t u3; + initbuf(); + if(buf[1] == '\n' || !buf[1]){ // one symbol commands + switch(*buf){ + case 'i': + add2buf("USB->ISTR="); + add2buf(u2hexstr(USB->ISTR)); + add2buf(", USB->CNTR="); + add2buf(u2hexstr(USB->CNTR)); + add2buf("\n"); + break; + case 'R': + USB_sendstr("Soft reset\n"); + USB_sendall(); + for(uint32_t i = 0; i < 48000000; ++i) nop(); + NVIC_SystemReset(); + break; + case 'T': + u3 = Tms; + for(int i = 0; i < 1000; ++i) USB_sendstr(test); + add2buf("\n\nspd="); + add2buf(u2str(2000000000/(Tms - u3))); add2buf("\n"); // strlen == 2Mbit, speed in bits per second + break; + case 'U': + add2buf("USB status: "); + if(usbON) add2buf("ON"); + else add2buf("OFF"); + add2buf("\n"); + break; + default: + return helpmsg; + } + return stbuf; + } + uint32_t Num = 0; + char *nxt; + switch(*buf){ // long messages + case 'N': + ++buf; + nxt = getnum(buf, &Num); + if(buf == nxt){ + if(Num == 0) return "Wrong number\n"; + return "Integer32 overflow\n"; + } + add2buf("You give: "); + add2buf(u2str(Num)); + if(*nxt && *nxt != '\n'){ + add2buf(", the rest of string: "); + add2buf(nxt); + }else add2buf("\n"); + break; + default: + return buf; + } + return stbuf; +} + + +// return string with number `val` +char *u2str(uint32_t val){ + static char strbuf[11]; + char *bufptr = &strbuf[10]; + *bufptr = 0; + if(!val){ + *(--bufptr) = '0'; + }else{ + while(val){ + *(--bufptr) = val % 10 + '0'; + val /= 10; + } + } + return bufptr; +} + +char *u2hexstr(uint32_t val){ + static char strbuf[11] = "0x"; + char *sptr = strbuf + 2; + uint8_t *ptr = (uint8_t*)&val + 3; + int8_t i, j, z=1; + for(i = 0; i < 4; ++i, --ptr){ + if(*ptr == 0){ // omit leading zeros + if(i == 3) z = 0; + if(z) continue; + } + else z = 0; + for(j = 1; j > -1; --j){ + uint8_t half = (*ptr >> (4*j)) & 0x0f; + if(half < 10) *sptr++ = half + '0'; + else *sptr++ = half - 10 + 'a'; + } + } + *sptr = 0; + return strbuf; +} diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/proto.h b/F0:F030,F042,F072/PL2303_ringbuffer/proto.h new file mode 100644 index 0000000..da8776b --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/proto.h @@ -0,0 +1,31 @@ +/* + * This file is part of the pl2303 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once +#ifndef PROTO_H__ +#define PROTO_H__ + +#include + +const char *parse_cmd(const char *buf); +char *omit_spaces(const char *buf); +char *getnum(const char *buf, uint32_t *N); +char *u2str(uint32_t val); +char *u2hexstr(uint32_t val); + +#endif // PROTO_H__ diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.c b/F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.c new file mode 100644 index 0000000..d70a9a7 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.c @@ -0,0 +1,124 @@ +/* + * This file is part of the pl2303 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "ringbuffer.h" + +// stored data length +int RB_datalen(ringbuffer *b){ + if(b->tail >= b->head) return (b->tail - b->head); + else return (b->length - b->head + b->tail); +} + +/** + * @brief RB_hasbyte - check if buffer has given byte stored + * @param b - buffer + * @param byte - byte to find + * @return index if found, -1 if none + */ +int RB_hasbyte(ringbuffer *b, uint8_t byte){ + if(b->head == b->tail) return -1; // no data in buffer + int startidx = b->head; + if(b->head > b->tail){ // + for(int found = b->head; found < b->length; ++found) + if(b->data[found] == byte) return found; + startidx = 0; + } + for(int found = startidx; found < b->tail; ++found) + if(b->data[found] == byte) return found; + return -1; +} + +// poor memcpy +static void mcpy(uint8_t *targ, const uint8_t *src, int l){ + while(l--) *targ++ = *src++; +} + +// increment head or tail +TRUE_INLINE void incr(ringbuffer *b, volatile int *what, int n){ + *what += n; + if(*what >= b->length) *what -= b->length; +} + +/** + * @brief RB_read - read data from ringbuffer + * @param b - buffer + * @param s - array to write data + * @param len - max len of `s` + * @return bytes read + */ +int RB_read(ringbuffer *b, uint8_t *s, int len){ + int l = RB_datalen(b); + if(!l) return 0; + if(l > len) l = len; + int _1st = b->length - b->head; + if(_1st > l) _1st = l; + if(_1st > len) _1st = len; + mcpy(s, b->data + b->head, _1st); + if(_1st < len && l > _1st){ + mcpy(s+_1st, b->data, l - _1st); + incr(b, &b->head, l); + return l; + } + incr(b, &b->head, _1st); + return _1st; +} + +/** + * @brief RB_readto fill array `s` with data until byte `byte` (with it) + * @param b - ringbuffer + * @param byte - check byte + * @param s - buffer to write data + * @param len - length of `s` + * @return amount of bytes written (negative, if lenhead; + // now calculate length of new data portion + if(idx < b->head) partlen += b->length; + if(partlen > len) return -RB_read(b, s, len); + return RB_read(b, s, partlen); +} + +/** + * @brief RB_write - write some data to ringbuffer + * @param b - buffer + * @param str - data + * @param l - length + * @return amount of bytes written + */ +int RB_write(ringbuffer *b, const uint8_t *str, int l){ + int r = b->length - 1 - RB_datalen(b); // rest length + if(l > r) l = r; + if(!l) return 0; + int _1st = b->length - b->tail; + if(_1st > l) _1st = l; + mcpy(b->data + b->tail, str, _1st); + if(_1st < l){ // add another piece from start + mcpy(b->data, str+_1st, l-_1st); + } + incr(b, &b->tail, l); + return l; +} + +// just delete all information in buffer `b` +void RB_clearbuf(ringbuffer *b){ + b->head = 0; + b->tail = 0; +} diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.h b/F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.h new file mode 100644 index 0000000..2c04863 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/ringbuffer.h @@ -0,0 +1,39 @@ +/* + * This file is part of the pl2303 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once +#ifndef RINGBUFFER_H__ +#define RINGBUFFER_H__ + +#include + +typedef struct{ + uint8_t *data; // data buffer + const int length; // its length + int head; // head index + int tail; // tail index +} ringbuffer; + +int RB_read(ringbuffer *b, uint8_t *s, int len); +int RB_readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len); +int RB_hasbyte(ringbuffer *b, uint8_t byte); +int RB_write(ringbuffer *b, const uint8_t *str, int l); +int RB_datalen(ringbuffer *b); +void RB_clearbuf(ringbuffer *b); + +#endif // RINGBUFFER_H__ diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/usb.c b/F0:F030,F042,F072/PL2303_ringbuffer/usb.c new file mode 100644 index 0000000..e5ef3a1 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/usb.c @@ -0,0 +1,158 @@ +/* + * This file is part of the MLX90640 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +// USB read/write for text or binary data through ring-buffers (mean 5187476b/s) + +#include "ringbuffer.h" +#include "usb.h" +#include "usb_lib.h" + +static uint8_t usbbuff[USB_TXBUFSZ]; // temporary buffer for sending data +// ring buffers for incoming and outgoing data +static uint8_t obuf[RBOUTSZ], ibuf[RBINSZ]; +static ringbuffer out = {.data = obuf, .length = RBOUTSZ, .head = 0, .tail = 0}; +static ringbuffer in = {.data = ibuf, .length = RBINSZ, .head = 0, .tail = 0}; +// transmission is succesfull +static volatile uint8_t tx_succesfull = 1; +static volatile uint8_t bufovrfl = 0; + +static void send_next(){ + if(!tx_succesfull) return; + static int lastdsz = 0; + int buflen = RB_read(&out, usbbuff, USB_TXBUFSZ); + if(!buflen){ + if(lastdsz == 64) EP_Write(3, NULL, 0); // send ZLP after 64 bits packet when nothing more to send + lastdsz = 0; + return; + } + tx_succesfull = 0; + EP_Write(3, usbbuff, buflen); + lastdsz = buflen; +} + +// send full content of ring buffer +int USB_sendall(){ + while(RB_datalen(&out)){ + send_next(); + if(!usbON) return 0; + } + return 1; +} + +// put `buf` into queue to send +int USB_send(const uint8_t *buf, int len){ + if(!buf || !usbON || !len) return 0; + while(len){ + if(tx_succesfull) send_next(); + int a = RB_write(&out, buf, len); + len -= a; + buf += a; + } + return 1; +} + +int USB_sendstr(const char *string){ + if(!string || !usbON) return 0; + int len = 0; + const char *b = string; + while(*b++) ++len; + if(!len) return 0; + return USB_send((const uint8_t*)string, len); +} + +/** + * @brief USB_receive - get binary data from receiving ring-buffer + * @param buf (i) - buffer[64] for received data + * @return amount of received bytes (negative, if overfull happened) + */ +int USB_receive(uint8_t *buf, int len){ + int sz = RB_read(&in, buf, len); + if(bufovrfl){ + RB_clearbuf(&in); + sz = -sz; + bufovrfl = 0; + } + return sz; +} + +/** + * @brief USB_receivestr - get string up to '\n' and replace '\n' with 0 + * @param buf - receiving buffer + * @param len - its length + * @return strlen or negative value indicating overflow (if so, string won't be ends with 0 and buffer should be cleared) + */ +int USB_receivestr(char *buf, int len){ + int l = RB_readto(&in, '\n', (uint8_t*)buf, len); + if(l < 0 || bufovrfl) RB_clearbuf(&in); + else buf[l] = 0; // replace '\n' with strend + if(bufovrfl){ + if(l > 0) l = -l; + bufovrfl = 0; + } + return l; +} + +// interrupt IN handler (never used?) +static void EP1_Handler(){ + uint16_t epstatus = KEEP_DTOG(USB->EPnR[1]); + if(RX_FLAG(epstatus)) epstatus = (epstatus & ~USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_RX; // set valid RX + else epstatus = epstatus & ~(USB_EPnR_STAT_TX|USB_EPnR_STAT_RX); + // clear CTR + epstatus = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX)); + USB->EPnR[1] = epstatus; +} + +// data IN/OUT handlers +static void transmit_Handler(){ // EP3IN + tx_succesfull = 1; + uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[3]); + // clear CTR keep DTOGs & STATs + USB->EPnR[3] = (epstatus & ~(USB_EPnR_CTR_TX)); // clear TX ctr +} + +static void receive_Handler(){ // EP2OUT + uint16_t epstatus = KEEP_DTOG(USB->EPnR[2]); + uint8_t sz = endpoints[2].rx_cnt; + if(sz){ + if(RB_write(&in, endpoints[2].rx_buf, sz) != sz) bufovrfl = 1; + } + // keep stat_tx & set ACK rx, clear RX ctr + USB->EPnR[2] = (epstatus & ~USB_EPnR_CTR_RX) ^ USB_EPnR_STAT_RX; +} + +void USB_proc(){ + switch(USB_Dev.USB_Status){ + case USB_STATE_CONFIGURED: + // make new BULK endpoint + // Buffer have 1024 bytes, but last 256 we use for CAN bus (30.2 of RM: USB main features) + EP_Init(1, EP_TYPE_INTERRUPT, USB_EP1BUFSZ, 0, EP1_Handler); // IN1 - transmit + EP_Init(2, EP_TYPE_BULK, 0, USB_RXBUFSZ, receive_Handler); // OUT2 - receive data + EP_Init(3, EP_TYPE_BULK, USB_TXBUFSZ, 0, transmit_Handler); // IN3 - transmit data + USB_Dev.USB_Status = USB_STATE_CONNECTED; + break; + case USB_STATE_DEFAULT: + case USB_STATE_ADDRESSED: + if(usbON){ + usbON = 0; + } + break; + default: // USB_STATE_CONNECTED - send next data portion + if(!usbON) return; + if(tx_succesfull) send_next(); + } +} diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/usb.h b/F0:F030,F042,F072/PL2303_ringbuffer/usb.h new file mode 100644 index 0000000..df70e73 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/usb.h @@ -0,0 +1,36 @@ +/* + * This file is part of the MLX90640 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once +#ifndef __USB_H__ +#define __USB_H__ + +#include "usbhw.h" + +// sizes of ringbuffers for outgoing and incoming data +#define RBOUTSZ (512) +#define RBINSZ (512) + +void USB_proc(); +int USB_sendall(); +int USB_send(const uint8_t *buf, int len); +int USB_sendstr(const char *string); +int USB_receive(uint8_t *buf, int len); +int USB_receivestr(char *buf, int len); + +#endif // __USB_H__ diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.c b/F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.c new file mode 100644 index 0000000..611c347 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.c @@ -0,0 +1,381 @@ +/* + * This file is part of the MLX90640 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include "usb_lib.h" + +ep_t endpoints[STM32ENDPOINTS]; + +usb_dev_t USB_Dev; +static usb_LineCoding lineCoding = {115200, 0, 0, 8}; +config_pack_t setup_packet; +uint8_t ep0databuf[EP0DATABUF_SIZE]; +//uint8_t ep0dbuflen = 0; + +usb_LineCoding getLineCoding(){return lineCoding;} + +uint8_t usbON = 0; // device disconnected from terminal + +// definition of parts common for USB_DeviceDescriptor & USB_DeviceQualifierDescriptor +#define bcdUSB_L 0x10 +#define bcdUSB_H 0x01 +#define bDeviceClass 0 +#define bDeviceSubClass 0 +#define bDeviceProtocol 0 +#define bNumConfigurations 1 + +static const uint8_t USB_DeviceDescriptor[] = { + 18, // bLength + 0x01, // bDescriptorType - Device descriptor + bcdUSB_L, // bcdUSB_L - 1.10 + bcdUSB_H, // bcdUSB_H + bDeviceClass, // bDeviceClass - USB_COMM + bDeviceSubClass, // bDeviceSubClass + bDeviceProtocol, // bDeviceProtocol + USB_EP0_BUFSZ, // bMaxPacketSize + 0x7b, // idVendor_L PL2303: VID=0x067b, PID=0x2303 + 0x06, // idVendor_H + 0x03, // idProduct_L + 0x23, // idProduct_H + 0x00, // bcdDevice_Ver_L + 0x03, // bcdDevice_Ver_H + 0x01, // iManufacturer + 0x02, // iProduct + 0x00, // iSerialNumber + bNumConfigurations // bNumConfigurations +}; + +static const uint8_t USB_DeviceQualifierDescriptor[] = { + 10, //bLength + 0x06, // bDescriptorType - Device qualifier + bcdUSB_L, // bcdUSB_L + bcdUSB_H, // bcdUSB_H + bDeviceClass, // bDeviceClass + bDeviceSubClass, // bDeviceSubClass + bDeviceProtocol, // bDeviceProtocol + USB_EP0_BUFSZ, // bMaxPacketSize0 + bNumConfigurations, // bNumConfigurations + 0x00 // Reserved +}; + +static const uint8_t USB_ConfigDescriptor[] = { + /*Configuration Descriptor*/ + 0x09, /* bLength: Configuration Descriptor size */ + 0x02, /* bDescriptorType: Configuration */ + 39, /* wTotalLength:no of returned bytes */ + 0x00, + 0x01, /* bNumInterfaces: 1 interface */ + 0x01, /* bConfigurationValue: Configuration value */ + 0x00, /* iConfiguration: Index of string descriptor describing the configuration */ + 0xa0, /* bmAttributes - Bus powered, Remote wakeup */ + 0x32, /* MaxPower 100 mA */ + + /*---------------------------------------------------------------------------*/ + + /*Interface Descriptor */ + 0x09, /* bLength: Interface Descriptor size */ + 0x04, /* bDescriptorType: Interface */ + 0x00, /* bInterfaceNumber: Number of Interface */ + 0x00, /* bAlternateSetting: Alternate setting */ + 0x03, /* bNumEndpoints: 3 endpoints used */ + 0xff, /* bInterfaceClass */ + 0x00, /* bInterfaceSubClass */ + 0x00, /* bInterfaceProtocol */ + 0x00, /* iInterface: */ +/////////////////////////////////////////////////// + /*Endpoint 1 Descriptor*/ + 0x07, /* bLength: Endpoint Descriptor size */ + 0x05, /* bDescriptorType: Endpoint */ + 0x81, /* bEndpointAddress IN1 */ + 0x03, /* bmAttributes: Interrupt */ + 0x0a, /* wMaxPacketSize LO: */ + 0x00, /* wMaxPacketSize HI: */ + 0x01, /* bInterval: */ + + /*Endpoint OUT2 Descriptor*/ + 0x07, /* bLength: Endpoint Descriptor size */ + 0x05, /* bDescriptorType: Endpoint */ + 0x02, /* bEndpointAddress: OUT2 */ + 0x02, /* bmAttributes: Bulk */ + (USB_RXBUFSZ & 0xff), /* wMaxPacketSize: 64 */ + (USB_RXBUFSZ >> 8), + 0x00, /* bInterval: ignore for Bulk transfer */ + + /*Endpoint IN3 Descriptor*/ + 0x07, /* bLength: Endpoint Descriptor size */ + 0x05, /* bDescriptorType: Endpoint */ + 0x83, /* bEndpointAddress IN3 */ + 0x02, /* bmAttributes: Bulk */ + (USB_TXBUFSZ & 0xff), /* wMaxPacketSize: 64 */ + (USB_TXBUFSZ >> 8), + 0x00, /* bInterval: ignore for Bulk transfer */ +}; + +_USB_LANG_ID_(USB_StringLangDescriptor, LANG_US); +// these descriptors are not used in PL2303 emulator! +_USB_STRING_(USB_StringSerialDescriptor, u"0"); +_USB_STRING_(USB_StringManufacturingDescriptor, u"Prolific Technology Inc."); +_USB_STRING_(USB_StringProdDescriptor, u"USB-Serial Controller"); + +/* + * default handlers + */ +// SET_LINE_CODING +void WEAK linecoding_handler(usb_LineCoding __attribute__((unused)) *lc){ +} + +// SET_CONTROL_LINE_STATE +void WEAK clstate_handler(uint16_t __attribute__((unused)) val){ +} + +// SEND_BREAK +void WEAK break_handler(){ +} + +// handler of vendor requests +void WEAK vendor_handler(config_pack_t *packet){ + if(packet->bmRequestType & 0x80){ // read + uint8_t c; + switch(packet->wValue){ + case 0x8484: + c = 2; + break; + case 0x0080: + c = 1; + break; + case 0x8686: + c = 0xaa; + break; + default: + c = 0; + } + EP_WriteIRQ(0, &c, 1); + }else{ // write ZLP + EP_WriteIRQ(0, (uint8_t *)0, 0); + } +} + +static void wr0(const uint8_t *buf, uint16_t size){ + if(setup_packet.wLength < size) size = setup_packet.wLength; // shortened request + if(size < endpoints[0].txbufsz){ + EP_WriteIRQ(0, buf, size); + return; + } + while(size){ + uint16_t l = size; + if(l > endpoints[0].txbufsz) l = endpoints[0].txbufsz; + EP_WriteIRQ(0, buf, l); + buf += l; + size -= l; + uint8_t needzlp = (l == endpoints[0].txbufsz) ? 1 : 0; + if(size || needzlp){ // send last data buffer + uint16_t status = KEEP_DTOG(USB->EPnR[0]); + // keep DTOGs, clear CTR_RX,TX, set TX VALID, leave stat_Rx + USB->EPnR[0] = (status & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX|USB_EPnR_STAT_RX)) + ^ USB_EPnR_STAT_TX; + uint32_t ctr = 1000000; + while(--ctr && (USB->ISTR & USB_ISTR_CTR) == 0){IWDG->KR = IWDG_REFRESH;}; + if((USB->ISTR & USB_ISTR_CTR) == 0){ + return; + } + if(needzlp) EP_WriteIRQ(0, (uint8_t*)0, 0); + } + } +} + +static inline void get_descriptor(){ + switch(setup_packet.wValue){ + case DEVICE_DESCRIPTOR: + wr0(USB_DeviceDescriptor, sizeof(USB_DeviceDescriptor)); + break; + case CONFIGURATION_DESCRIPTOR: + wr0(USB_ConfigDescriptor, sizeof(USB_ConfigDescriptor)); + break; + case STRING_LANG_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringLangDescriptor, STRING_LANG_DESCRIPTOR_SIZE_BYTE); + break; + case STRING_MAN_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringManufacturingDescriptor, USB_StringManufacturingDescriptor.bLength); + break; + case STRING_PROD_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringProdDescriptor, USB_StringProdDescriptor.bLength); + break; + case STRING_SN_DESCRIPTOR: + wr0((const uint8_t *)&USB_StringSerialDescriptor, USB_StringSerialDescriptor.bLength); + break; + case DEVICE_QUALIFIER_DESCRIPTOR: + wr0(USB_DeviceQualifierDescriptor, USB_DeviceQualifierDescriptor[0]); + break; + default: + break; + } +} + +static uint8_t configuration = 0; // reply for GET_CONFIGURATION (==1 if configured) +static inline void std_d2h_req(){ + uint16_t status = 0; // bus powered + switch(setup_packet.bRequest){ + case GET_DESCRIPTOR: + get_descriptor(); + break; + case GET_STATUS: + EP_WriteIRQ(0, (uint8_t *)&status, 2); // send status: Bus Powered + break; + case GET_CONFIGURATION: + EP_WriteIRQ(0, &configuration, 1); + break; + default: + break; + } +} + +static inline void std_h2d_req(){ + switch(setup_packet.bRequest){ + case SET_ADDRESS: + // new address will be assigned later - after acknowlegement or request to host + USB_Dev.USB_Addr = setup_packet.wValue; + break; + case SET_CONFIGURATION: + // Now device configured + USB_Dev.USB_Status = USB_STATE_CONFIGURED; + configuration = setup_packet.wValue; + break; + default: + break; + } +} + +/* +bmRequestType: 76543210 +7 direction: 0 - host->device, 1 - device->host +65 type: 0 - standard, 1 - class, 2 - vendor +4..0 getter: 0 - device, 1 - interface, 2 - endpoint, 3 - other +*/ +/** + * Endpoint0 (control) handler + */ +void EP0_Handler(){ + uint16_t epstatus = USB->EPnR[0]; // EP0R on input -> return this value after modifications + uint8_t reqtype = setup_packet.bmRequestType & 0x7f; + uint8_t dev2host = (setup_packet.bmRequestType & 0x80) ? 1 : 0; + int rxflag = RX_FLAG(epstatus); + if(rxflag && SETUP_FLAG(epstatus)){ + switch(reqtype){ + case STANDARD_DEVICE_REQUEST_TYPE: // standard device request + if(dev2host){ + std_d2h_req(); + }else{ + std_h2d_req(); + EP_WriteIRQ(0, (uint8_t *)0, 0); + } + break; + case STANDARD_ENDPOINT_REQUEST_TYPE: // standard endpoint request + if(setup_packet.bRequest == CLEAR_FEATURE){ + EP_WriteIRQ(0, (uint8_t *)0, 0); + } + break; + case VENDOR_REQUEST_TYPE: + vendor_handler(&setup_packet); + break; + case CONTROL_REQUEST_TYPE: + switch(setup_packet.bRequest){ + case GET_LINE_CODING: + EP_WriteIRQ(0, (uint8_t*)&lineCoding, sizeof(lineCoding)); + break; + case SET_LINE_CODING: // omit this for next stage, when data will come + break; + case SET_CONTROL_LINE_STATE: + usbON = 1; + clstate_handler(setup_packet.wValue); + break; + case SEND_BREAK: + usbON = 0; + break_handler(); + break; + default: + break; + } + if(setup_packet.bRequest != GET_LINE_CODING) EP_WriteIRQ(0, (uint8_t *)0, 0); // write acknowledgement + break; + default: + EP_WriteIRQ(0, (uint8_t *)0, 0); + } + }else if(rxflag){ // got data over EP0 or host acknowlegement + if(endpoints[0].rx_cnt){ + if(setup_packet.bRequest == SET_LINE_CODING){ + linecoding_handler((usb_LineCoding*)ep0databuf); + } + } + } else if(TX_FLAG(epstatus)){ // package transmitted + // now we can change address after enumeration + if ((USB->DADDR & USB_DADDR_ADD) != USB_Dev.USB_Addr){ + USB->DADDR = USB_DADDR_EF | USB_Dev.USB_Addr; + // change state to ADRESSED + USB_Dev.USB_Status = USB_STATE_ADDRESSED; + } + } + epstatus = KEEP_DTOG(USB->EPnR[0]); + if(rxflag) epstatus ^= USB_EPnR_STAT_TX; // start ZLP/data transmission + else epstatus &= ~USB_EPnR_STAT_TX; // or leave unchanged + // keep DTOGs, clear CTR_RX,TX, set RX VALID + USB->EPnR[0] = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_RX; +} + +/** + * Write data to EP buffer (called from IRQ handler) + * @param number - EP number + * @param *buf - array with data + * @param size - its size + */ +void EP_WriteIRQ(uint8_t number, const uint8_t *buf, uint16_t size){ + if(size > USB_TXBUFSZ) size = USB_TXBUFSZ; + uint16_t N2 = (size + 1) >> 1; + // the buffer is 16-bit, so we should copy data as it would be uint16_t + uint16_t *buf16 = (uint16_t *)buf; + for(int i = 0; i < N2; i++){ + endpoints[number].tx_buf[i] = buf16[i]; + } + USB_BTABLE->EP[number].USB_COUNT_TX = size; +} + +/** + * Write data to EP buffer (called outside IRQ handler) + * @param number - EP number + * @param *buf - array with data + * @param size - its size + */ +void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size){ + EP_WriteIRQ(number, buf, size); + uint16_t status = KEEP_DTOG(USB->EPnR[number]); + // keep DTOGs, clear CTR_TX & set TX VALID to start transmission + USB->EPnR[number] = (status & ~(USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_TX; +} + +/* + * Copy data from EP buffer into user buffer area + * @param *buf - user array for data + * @return amount of data read + */ +int EP_Read(uint8_t number, uint8_t *buf){ + int n = endpoints[number].rx_cnt; + if(n){ + for(int i = 0; i < n; ++i) + buf[i] = endpoints[number].rx_buf[i]; + } + return n; +} diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.h b/F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.h new file mode 100644 index 0000000..84b8c4c --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/usb_lib.h @@ -0,0 +1,184 @@ +/* + * This file is part of the MLX90640 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once +#ifndef __USB_LIB_H__ +#define __USB_LIB_H__ + +#include +#include "usbhw.h" + +#define EP0DATABUF_SIZE (64) +#define LASTADDR_DEFAULT (STM32ENDPOINTS * 8) + +// bmRequestType & 0x7f +#define STANDARD_DEVICE_REQUEST_TYPE 0 +#define STANDARD_ENDPOINT_REQUEST_TYPE 2 +#define VENDOR_REQUEST_TYPE 0x40 +#define CONTROL_REQUEST_TYPE 0x21 +// bRequest, standard; for bmRequestType == 0x80 +#define GET_STATUS 0x00 +#define GET_DESCRIPTOR 0x06 +#define GET_CONFIGURATION 0x08 +// for bmRequestType == 0 +#define CLEAR_FEATURE 0x01 +#define SET_FEATURE 0x03 // unused +#define SET_ADDRESS 0x05 +#define SET_DESCRIPTOR 0x07 // unused +#define SET_CONFIGURATION 0x09 +// for bmRequestType == 0x81, 1 or 0xB2 +#define GET_INTERFACE 0x0A // unused +#define SET_INTERFACE 0x0B // unused +#define SYNC_FRAME 0x0C // unused +#define VENDOR_REQUEST 0x01 // unused + +// Class-Specific Control Requests +#define SEND_ENCAPSULATED_COMMAND 0x00 // unused +#define GET_ENCAPSULATED_RESPONSE 0x01 // unused +#define SET_COMM_FEATURE 0x02 // unused +#define GET_COMM_FEATURE 0x03 // unused +#define CLEAR_COMM_FEATURE 0x04 // unused +#define SET_LINE_CODING 0x20 +#define GET_LINE_CODING 0x21 +#define SET_CONTROL_LINE_STATE 0x22 +#define SEND_BREAK 0x23 + +// control line states +#define CONTROL_DTR 0x01 +#define CONTROL_RTS 0x02 + +// wValue +#define DEVICE_DESCRIPTOR 0x100 +#define CONFIGURATION_DESCRIPTOR 0x200 +#define STRING_LANG_DESCRIPTOR 0x300 +#define STRING_MAN_DESCRIPTOR 0x301 +#define STRING_PROD_DESCRIPTOR 0x302 +#define STRING_SN_DESCRIPTOR 0x303 +#define DEVICE_QUALIFIER_DESCRIPTOR 0x600 + +#define RX_FLAG(epstat) (epstat & USB_EPnR_CTR_RX) +#define TX_FLAG(epstat) (epstat & USB_EPnR_CTR_TX) +#define SETUP_FLAG(epstat) (epstat & USB_EPnR_SETUP) + +// EPnR bits manipulation +#define KEEP_DTOG_STAT(EPnR) (EPnR & ~(USB_EPnR_STAT_RX|USB_EPnR_STAT_TX|USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX)) +#define KEEP_DTOG(EPnR) (EPnR & ~(USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX)) + +// USB state: uninitialized, addressed, ready for use +typedef enum{ + USB_STATE_DEFAULT, + USB_STATE_ADDRESSED, + USB_STATE_CONFIGURED, + USB_STATE_CONNECTED +} USB_state; + +// EP types +#define EP_TYPE_BULK 0x00 +#define EP_TYPE_CONTROL 0x01 +#define EP_TYPE_ISO 0x02 +#define EP_TYPE_INTERRUPT 0x03 + +#define LANG_US (uint16_t)0x0409 + +#define _USB_STRING_(name, str) \ +static const struct name \ +{ \ + uint8_t bLength; \ + uint8_t bDescriptorType; \ + uint16_t bString[(sizeof(str) - 2) / 2]; \ + \ +} \ +name = {sizeof(name), 0x03, str} + +#define _USB_LANG_ID_(name, lng_id) \ + \ +static const struct name \ +{ \ + uint8_t bLength; \ + uint8_t bDescriptorType; \ + uint16_t bString; \ + \ +} \ +name = {0x04, 0x03, lng_id} +#define STRING_LANG_DESCRIPTOR_SIZE_BYTE (4) + +// EP0 configuration packet +typedef struct { + uint8_t bmRequestType; + uint8_t bRequest; + uint16_t wValue; + uint16_t wIndex; + uint16_t wLength; +} config_pack_t; + +// endpoints state +typedef struct __ep_t{ + uint16_t *tx_buf; // transmission buffer address + uint16_t txbufsz; // transmission buffer size + uint8_t *rx_buf; // reception buffer address + void (*func)(); // endpoint action function + uint16_t rx_cnt; // received data counter +} ep_t; + +// USB status & its address +typedef struct { + uint8_t USB_Status; + uint16_t USB_Addr; +}usb_dev_t; + +typedef struct { + uint32_t dwDTERate; + uint8_t bCharFormat; + #define USB_CDC_1_STOP_BITS 0 + #define USB_CDC_1_5_STOP_BITS 1 + #define USB_CDC_2_STOP_BITS 2 + uint8_t bParityType; + #define USB_CDC_NO_PARITY 0 + #define USB_CDC_ODD_PARITY 1 + #define USB_CDC_EVEN_PARITY 2 + #define USB_CDC_MARK_PARITY 3 + #define USB_CDC_SPACE_PARITY 4 + uint8_t bDataBits; +} __attribute__ ((packed)) usb_LineCoding; + +typedef struct { + uint8_t bmRequestType; + uint8_t bNotificationType; + uint16_t wValue; + uint16_t wIndex; + uint16_t wLength; +} __attribute__ ((packed)) usb_cdc_notification; + +extern ep_t endpoints[]; +extern usb_dev_t USB_Dev; +extern uint8_t usbON; +extern config_pack_t setup_packet; +extern uint8_t ep0databuf[]; +//extern uint8_t ep0dbuflen; + +void EP0_Handler(); + +void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size); +usb_LineCoding getLineCoding(); + +void linecoding_handler(usb_LineCoding *lc); +void clstate_handler(uint16_t val); +void break_handler(); +void vendor_handler(config_pack_t *packet); + +#endif // __USB_LIB_H__ diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/usbhw.c b/F0:F030,F042,F072/PL2303_ringbuffer/usbhw.c new file mode 100644 index 0000000..2108a88 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/usbhw.c @@ -0,0 +1,128 @@ +/* + * This file is part of the MLX90640 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "usb.h" +#include "usbhw.h" +#include "usb_lib.h" + +void USB_setup(){ + RCC->APB1ENR |= RCC_APB1ENR_CRSEN | RCC_APB1ENR_USBEN; // enable CRS (hsi48 sync) & USB + RCC->CFGR3 &= ~RCC_CFGR3_USBSW; // reset USB + RCC->CR2 |= RCC_CR2_HSI48ON; // turn ON HSI48 + uint32_t tmout = 16000000; + while(!(RCC->CR2 & RCC_CR2_HSI48RDY)){if(--tmout == 0) break;} + FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY; + CRS->CFGR &= ~CRS_CFGR_SYNCSRC; + CRS->CFGR |= CRS_CFGR_SYNCSRC_1; // USB SOF selected as sync source + CRS->CR |= CRS_CR_AUTOTRIMEN; // enable auto trim + CRS->CR |= CRS_CR_CEN; // enable freq counter & block CRS->CFGR as read-only + RCC->CFGR |= RCC_CFGR_SW; + // allow RESET and WKUPM interrupts + USB->CNTR = USB_CNTR_RESETM | USB_CNTR_WKUPM; + // clear flags + USB->ISTR = 0; + // and activate pullup + USB->BCDR |= USB_BCDR_DPPU; + NVIC_EnableIRQ(USB_IRQn); +} + +static uint16_t lastaddr = LASTADDR_DEFAULT; +/** + * Endpoint initialisation + * !!! when working with CAN bus change USB_BTABLE_SIZE to 768 !!! + * @param number - EP num (0...7) + * @param type - EP type (EP_TYPE_BULK, EP_TYPE_CONTROL, EP_TYPE_ISO, EP_TYPE_INTERRUPT) + * @param txsz - transmission buffer size @ USB/CAN buffer + * @param rxsz - reception buffer size @ USB/CAN buffer + * @param uint16_t (*func)(ep_t *ep) - EP handler function + * @return 0 if all OK + */ +int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)()){ + if(number >= STM32ENDPOINTS) return 4; // out of configured amount + if(txsz > USB_BTABLE_SIZE || rxsz > USB_BTABLE_SIZE) return 1; // buffer too large + if(lastaddr + txsz + rxsz >= USB_BTABLE_SIZE) return 2; // out of btable + USB->EPnR[number] = (type << 9) | (number & USB_EPnR_EA); + USB->EPnR[number] ^= USB_EPnR_STAT_RX | USB_EPnR_STAT_TX_1; + if(rxsz & 1 || rxsz > USB_BTABLE_SIZE) return 3; // wrong rx buffer size + uint16_t countrx = 0; + if(rxsz < 64) countrx = rxsz / 2; + else{ + if(rxsz & 0x1f) return 3; // should be multiple of 32 + countrx = 31 + rxsz / 32; + } + USB_BTABLE->EP[number].USB_ADDR_TX = lastaddr; + endpoints[number].tx_buf = (uint16_t *)(USB_BTABLE_BASE + lastaddr); + endpoints[number].txbufsz = txsz; + lastaddr += txsz; + USB_BTABLE->EP[number].USB_COUNT_TX = 0; + USB_BTABLE->EP[number].USB_ADDR_RX = lastaddr; + endpoints[number].rx_buf = (uint8_t *)(USB_BTABLE_BASE + lastaddr); + lastaddr += rxsz; + // buffer size: Table127 of RM + USB_BTABLE->EP[number].USB_COUNT_RX = countrx << 10; + endpoints[number].func = func; + return 0; +} + +// standard IRQ handler +void usb_isr(){ + if (USB->ISTR & USB_ISTR_RESET){ + // Reinit registers + USB->CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM | USB_CNTR_SUSPM | USB_CNTR_WKUPM; + USB->ISTR = 0; + // Endpoint 0 - CONTROL + // ON USB LS size of EP0 may be 8 bytes, but on FS it should be 64 bytes! + lastaddr = LASTADDR_DEFAULT; // roll back to beginning of buffer + EP_Init(0, EP_TYPE_CONTROL, USB_EP0_BUFSZ, USB_EP0_BUFSZ, EP0_Handler); + // clear address, leave only enable bit + USB->DADDR = USB_DADDR_EF; + // state is default - wait for enumeration + USB_Dev.USB_Status = USB_STATE_DEFAULT; + } + if(USB->ISTR & USB_ISTR_CTR){ + // EP number + uint8_t n = USB->ISTR & USB_ISTR_EPID; + // copy status register + uint16_t epstatus = USB->EPnR[n]; + // copy received bytes amount + endpoints[n].rx_cnt = USB_BTABLE->EP[n].USB_COUNT_RX & 0x3FF; // low 10 bits is counter + // check direction + if(USB->ISTR & USB_ISTR_DIR){ // OUT interrupt - receive data, CTR_RX==1 (if CTR_TX == 1 - two pending transactions: receive following by transmit) + if(n == 0){ // control endpoint + if(epstatus & USB_EPnR_SETUP){ // setup packet -> copy data to conf_pack + EP_Read(0, (uint8_t*)&setup_packet); + // interrupt handler will be called later + }else if(epstatus & USB_EPnR_CTR_RX){ // data packet -> push received data to ep0databuf + EP_Read(0, (uint8_t*)&ep0databuf); + } + } + } + // call EP handler + if(endpoints[n].func) endpoints[n].func(endpoints[n]); + } + if(USB->ISTR & USB_ISTR_SUSP){ // suspend -> still no connection, may sleep + usbON = 0; + USB->CNTR |= USB_CNTR_FSUSP | USB_CNTR_LPMODE; + USB->ISTR = ~USB_ISTR_SUSP; + } + if(USB->ISTR & USB_ISTR_WKUP){ // wakeup + USB->CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LPMODE); // clear suspend flags + USB->ISTR = ~USB_ISTR_WKUP; + } +} + diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/usbhw.h b/F0:F030,F042,F072/PL2303_ringbuffer/usbhw.h new file mode 100644 index 0000000..ce1593f --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/usbhw.h @@ -0,0 +1,104 @@ +/* + * This file is part of the MLX90640 project. + * Copyright 2022 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once +#ifndef USBHW_H__ +#define USBHW_H__ + +#include + +// max endpoints number +#define STM32ENDPOINTS 8 +/** + * Buffers size definition + **/ +// !!! when working with CAN bus change USB_BTABLE_SIZE to 768 !!! +#define USB_BTABLE_SIZE 768 +// for USB FS EP0 buffers are from 8 to 64 bytes long (64 for PL2303) +#define USB_EP0_BUFSZ 64 +// USB transmit buffer size (64 for PL2303) +#define USB_TXBUFSZ 64 +// USB receive buffer size (64 for PL2303) +#define USB_RXBUFSZ 64 +// EP1 buffer size +#define USB_EP1BUFSZ 8 + +#define USB_BTABLE_BASE ((uint32_t)0x40006000) + +#ifdef USB_BTABLE +#undef USB_BTABLE +#endif +#define USB_BTABLE ((USB_BtableDef *)(USB_BTABLE_BASE)) +#define USB_ISTR_EPID 0x0000000F +#define USB_FNR_LSOF_0 0x00000800 +#define USB_FNR_lSOF_1 0x00001000 +#define USB_LPMCSR_BESL_0 0x00000010 +#define USB_LPMCSR_BESL_1 0x00000020 +#define USB_LPMCSR_BESL_2 0x00000040 +#define USB_LPMCSR_BESL_3 0x00000080 +#define USB_EPnR_CTR_RX 0x00008000 +#define USB_EPnR_DTOG_RX 0x00004000 +#define USB_EPnR_STAT_RX 0x00003000 +#define USB_EPnR_STAT_RX_0 0x00001000 +#define USB_EPnR_STAT_RX_1 0x00002000 +#define USB_EPnR_SETUP 0x00000800 +#define USB_EPnR_EP_TYPE 0x00000600 +#define USB_EPnR_EP_TYPE_0 0x00000200 +#define USB_EPnR_EP_TYPE_1 0x00000400 +#define USB_EPnR_EP_KIND 0x00000100 +#define USB_EPnR_CTR_TX 0x00000080 +#define USB_EPnR_DTOG_TX 0x00000040 +#define USB_EPnR_STAT_TX 0x00000030 +#define USB_EPnR_STAT_TX_0 0x00000010 +#define USB_EPnR_STAT_TX_1 0x00000020 +#define USB_EPnR_EA 0x0000000F +#define USB_COUNTn_RX_BLSIZE 0x00008000 +#define USB_COUNTn_NUM_BLOCK 0x00007C00 +#define USB_COUNTn_RX 0x0000003F + +#define USB_TypeDef USB_TypeDef_custom + +typedef struct { + __IO uint32_t EPnR[STM32ENDPOINTS]; + __IO uint32_t RESERVED[STM32ENDPOINTS]; + __IO uint32_t CNTR; + __IO uint32_t ISTR; + __IO uint32_t FNR; + __IO uint32_t DADDR; + __IO uint32_t BTABLE; + __IO uint32_t LPMCSR; + __IO uint32_t BCDR; +} USB_TypeDef; + +typedef struct{ + __IO uint16_t USB_ADDR_TX; + __IO uint16_t USB_COUNT_TX; + __IO uint16_t USB_ADDR_RX; + __IO uint16_t USB_COUNT_RX; +} USB_EPDATA_TypeDef; + +typedef struct{ + __IO USB_EPDATA_TypeDef EP[STM32ENDPOINTS]; +} USB_BtableDef; + +void USB_setup(); +int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)()); +void EP_WriteIRQ(uint8_t number, const uint8_t *buf, uint16_t size); +int EP_Read(uint8_t number, uint8_t *buf); + +#endif // USBHW_H__ diff --git a/F0:F030,F042,F072/PL2303_ringbuffer/version.inc b/F0:F030,F042,F072/PL2303_ringbuffer/version.inc new file mode 100644 index 0000000..d4f59f2 --- /dev/null +++ b/F0:F030,F042,F072/PL2303_ringbuffer/version.inc @@ -0,0 +1,2 @@ +#define BUILD_NUMBER "111" +#define BUILD_DATE "2022-10-27"