starting CAN-GPIO, have a lot of errors

F0:F030,F042,F072/CANBUS_SSI/Makefile.old

@@ -1,155 +0,0 @@
-# make debug adds -DEBUG -Werror
-# make ADDEFS="additional defs"
-BINARY		= canstepper
-BOOTPORT	?= /dev/ttyUSB0
-BOOTSPEED	?= 115200
-# MCU FAMILY
-FAMILY		?= F0
-# MCU code (STM32F072xx)
-MCU			?= F072xB
-# change this linking script depending on particular MCU model,
-LDSCRIPT	?= stm32f0728.ld
-DEFS		= ${ADDEFS} -DVERSION=\"0.0.1\" -DUSARTNUM=1
-TARGET := RELEASE
-
-FP_FLAGS	?= -msoft-float
-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
-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)
-# 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 -Wextra -Wshadow
-CFLAGS		+= -fno-common -ffunction-sections -fdata-sections
-
-###############################################################################
-# Linker flags
-LDFLAGS		+= --static -nostartfiles --specs=nano.specs
-LDFLAGS		+= -L$(LIB_DIR)
-LDFLAGS		+= -T$(LDSCRIPT)
-LDFLAGS     += -Wl,-Map=$(OBJDIR)/$(BINARY).map
-LDFLAGS     += -Wl,--gc-sections
-
-###############################################################################
-# Used libraries
-LDLIBS      += -Wl,--start-group -lc -lgcc -Wl,--end-group
-LDLIBS		+= $(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: $(OBJDIR)/RELEASE bin list size
-release: all
-
-debug: CFLAGS += -DEBUG -Werror -W -Wimplicit-function-declaration
-debug: $(OBJDIR)/DEBUG bin list size
-
-$(OBJDIR)/DEBUG:
-	@rm -rf $(OBJDIR)
-	@mkdir $(OBJDIR)
-	@> $(OBJDIR)/DEBUG
-	@echo "TARGET: DEBUG"
-	echo "CFLAGS += -DEBUG -Werror -W -Wimplicit-function-declaration" > $(OBJDIR)/CFLAGS
-$(OBJDIR)/RELEASE:
-	@rm -rf $(OBJDIR)
-	@mkdir $(OBJDIR)
-	@> $(OBJDIR)/RELEASE
-	@echo "TARGET: RELEASE"
-	echo "" > $(OBJDIR)/CFLAGS
-
-elf: $(ELF)
-bin: $(BIN)
-hex: $(HEX)
-list: $(LIST)
-
-ifneq ($(MAKECMDGOALS),clean)
--include $(DEPS)
--include $(OBJDIR)/CFLAGS
-endif
-
-$(OBJDIR):
-	mkdir $(OBJDIR)
-
-$(STARTUP): $(INC_DIR)/startup/vector.c
-	@echo "  CC   startup"
-	$(CC) $(CFLAGS) $(DEFS) $(INCLUDE) $(ARCH_FLAGS) -o $@ -c $<
-
-$(OBJDIR)/%.o: %.c
-	@echo "  CC	  $<"
-	$(CC) $(CFLAGS) $(DEFS) $(INCLUDE) $(ARCH_FLAGS) -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) $(ARCH_FLAGS) $(OBJS) $(LDLIBS) -o $(ELF)
-
-size: $(ELF)
-	$(SIZE) $(ELF)
-
-clean:
-	@echo "  CLEAN"
-	@$(RM) $(HEX)
-	@$(RM) -rf $(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
-
-.PHONY: clean flash boot

F0:F030,F042,F072/PL2303_ringbuffer/Makefile.old

@@ -1,154 +0,0 @@
-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

F0:F030,F042,F072/usbcan_gpio/Makefile

@@ -0,0 +1,12 @@
+BINARY      := usbcangpio
+# MCU code
+#MCU         := F072xB
+MCU          := F042x6
+# change this linking script depending on particular MCU model,
+#LDSCRIPT    := stm32f072xB.ld
+LDSCRIPT     := stm32f042x6.ld
+
+DEFINES := -DUSB2_16
+
+include ../makefile.f0
+include ../../makefile.stm32

F0:F030,F042,F072/usbcan_gpio/Readme.md

@@ -0,0 +1,12 @@
+USB-CAN adapter
+===============
+
+Based on [USB-CAN](https://github.com/eddyem/stm32samples/tree/master/F0%3AF030%2CF042%2CF072/usbcan_ringbuffer).
+
+Unlike original (only USB-CAN) adapter, in spite of it have GPIO contacts on board, this firmware allows to use both
+USB-CAN and GPIO.
+
+The old USB-CAN is available as earlier by /dev/USB-CANx, also you can see new device: /dev/USB-GPIOx. 
+New interface allows you to configure GPIO and use it's base functions: in/out/ADC.
+
+

F0:F030,F042,F072/usbcan_gpio/can.c

@@ -0,0 +1,396 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2022 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "can.h"
+#include "hardware.h"
+#include "canproto.h"
+
+#define USBIF   ICAN
+#include "strfunc.h"
+
+// circular buffer for  received messages
+static CAN_message messages[CAN_INMESSAGE_SIZE];
+static uint8_t first_free_idx = 0;    // index of first empty cell
+static int8_t first_nonfree_idx = -1; // index of first data cell
+uint32_t floodT = FLOOD_PERIOD_MS; // flood period in ms
+static uint8_t incrflood = 0; // ==1 for incremental flooding
+
+static uint32_t last_err_code = 0;
+static CAN_status can_status = CAN_STOP;
+
+static void can_process_fifo(uint8_t fifo_num);
+
+static CAN_message loc_flood_msg;
+static CAN_message *flood_msg = NULL; // == loc_flood_msg - to flood
+
+CAN_status CAN_get_status(){
+    CAN_status st = can_status;
+    // give overrun message only once
+    if(st == CAN_FIFO_OVERRUN){
+        SEND("FIFO overrun\n");
+        can_status = CAN_READY;
+    }
+    return st;
+}
+
+// push next message into buffer; return 1 if buffer overfull
+static int CAN_messagebuf_push(CAN_message *msg){
+#ifdef EBUG
+        SEND("push\n");
+#endif
+    if(first_free_idx == first_nonfree_idx){
+#ifdef EBUG
+        SEND("INBUF OVERFULL\n");
+#endif
+        return 1; // no free space
+    }
+    if(first_nonfree_idx < 0) first_nonfree_idx = 0;  // first message in empty buffer
+    messages[first_free_idx++] = *msg;
+    // need to roll?
+    if(first_free_idx == CAN_INMESSAGE_SIZE) first_free_idx = 0;
+    return 0;
+}
+
+// pop message from buffer
+CAN_message *CAN_messagebuf_pop(){
+    if(first_nonfree_idx < 0) return NULL;
+    CAN_message *msg = &messages[first_nonfree_idx++];
+    if(first_nonfree_idx == CAN_INMESSAGE_SIZE) first_nonfree_idx = 0;
+    if(first_nonfree_idx == first_free_idx){ // buffer is empty - refresh it
+        first_nonfree_idx = -1;
+        first_free_idx = 0;
+    }
+    return msg;
+}
+
+int CAN_reinit(uint16_t speed){
+    CAN->TSR |= CAN_TSR_ABRQ0 | CAN_TSR_ABRQ1 | CAN_TSR_ABRQ2;
+    RCC->APB1RSTR |= RCC_APB1RSTR_CANRST;
+    RCC->APB1RSTR &= ~RCC_APB1RSTR_CANRST;
+    return CAN_setup(speed);
+}
+
+/*
+Can filtering: FSCx=0 (CAN->FS1R) -> 16-bit identifiers
+MASK: FBMx=0 (CAN->FM1R), two filters (n in FR1 and n+1 in FR2)
+    ID:   CAN->sFilterRegister[x].FRn[0..15]
+    MASK: CAN->sFilterRegister[x].FRn[16..31]
+    FR bits:  STID[10:0] RTR IDE EXID[17:15]
+LIST: FBMx=1, four filters (n&n+1 in FR1, n+2&n+3 in FR2)
+    IDn:   CAN->sFilterRegister[x].FRn[0..15]
+    IDn+1: CAN->sFilterRegister[x].FRn[16..31]
+*/
+
+/*
+Can timing: main freq - APB (PLL=48MHz)
+segment = 1sync + TBS1 + TBS2, sample point is between TBS1 and TBS2,
+so if TBS1=4 and TBS2=3, sum=8, bit sampling freq is 48/8 = 6MHz
+-> to get   100kbps we need prescaler=60
+            250kbps - 24
+            500kbps - 12
+            1MBps   - 6
+*/
+
+
+static uint16_t oldspeed = 100; // speed of last init
+uint16_t CAN_getspeed(){
+    return oldspeed;
+}
+// speed - in kbps. @return - current speed
+int CAN_setup(uint16_t speed){
+    LED_off(LED1);
+    flood_msg = NULL; // clear for not flood in terminal
+    incrflood = 0;
+    if(speed == 0) speed = oldspeed;
+    else if(speed < CAN_MIN_SPEED) speed = CAN_MIN_SPEED;
+    else if(speed > CAN_MAX_SPEED) speed = CAN_MAX_SPEED;
+    uint32_t regval = 6000/speed - 1;
+    oldspeed = 6000 / (regval + 1); // new speed due to register value
+    uint32_t tmout = 16000000;
+    // Configure GPIO: PB8 - CAN_Rx, PB9 - CAN_Tx
+    /* (1) Select AF mode (10) on PB8 and PB9 */
+    /* (2) AF4 for CAN signals */
+    GPIOB->MODER = (GPIOB->MODER & ~(GPIO_MODER_MODER8 | GPIO_MODER_MODER9))
+                 | (GPIO_MODER_MODER8_AF | GPIO_MODER_MODER9_AF); /* (1) */
+    GPIOB->AFR[1] = (GPIOB->AFR[1] &~ (GPIO_AFRH_AFRH0 | GPIO_AFRH_AFRH1))\
+                  | (4 << (0 * 4)) | (4 << (1 * 4)); /* (2) */
+    /* Enable the peripheral clock CAN */
+    RCC->APB1ENR |= RCC_APB1ENR_CANEN;
+      /* Configure CAN */
+    /* (1) Enter CAN init mode to write the configuration */
+    /* (2) Wait the init mode entering */
+    /* (3) Exit sleep mode */
+    /* (4) Normal mode, set timing to 100kb/s: TBS1 = 4, TBS2 = 3, prescaler = 60 */
+    /* (5) Leave init mode */
+    /* (6) Wait the init mode leaving */
+    /* (7) Enter filter init mode, (16-bit + mask, bank 0 for FIFO 0) */
+    /* (8) Acivate filter 0 for two IDs */
+    /* (9) Identifier list mode */
+    /* (10) Set the Id list */
+    /* (12) Leave filter init */
+    /* (13) Set error interrupts enable */
+    CAN->MCR |= CAN_MCR_INRQ; /* (1) */
+    while((CAN->MSR & CAN_MSR_INAK)!=CAN_MSR_INAK) /* (2) */
+        if(--tmout == 0) break;
+    CAN->MCR &=~ CAN_MCR_SLEEP; /* (3) */
+    CAN->MCR |= CAN_MCR_ABOM; /* allow automatically bus-off */
+
+    CAN->BTR =  2 << 20 | 3 << 16 | regval; /* (4) */
+    CAN->MCR &=~ CAN_MCR_INRQ; /* (5) */
+    tmout = 16000000;
+    while((CAN->MSR & CAN_MSR_INAK)==CAN_MSR_INAK) if(--tmout == 0) break; /* (6) */
+    // accept ALL
+    CAN->FMR = CAN_FMR_FINIT; /* (7) */
+    CAN->FA1R = CAN_FA1R_FACT0 | CAN_FA1R_FACT1; /* (8) */
+    // set to 1 all needed bits of CAN->FFA1R to switch given filters to FIFO1
+    CAN->sFilterRegister[0].FR1 = (1<<21)|(1<<5); // all odd IDs
+    CAN->FFA1R = 2; // filter 1 for FIFO1, filter 0 - for FIFO0
+    CAN->sFilterRegister[1].FR1 = (1<<21); // all even IDs
+    CAN->FMR &= ~CAN_FMR_FINIT; /* (12) */
+    CAN->IER |= CAN_IER_ERRIE | CAN_IER_FOVIE0 | CAN_IER_FOVIE1; /* (13) */
+
+    /* Configure IT */
+    /* (14) Set priority for CAN_IRQn */
+    /* (15) Enable CAN_IRQn */
+    NVIC_SetPriority(CEC_CAN_IRQn, 0); /* (14) */
+    NVIC_EnableIRQ(CEC_CAN_IRQn); /* (15) */
+    can_status = CAN_READY;
+    return oldspeed;
+}
+
+void printCANerr(){
+    if(!last_err_code) last_err_code = CAN->ESR;
+    if(!last_err_code){
+        SEND("No errors\n");
+        return;
+    }
+    SEND("Receive error counter: ");
+    printu((last_err_code & CAN_ESR_REC)>>24);
+    SEND("\nTransmit error counter: ");
+    printu((last_err_code & CAN_ESR_TEC)>>16);
+    SEND("\nLast error code: ");
+    int lec = (last_err_code & CAN_ESR_LEC) >> 4;
+    const char *errmsg = "No";
+    switch(lec){
+        case 1: errmsg = "Stuff"; break;
+        case 2: errmsg = "Form"; break;
+        case 3: errmsg = "Ack"; break;
+        case 4: errmsg = "Bit recessive"; break;
+        case 5: errmsg = "Bit dominant"; break;
+        case 6: errmsg = "CRC"; break;
+        case 7: errmsg = "(set by software)"; break;
+    }
+    SEND(errmsg); SEND(" error\n");
+    if(last_err_code & CAN_ESR_BOFF) SEND("Bus off ");
+    if(last_err_code & CAN_ESR_EPVF) SEND("Passive error limit ");
+    if(last_err_code & CAN_ESR_EWGF) SEND("Error counter limit");
+    last_err_code = 0;
+    NL();
+}
+
+void can_proc(){
+#ifdef EBUG
+    if(last_err_code){
+        SEND("Error, ESR=");
+        printu(last_err_code);
+        NL();
+        last_err_code = 0;
+    }
+#endif
+    // check for messages in FIFO0 & FIFO1
+    if(CAN->RF0R & CAN_RF0R_FMP0){
+        can_process_fifo(0);
+    }
+    if(CAN->RF1R & CAN_RF1R_FMP1){
+        can_process_fifo(1);
+    }
+    IWDG->KR = IWDG_REFRESH;
+    if(CAN->ESR & (CAN_ESR_BOFF | CAN_ESR_EPVF | CAN_ESR_EWGF)){ // much errors - restart CAN BUS
+        SEND("\nToo much errors, restarting CAN!\n");
+        printCANerr();
+        // request abort for all mailboxes
+        CAN->TSR |= CAN_TSR_ABRQ0 | CAN_TSR_ABRQ1 | CAN_TSR_ABRQ2;
+        // reset CAN bus
+        RCC->APB1RSTR |= RCC_APB1RSTR_CANRST;
+        RCC->APB1RSTR &= ~RCC_APB1RSTR_CANRST;
+        CAN_setup(0);
+    }
+    static uint32_t lastFloodTime = 0;
+    static uint32_t incrmessagectr = 0;
+    if(flood_msg && (Tms - lastFloodTime) >= (floodT)){ // send message every floodT ms
+        lastFloodTime = Tms;
+        can_send(flood_msg->data, flood_msg->length, flood_msg->ID);
+    }else if(incrflood && (Tms - lastFloodTime) >= floodT){ // incremental flood message
+        lastFloodTime = Tms;
+        if(CAN_OK == can_send((uint8_t*)&incrmessagectr, 4, loc_flood_msg.ID)) ++incrmessagectr;
+    }
+}
+
+CAN_status can_send(uint8_t *msg, uint8_t len, uint16_t target_id){
+    uint8_t mailbox = 0;
+    // check first free mailbox
+    if(CAN->TSR & (CAN_TSR_TME)){
+        mailbox = (CAN->TSR & CAN_TSR_CODE) >> 24;
+    }else{ // no free mailboxes
+#ifdef EBUG
+        SEND("No free mailboxes\n");
+#endif
+        return CAN_BUSY;
+    }
+#ifdef EBUG
+    SEND("Send data. Len="); printu(len);
+    SEND(", tagid="); printuhex(target_id);
+    SEND(", data=");
+    for(int i = 0; i < len; ++i){
+        SEND(" "); printuhex(msg[i]);
+    }
+    NL();
+#endif
+    CAN_TxMailBox_TypeDef *box = &CAN->sTxMailBox[mailbox];
+    uint32_t lb = 0, hb = 0;
+    switch(len){
+        case 8:
+            hb |= (uint32_t)msg[7] << 24;
+            // fallthrough
+        case 7:
+            hb |= (uint32_t)msg[6] << 16;
+            // fallthrough
+        case 6:
+            hb |= (uint32_t)msg[5] << 8;
+            // fallthrough
+        case 5:
+            hb |= (uint32_t)msg[4];
+            // fallthrough
+        case 4:
+            lb |= (uint32_t)msg[3] << 24;
+            // fallthrough
+        case 3:
+            lb |= (uint32_t)msg[2] << 16;
+            // fallthrough
+        case 2:
+            lb |= (uint32_t)msg[1] << 8;
+            // fallthrough
+        default:
+            lb |= (uint32_t)msg[0];
+    }
+    box->TDLR = lb;
+    box->TDHR = hb;
+    box->TDTR = len;
+    box->TIR  = (target_id & 0x7FF) << 21 | CAN_TI0R_TXRQ;
+    return CAN_OK;
+}
+
+void set_flood(CAN_message *msg, int incr){
+    if(incr){ incrflood = 1; return; }
+    incrflood = 0;
+    if(!msg) flood_msg = NULL;
+    else{
+#ifdef EBUG
+        SEND("flood msg: #");
+        printuhex(msg->ID);
+        for(uint8_t ctr = 0; ctr < msg->length; ++ctr){
+            PUTCHAR(' ');
+            printuhex(msg->data[ctr]);
+        }
+        NL();
+#endif
+        // I meet strange problems with `loc_flood_msg = *msg` and system memcpy, so..
+        loc_flood_msg.ID = msg->ID;
+        loc_flood_msg.length = msg->length;
+        *((uint32_t*)loc_flood_msg.data) = *((uint32_t*)msg->data);
+        if(loc_flood_msg.length > 4)
+            *((uint32_t*)&loc_flood_msg.data[4]) = *((uint32_t*)&msg->data[4]);
+        flood_msg = &loc_flood_msg;
+    }
+}
+
+static void can_process_fifo(uint8_t fifo_num){
+    if(fifo_num > 1) return;
+    LED_on(LED1); // Turn on LED1 - message received
+    CAN_FIFOMailBox_TypeDef *box = &CAN->sFIFOMailBox[fifo_num];
+    volatile uint32_t *RFxR = (fifo_num) ? &CAN->RF1R : &CAN->RF0R;
+#ifdef EBUG
+        printu(*RFxR & CAN_RF0R_FMP0); SEND(" messages in FIFO\n");
+#endif
+    // read all
+    while(*RFxR & CAN_RF0R_FMP0){ // amount of messages pending
+        // CAN_RDTxR: (16-31) - timestamp, (8-15) - filter match index, (0-3) - data length
+        /* TODO: check filter match index if more than one ID can receive */
+        CAN_message msg;
+        uint8_t *dat = msg.data;
+        uint8_t len = box->RDTR & 0x0f;
+        msg.length = len;
+        msg.ID = box->RIR >> 21;
+        //msg.filterNo = (box->RDTR >> 8) & 0xff;
+        //msg.fifoNum = fifo_num;
+        if(len){ // message can be without data
+            uint32_t hb = box->RDHR, lb = box->RDLR;
+            switch(len){
+                case 8:
+                    dat[7] = hb>>24;
+                    // fallthrough
+                case 7:
+                    dat[6] = (hb>>16) & 0xff;
+                    // fallthrough
+                case 6:
+                    dat[5] = (hb>>8) & 0xff;
+                    // fallthrough
+                case 5:
+                    dat[4] = hb & 0xff;
+                    // fallthrough
+                case 4:
+                    dat[3] = lb>>24;
+                    // fallthrough
+                case 3:
+                    dat[2] = (lb>>16) & 0xff;
+                    // fallthrough
+                case 2:
+                    dat[1] = (lb>>8) & 0xff;
+                    // fallthrough
+                case 1:
+                    dat[0] = lb & 0xff;
+            }
+        }
+        if(CAN_messagebuf_push(&msg)) return; // error: buffer is full, try later
+        *RFxR = CAN_RF0R_RFOM0; // release fifo for access to next message
+    }
+    //if(*RFxR & CAN_RF0R_FULL0) *RFxR &= ~CAN_RF0R_FULL0;
+    *RFxR = 0; // clear FOVR & FULL
+}
+
+void cec_can_isr(){
+    if(CAN->RF0R & CAN_RF0R_FOVR0){ // FIFO overrun
+        CAN->RF0R = CAN_RF0R_FOVR0;
+        can_status = CAN_FIFO_OVERRUN;
+    }
+    if(CAN->RF1R & CAN_RF1R_FOVR1){
+        CAN->RF1R = CAN_RF1R_FOVR1;
+        can_status = CAN_FIFO_OVERRUN;
+    }
+    if(CAN->MSR & CAN_MSR_ERRI){ // Error
+        CAN->MSR &= ~CAN_MSR_ERRI;
+        // request abort for problem mailbox
+        if(CAN->TSR & CAN_TSR_TERR0) CAN->TSR |= CAN_TSR_ABRQ0;
+        if(CAN->TSR & CAN_TSR_TERR1) CAN->TSR |= CAN_TSR_ABRQ1;
+        if(CAN->TSR & CAN_TSR_TERR2) CAN->TSR |= CAN_TSR_ABRQ2;
+#ifdef EBUG
+        last_err_code = CAN->ESR;
+#endif
+    }
+}
+

F0:F030,F042,F072/usbcan_gpio/can.h

@@ -0,0 +1,64 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2022 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+// min/max CAN speed (kBaud)
+#define CAN_MIN_SPEED       10
+#define CAN_MAX_SPEED       1000
+
+// amount of filter banks in STM32F0
+#define STM32F0FBANKNO      28
+// flood period in milliseconds
+#define FLOOD_PERIOD_MS     5
+
+// incoming message buffer size
+#define CAN_INMESSAGE_SIZE  (8)
+
+extern uint32_t floodT;
+
+// CAN message
+typedef struct{
+    uint8_t data[8];    // up to 8 bytes of data
+    uint8_t length;     // data length
+    uint16_t ID;        // ID of receiver
+} CAN_message;
+
+typedef enum{
+    CAN_STOP,
+    CAN_READY,
+    CAN_BUSY,
+    CAN_OK,
+    CAN_FIFO_OVERRUN
+} CAN_status;
+
+CAN_status CAN_get_status();
+
+int CAN_reinit(uint16_t speed);
+int CAN_setup(uint16_t speed);
+uint16_t CAN_getspeed();
+
+CAN_status can_send(uint8_t *msg, uint8_t len, uint16_t target_id);
+void can_proc();
+void printCANerr();
+
+CAN_message *CAN_messagebuf_pop();
+
+void set_flood(CAN_message *msg, int incr);

F0:F030,F042,F072/usbcan_gpio/canproto.c

@@ -0,0 +1,483 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2022 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stm32f0.h>
+
+#include "can.h"
+#include "hardware.h"
+#include "canproto.h"
+
+#define USBIF   ICAN
+#include "strfunc.h"
+
+#define IGN_SIZE 10
+
+extern volatile uint8_t canerror;
+
+static uint8_t ShowMsgs = 1;
+static uint16_t Ignore_IDs[IGN_SIZE];
+static uint8_t IgnSz = 0;
+
+// parse `txt` to CAN_message
+static CAN_message *parseCANmsg(char *txt){
+    static CAN_message canmsg;
+    uint32_t N;
+    char *n;
+    int ctr = -1;
+    canmsg.ID = 0xffff;
+    do{
+        n = getnum(txt, &N);
+        if(txt == n) break;
+        txt = n;
+        if(ctr == -1){
+            if(N > 0x7ff){
+                SEND("ID should be 11-bit number!\n");
+                return NULL;
+            }
+            canmsg.ID = (uint16_t)(N&0x7ff);
+            ctr = 0;
+            continue;
+        }
+        if(ctr > 7){
+            SEND("ONLY 8 data bytes allowed!\n");
+            return NULL;
+        }
+        if(N > 0xff){
+            SEND("Every data portion is a byte!\n");
+            return NULL;
+        }
+        canmsg.data[ctr++] = (uint8_t)(N&0xff);
+    }while(1);
+    if(canmsg.ID == 0xffff){
+        SEND("NO ID given, send nothing!\n");
+        return NULL;
+    }
+    SEND("Message parsed OK\n");
+    canmsg.length = (uint8_t) ctr;
+    return &canmsg;
+}
+
+// USB_sendstr command, format: ID (hex/bin/dec) data bytes (up to 8 bytes, space-delimeted)
+TRUE_INLINE void USB_sendstrCANcommand(char *txt){
+    if(CAN->MSR & CAN_MSR_INAK){
+        SEND("CAN bus is off, try to restart it\n");
+        return;
+    }
+    CAN_message *msg = parseCANmsg(txt);
+    if(!msg) return;
+    uint32_t N = 5;
+    while(CAN_BUSY == can_send(msg->data, msg->length, msg->ID)){
+        if(--N == 0) break;
+    }
+}
+
+TRUE_INLINE void CANini(char *txt){
+    uint32_t N;
+    char *n = getnum(txt, &N);
+    if(txt == n){
+        printu(CAN_getspeed());
+        SEND("kbps\n");
+        return;
+    }
+    if(N < CAN_MIN_SPEED){
+        SEND("Speed is too low\n");
+        return;
+    }else if(N > CAN_MAX_SPEED){
+        SEND("Speed is too high\n");
+        return;
+    }
+    CAN_reinit((uint16_t)N);
+    SEND("Reinit CAN bus with speed ");
+    printu(N); SEND("kbps\n");
+}
+
+TRUE_INLINE void addIGN(char *txt){
+    if(IgnSz == IGN_SIZE){
+        SEND("Ignore buffer is full\n");
+        return;
+    }
+    txt = omit_spaces(txt);
+    uint32_t N;
+    char *n = getnum(txt, &N);
+    if(txt == n){
+        SEND("No ID given\n");
+        return;
+    }
+    if(N > 0x7ff){
+        SEND("ID should be 11-bit number!\n");
+        return;
+    }
+    Ignore_IDs[IgnSz++] = (uint16_t)(N & 0x7ff);
+    SEND("Added ID "); printu(N);
+    SEND("\nIgn buffer size: "); printu(IgnSz);
+    NL();
+}
+
+TRUE_INLINE void print_ign_buf(){
+    if(IgnSz == 0){
+        SEND("Ignore buffer is empty\n");
+        return;
+    }
+    SEND("Ignored IDs:\n");
+    for(int i = 0; i < IgnSz; ++i){
+        printu(i);
+        SEND(": ");
+        printuhex(Ignore_IDs[i]);
+        NL();
+    }
+}
+
+// print ID/mask of CAN->sFilterRegister[x] half
+static void printID(uint16_t FRn){
+    if(FRn & 0x1f) return; // trash
+    printuhex(FRn >> 5);
+}
+/*
+Can filtering: FSCx=0 (CAN->FS1R) -> 16-bit identifiers
+CAN->FMR = (sb)<<8 | FINIT - init filter in starting bank sb
+CAN->FFA1R FFAx = 1 -> FIFO1, 0 -> FIFO0
+CAN->FA1R FACTx=1 - filter active
+MASK: FBMx=0 (CAN->FM1R), two filters (n in FR1 and n+1 in FR2)
+    ID:   CAN->sFilterRegister[x].FRn[0..15]
+    MASK: CAN->sFilterRegister[x].FRn[16..31]
+    FR bits:  STID[10:0] RTR IDE EXID[17:15]
+LIST: FBMx=1, four filters (n&n+1 in FR1, n+2&n+3 in FR2)
+    IDn:   CAN->sFilterRegister[x].FRn[0..15]
+    IDn+1: CAN->sFilterRegister[x].FRn[16..31]
+*/
+TRUE_INLINE void list_filters(){
+    uint32_t fa = CAN->FA1R, ctr = 0, mask = 1;
+    while(fa){
+        if(fa & 1){
+            SEND("Filter "); printu(ctr); SEND(", FIFO");
+            if(CAN->FFA1R & mask) SEND("1");
+            else SEND("0");
+            SEND(" in ");
+            if(CAN->FM1R & mask){ // up to 4 filters in LIST mode
+                SEND("LIST mode, IDs: ");
+                printID(CAN->sFilterRegister[ctr].FR1 & 0xffff);
+                SEND(" ");
+                printID(CAN->sFilterRegister[ctr].FR1 >> 16);
+                SEND(" ");
+                printID(CAN->sFilterRegister[ctr].FR2 & 0xffff);
+                SEND(" ");
+                printID(CAN->sFilterRegister[ctr].FR2 >> 16);
+            }else{ // up to 2 filters in MASK mode
+                SEND("MASK mode: ");
+                if(!(CAN->sFilterRegister[ctr].FR1&0x1f)){
+                    SEND("ID="); printID(CAN->sFilterRegister[ctr].FR1 & 0xffff);
+                    SEND(", MASK="); printID(CAN->sFilterRegister[ctr].FR1 >> 16);
+                    SEND(" ");
+                }
+                if(!(CAN->sFilterRegister[ctr].FR2&0x1f)){
+                    SEND("ID="); printID(CAN->sFilterRegister[ctr].FR2 & 0xffff);
+                    SEND(", MASK="); printID(CAN->sFilterRegister[ctr].FR2 >> 16);
+                }
+            }
+            NL();
+        }
+        fa >>= 1;
+        ++ctr;
+        mask <<= 1;
+    }
+}
+
+TRUE_INLINE void setfloodt(char *s){
+    uint32_t N;
+    s = omit_spaces(s);
+    char *n = getnum(s, &N);
+    if(s != n){
+        floodT = N;
+    }
+    SEND("t="); printu(floodT); NL();
+}
+
+/**
+ * @brief add_filter - add/modify filter
+ * @param str - string in format "bank# FIFO# mode num0 .. num3"
+ * where bank# - 0..27
+ * if there's nothing after bank# - delete filter
+ * FIFO# - 0,1
+ * mode - 'I' for ID, 'M' for mask
+ * num0..num3 - IDs in ID mode, ID/MASK for mask mode
+ */
+static void add_filter(char *str){
+    uint32_t N;
+    str = omit_spaces(str);
+    char *n = getnum(str, &N);
+    if(n == str){
+        SEND("No bank# given\n");
+        return;
+    }
+    if(N > STM32F0FBANKNO-1){
+        SEND("bank# > 27\n");
+        return;
+    }
+    uint8_t bankno = (uint8_t)N;
+    str = omit_spaces(n);
+    if(!*str){ // deactivate filter
+        SEND("Deactivate filters in bank ");
+        printu(bankno); NL();
+        CAN->FMR = CAN_FMR_FINIT;
+        CAN->FA1R &= ~(1<<bankno);
+        CAN->FMR &=~ CAN_FMR_FINIT;
+        return;
+    }
+    uint8_t fifono = 0;
+    if(*str == '1') fifono = 1;
+    else if(*str != '0'){
+        SEND("FIFO# is 0 or 1\n");
+        return;
+    }
+    str = omit_spaces(str + 1);
+    char c = *str;
+    uint8_t mode = 0; // ID
+    if(c == 'M' || c == 'm') mode = 1;
+    else if(c != 'I' && c != 'i'){
+        SEND("mode is 'M/m' for MASK and 'I/i' for IDLIST\n");
+        return;
+    }
+    str = omit_spaces(str + 1);
+    uint32_t filters[4];
+    uint32_t nfilt;
+    for(nfilt = 0; nfilt < 4; ++nfilt){
+        n = getnum(str, &N);
+        if(n == str) break;
+        filters[nfilt] = N;
+        str = omit_spaces(n);
+    }
+    if(nfilt == 0){
+        SEND("You should add at least one filter!\n");
+        return;
+    }
+    if(mode && (nfilt&1)){
+        SEND("In MASK mode you should point pairs of ID/MASK\n");
+        return;
+    }
+    CAN->FMR = CAN_FMR_FINIT;
+    uint32_t mask = 1<<bankno;
+    CAN->FA1R |= mask; // activate given filter
+    if(fifono) CAN->FFA1R |= mask; // set FIFO number
+    else CAN->FFA1R &= ~mask;
+    if(mode) CAN->FM1R &= ~mask; // MASK
+    else CAN->FM1R |= mask; // LIST
+    uint32_t F1 = (0x8f<<16);
+    uint32_t F2 = (0x8f<<16);
+    // reset filter registers to wrong value
+    CAN->sFilterRegister[bankno].FR1 = (0x8f<<16) | 0x8f;
+    CAN->sFilterRegister[bankno].FR2 = (0x8f<<16) | 0x8f;
+    switch(nfilt){
+        case 4:
+            F2 = filters[3] << 21;
+            // fallthrough
+        case 3:
+            CAN->sFilterRegister[bankno].FR2 = (F2 & 0xffff0000) | (filters[2] << 5);
+            // fallthrough
+        case 2:
+            F1 = filters[1] << 21;
+            // fallthrough
+        case 1:
+            CAN->sFilterRegister[bankno].FR1 = (F1 & 0xffff0000) | (filters[0] << 5);
+    }
+    CAN->FMR &=~ CAN_FMR_FINIT;
+    SEND("Added filter with ");
+    printu(nfilt); SEND(" parameters\n");
+}
+
+static const char *helpmsg =
+    REPOURL
+    "'a' - add ID to ignore list (max 10 IDs)\n"
+    "'b' - reinit CAN with given baudrate or get current\n"
+    "'c' - get CAN status\n"
+    "'d' - delete ignore list\n"
+#ifdef STM32F072xB
+    "'D' - activate DFU mode\n"
+#endif
+    "'e' - get CAN errcodes\n"
+    "'f' - add/delete filter, format: bank# FIFO# mode(M/I) num0 [num1 [num2 [num3]]]\n"
+    "'F' - send/clear flood message: F ID byte0 ... byteN\n"
+    "'i' - send incremental flood message (ID == ID for `F`)\n"
+    "'I' - reinit CAN\n"
+    "'l' - list all active filters\n"
+    "'o' - turn LEDs OFF\n"
+    "'O' - turn LEDs ON\n"
+    "'p' - print ignore buffer\n"
+    "'P' - pause/resume in packets displaying\n"
+    "'R' - software reset\n"
+    "'s/S' - send data over CAN: s ID byte0 .. byteN\n"
+    "'t' - change flood period (>=0ms)\n"
+    "'T' - get time from start (ms)\n"
+;
+
+TRUE_INLINE void getcanstat(){
+    SEND("CAN_MSR=");
+    printuhex(CAN->MSR);
+    SEND("\nCAN_TSR=");
+    printuhex(CAN->TSR);
+    SEND("\nCAN_RF0R=");
+    printuhex(CAN->RF0R);
+    SEND("\nCAN_RF1R=");
+    printuhex(CAN->RF1R);
+    NL();
+}
+
+/**
+ * @brief cmd_parser - command parsing
+ * @param txt   - buffer with commands & data
+ * @param isUSB - == 1 if data got from USB
+ */
+static void cmd_parser(char *txt){
+    char _1st = txt[0];
+    ++txt;
+    /*
+     * parse long commands here
+     */
+    switch(_1st){
+        case 'a':
+            addIGN(txt);
+            return;
+        break;
+        case 'b':
+            CANini(txt);
+            return;
+        break;
+        case 'f':
+            add_filter(txt);
+            return;
+        break;
+        case 'F':
+            set_flood(parseCANmsg(txt), 0);
+            return;
+        break;
+        case 's':
+        case 'S':
+            USB_sendstrCANcommand(txt);
+            return;
+        break;
+        case 't':
+            setfloodt(txt);
+            return;
+        break;
+    }
+    if(*txt) _1st = '?'; // help for wrong message length
+    switch(_1st){
+        case 'c':
+            getcanstat();
+        break;
+        case 'd':
+            IgnSz = 0;
+        break;
+        case 'e':
+            printCANerr();
+        break;
+#ifdef STM32F072xB
+        case 'D':
+            USB_sendstr("Go into DFU mode\n");
+            USB_sendall();
+            Jump2Boot();
+        break;
+#endif
+        case 'i':
+            set_flood(NULL, 1);
+            SEND("Incremental flooding is ON ('F' to off)\n");
+        break;
+        case 'I':
+            SEND("CANspeed=");
+            printu(CAN_reinit(0));
+            NL();
+        break;
+        case 'l':
+            list_filters();
+        break;
+        case 'o':
+            ledsON = 0;
+            LED_off(LED0);
+            LED_off(LED1);
+            SEND("LEDS=0\n");
+        break;
+        case 'O':
+            ledsON = 1;
+            SEND("LEDS=1\n");
+        break;
+        case 'p':
+            print_ign_buf();
+        break;
+        case 'P':
+            ShowMsgs = !ShowMsgs;
+            if(ShowMsgs) SEND("Resume\n");
+            else SEND("Pause\n");
+        break;
+        case 'R':
+            SEND("Soft reset\n");
+            USB_sendall(ICAN); // wait until everything will gone
+            NVIC_SystemReset();
+        break;
+        case 'T':
+            SEND("Time (ms): ");
+            printu(Tms);
+            NL();
+        break;
+        default: // help
+            SEND(helpmsg);
+        break;
+    }
+}
+
+// check Ignore_IDs & return 1 if ID isn't in list
+static uint8_t isgood(uint16_t ID){
+    for(int i = 0; i < IgnSz; ++i)
+        if(Ignore_IDs[i] == ID) return 0;
+    return 1;
+}
+
+void CANUSB_process(){
+    char inbuff[MAXSTRLEN];
+    CAN_message *can_mesg;
+    uint32_t lastT = 0;
+    can_proc();
+    if(CAN_get_status() == CAN_FIFO_OVERRUN){
+        SEND("CAN bus fifo overrun occured!\n");
+    }
+    while((can_mesg = CAN_messagebuf_pop())){
+        IWDG->KR = IWDG_REFRESH;
+        if(can_mesg && isgood(can_mesg->ID)){
+            LED_on(LED0);
+            lastT = Tms;
+            if(!lastT) lastT = 1;
+            if(ShowMsgs){ // new data in buff
+                IWDG->KR = IWDG_REFRESH;
+                uint8_t len = can_mesg->length;
+                printu(Tms);
+                SEND(" #");
+                printuhex(can_mesg->ID);
+                for(uint8_t ctr = 0; ctr < len; ++ctr){
+                    PUTCHAR(' ');
+                    printuhex(can_mesg->data[ctr]);
+                }
+                NL();
+            }
+        }
+    }
+    if(lastT && (Tms - lastT > 199)){
+        LED_off(LED0);
+        lastT = 0;
+    }
+    int l = RECV(inbuff, MAXSTRLEN);
+    if(l < 0) SEND("ERROR: USB buffer overflow or string was too long\n");
+    else if(l) cmd_parser(inbuff);
+}

F0:F030,F042,F072/usbcan_gpio/canproto.h

@@ -0,0 +1,22 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2022 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+void CANUSB_process();
+

F0:F030,F042,F072/usbcan_gpio/flash.c

@@ -0,0 +1,181 @@
+/*
+ * flash.c
+ *
+ * Copyright 2017 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * 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 2 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ *
+ */
+
+#include <stm32f0.h>
+#include <string.h> // memcpy
+#include "can.h"
+#include "flash.h"
+//#include "strfunc.h"
+
+extern const uint32_t __varsstart, _BLOCKSIZE;
+
+static const uint32_t blocksize = (uint32_t)&_BLOCKSIZE;
+
+// max amount of Config records stored (will be recalculate in flashstorage_init()
+static uint32_t maxCnum = 1024 / sizeof(user_conf); // can't use blocksize here
+
+static int erase_flash(const void*, const void*);
+static int write2flash(const void*, const void*, uint32_t);
+// don't write `static` here, or get error:
+//      'memcpy' forming offset 8 is out of the bounds [0, 4] of object '__varsstart' with type 'uint32_t'
+const user_conf *Flash_Data = (const user_conf *)(&__varsstart);
+
+user_conf the_conf = {
+    .userconf_sz = sizeof(user_conf),
+    .CANspeed = 100,
+    .iInterface = {
+        [ICAN] =  u"USB-CAN",
+        [IGPIO] = u"USB-GPIO",
+    },
+    .iIlengths = {14, 16},
+};
+
+int currentconfidx = -1; // index of current configuration
+
+/**
+ * @brief binarySearch - binary search in flash for last non-empty cell
+ *          any struct searched should have its sizeof() @ the first field!!!
+ * @param l - left index
+ * @param r - right index (should be @1 less than last index!)
+ * @param start - starting address
+ * @param stor_size - size of structure to search
+ * @return index of non-empty cell or -1
+ */
+static int binarySearch(int r, const uint8_t *start, int stor_size){
+    int l = 0;
+    while(r >= l){
+        int mid = l + (r - l) / 2;
+        const uint8_t *s = start + mid * stor_size;
+        if(*((const uint16_t*)s) == stor_size){
+            if(*((const uint16_t*)(s + stor_size)) == 0xffff){ // next is free
+                return mid;
+            }else{ // element is to the right
+                l = mid + 1;
+            }
+        }else{ // element is to the left
+            r = mid - 1;
+        }
+    }
+    return -1; // not found
+}
+
+/**
+ * @brief flashstorage_init - initialization of user conf storage
+ * run in once @ start
+ */
+void flashstorage_init(){
+    if(FLASH_SIZE > 0 && FLASH_SIZE < 20000){
+        uint32_t flsz = FLASH_SIZE * blocksize; // size in bytes
+        flsz -= (uint32_t)(&__varsstart) - FLASH_BASE;
+        maxCnum = flsz / sizeof(user_conf);
+    }
+    // -1 if there's no data at all & flash is clear; maxnum-1 if flash is full
+    currentconfidx = binarySearch((int)maxCnum-2, (const uint8_t*)Flash_Data, sizeof(user_conf));
+    if(currentconfidx > -1){
+        memcpy(&the_conf, &Flash_Data[currentconfidx], sizeof(user_conf));
+    }
+}
+
+// store new configuration
+// @return 0 if all OK
+int store_userconf(){
+    // maxnum - 3 means that there always should be at least one empty record after last data
+    // for binarySearch() checking that there's nothing more after it!
+    if(currentconfidx > (int)maxCnum - 3){ // there's no more place
+        currentconfidx = 0;
+        if(erase_flash(Flash_Data, NULL)) return 1;
+    }else ++currentconfidx; // take next data position (0 - within first run after firmware flashing)
+    return write2flash((const void*)&Flash_Data[currentconfidx], &the_conf, sizeof(the_conf));
+}
+
+static int write2flash(const void *start, const void *wrdata, uint32_t stor_size){
+    int ret = 0;
+    if (FLASH->CR & FLASH_CR_LOCK){ // unloch flash
+        FLASH->KEYR = FLASH_KEY1;
+        FLASH->KEYR = FLASH_KEY2;
+    }
+    while (FLASH->SR & FLASH_SR_BSY) IWDG->KR = IWDG_REFRESH;
+    FLASH->SR = FLASH_SR_EOP | FLASH_SR_PGERR | FLASH_SR_WRPRTERR; // clear all flags
+    FLASH->CR |= FLASH_CR_PG;
+    const uint16_t *data = (const uint16_t*) wrdata;
+    volatile uint16_t *address = (volatile uint16_t*) start;
+    uint32_t i, count = (stor_size + 1) / 2;
+    for (i = 0; i < count; ++i){
+        IWDG->KR = IWDG_REFRESH;
+        *(volatile uint16_t*)(address + i) = data[i];
+        while (FLASH->SR & FLASH_SR_BSY) IWDG->KR = IWDG_REFRESH;
+        if(FLASH->SR & FLASH_SR_PGERR){
+            //SEND("Prog err\n");
+            ret = 1; // program error - meet not 0xffff
+            break;
+        }
+        FLASH->SR = FLASH_SR_EOP | FLASH_SR_PGERR | FLASH_SR_WRPRTERR;
+    }
+    FLASH->CR &= ~(FLASH_CR_PG);
+    return ret;
+}
+
+/**
+ * @brief erase_flash - erase N pages of flash memory
+ * @param start  - first address
+ * @param end    - last address (or NULL if need to erase all flash remaining)
+ * @return 0 if succeed
+ */
+static int erase_flash(const void *start, const void *end){
+    int ret = 0;
+    uint32_t nblocks = 1, flsz = 0;
+    if(!end){ // erase all remaining
+        if(FLASH_SIZE > 0 && FLASH_SIZE < 20000){
+            flsz = FLASH_SIZE * blocksize; // size in bytes
+            flsz -= (uint32_t)start - FLASH_BASE;
+        }
+    }else{ // erase a part
+        flsz = (uint32_t)end - (uint32_t)start;
+    }
+    nblocks = flsz / blocksize;
+    if(nblocks == 0 || nblocks >= FLASH_SIZE) return 1;
+    if((FLASH->CR & FLASH_CR_LOCK) != 0){
+        FLASH->KEYR = FLASH_KEY1;
+        FLASH->KEYR = FLASH_KEY2;
+    }
+    while(FLASH->SR & FLASH_SR_BSY) IWDG->KR = IWDG_REFRESH;
+    FLASH->SR = FLASH_SR_EOP | FLASH_SR_PGERR | FLASH_SR_WRPRTERR;
+    FLASH->CR |= FLASH_CR_PER;
+    for(uint32_t i = 0; i < nblocks; ++i){
+        //SEND("Erase block #"); printu(i); newline();
+        FLASH->AR = (uint32_t)Flash_Data + i * blocksize;
+        FLASH->CR |= FLASH_CR_STRT;
+        while(FLASH->SR & FLASH_SR_BSY) IWDG->KR = IWDG_REFRESH;
+        FLASH->SR = FLASH_SR_EOP;
+        if(FLASH->SR & FLASH_SR_WRPRTERR){
+            ret = 1;
+            FLASH->SR = FLASH_SR_WRPRTERR;
+            break;
+        }
+    }
+    FLASH->CR &= ~FLASH_CR_PER;
+    return ret;
+}
+
+int erase_storage(){
+    return erase_flash(Flash_Data, NULL);
+}

F0:F030,F042,F072/usbcan_gpio/flash.h

@@ -0,0 +1,56 @@
+/*
+ * flash.h
+ *
+ * Copyright 2017 Edward V. Emelianov <eddy@sao.ru, edward.emelianoff@gmail.com>
+ *
+ * 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 2 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ *
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include "usb_descr.h"
+
+// register with flash size (in blocks)
+#ifndef FLASH_SIZE_REG
+#define FLASH_SIZE_REG      ((uint32_t)0x1FFFF7CC)
+#endif
+
+#define FLASH_SIZE          *((uint16_t*)FLASH_SIZE_REG)
+
+// maximal size (in letters, ASCII, no ending \0) of iInterface for settings
+#define MAX_IINTERFACE_SZ   (16)
+
+/*
+ * struct to save user configurations
+ */
+typedef struct __attribute__((packed, aligned(4))){
+    uint16_t userconf_sz;           // "magick number"
+    uint16_t CANspeed;              // default CAN speed (in kBaud!!!)
+    uint16_t iInterface[InterfacesAmount][MAX_IINTERFACE_SZ]; // we store Interface name here in UTF!
+    uint8_t  iIlengths[InterfacesAmount]; // length in BYTES (symbols amount x2)!
+} user_conf;
+
+extern user_conf the_conf; // global user config (read from FLASH to RAM)
+extern int currentconfidx;
+
+// data from ld-file: start address of storage
+
+void flashstorage_init();
+int store_userconf();
+void dump_userconf();
+int erase_storage();

F0:F030,F042,F072/usbcan_gpio/gpioproto.c

@@ -0,0 +1,146 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2026 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stm32f0.h>
+
+#include "can.h"
+#include "flash.h"
+#include "gpioproto.h"
+
+#define USBIF   IGPIO
+#include "strfunc.h"
+
+extern volatile uint32_t Tms;
+static const char *const sOKn = "OK\n", *const sERRn = "ERR\n";
+
+const char *helpstring =
+    REPOURL
+    "d  - dump flash\n"
+    "ix - rename interface number x (0 - CAN, 1 - GPIO)\n"
+    "Cx - starting CAN bus speed (kBaud)\n"
+    "Dx - send text x to CAN USB interface\n"
+    "E  - erase storage\n"
+    "F  - reinit configurations from flash\n"
+    "R  - soft reset\n"
+    "S  - store new parameters into flash\n"
+    "T  - print current Tms\n"
+;
+
+static void dumpflash(){
+    SEND("userconf_sz="); SEND(u2str(the_conf.userconf_sz));
+    SEND("\ncurrentconfidx="); SENDn(i2str(currentconfidx));
+    for(int i = 0; i < InterfacesAmount; ++i){
+        SEND("interface"); PUTCHAR('0' + i);
+        PUTCHAR('=');
+        int l = the_conf.iIlengths[i] / 2;
+        char *ptr = (char*) the_conf.iInterface[i];
+        for(int j = 0; j < l; ++j){
+            PUTCHAR(*ptr);
+            ptr += 2;
+        }
+        NL();
+    }
+    SEND("canspeed="); SENDn(u2str(the_conf.CANspeed));
+}
+
+// set new interface name
+static const char* setiface(char *str){
+    if(!str || !*str) goto err;
+    uint32_t N;
+    const char *nxt = getnum(str, &N);
+    if(!nxt || nxt == str || N >= InterfacesAmount) goto err;
+    //nxt = strchr(nxt, '=');
+    //if(!nxt || !*(++nxt)) goto err;
+    nxt = omit_spaces(nxt);
+    if(!nxt || !*nxt) goto err;
+    int l = strlen(nxt);
+    if(l > MAX_IINTERFACE_SZ) goto err;
+    the_conf.iIlengths[N] = (uint8_t) l * 2;
+    char *ptr = (char*)the_conf.iInterface[N];
+    for(int i = 0; i < l; ++i){
+        char c = *nxt++;
+        *ptr++ = (c > ' ') ? c : '_';
+        *ptr++ = 0;
+    }
+    return sOKn;
+err:
+    return sERRn;
+}
+
+static const char* setCANspeed(char *buf){
+    uint32_t N;
+    if(buf == getnum(buf, &N)) return sERRn;
+    if(N < CAN_MIN_SPEED || N > CAN_MAX_SPEED) return sERRn;
+    the_conf.CANspeed = N;
+    return sOKn;
+}
+
+static const char *cmd_parser(char *buf){
+    if(!buf || !*buf) return NULL;
+    if(strlen(buf) > 1){
+        // "long" commands
+        char c = *buf++;
+        switch(c){
+        case 'C':
+            return setCANspeed(buf);
+        case 'D':
+            if(USB_sendstr(ICAN, buf)) return sOKn;
+            else return sERRn;
+        case 'i':
+            return setiface(buf);
+        default:
+            return buf-1; // echo wrong data
+        }
+    }
+    // "short" commands
+    switch(*buf){
+    case 'd':
+        dumpflash();
+        break;
+    case 'E':
+        if(erase_storage()) return sERRn;
+        return sOKn;
+    case 'F':
+        flashstorage_init();
+        return sOKn;
+    case 'R':
+        NVIC_SystemReset();
+        return NULL;
+    case 'S':
+        if(store_userconf()) return sERRn;
+        return sOKn;
+    case 'T':
+        SEND("T=");
+        SENDn(u2str(Tms));
+        break;
+    default: // help
+        SEND(helpstring);
+        break;
+    }
+    return NULL;
+}
+
+void GPIO_process(){
+    char inbuff[MAXSTRLEN];
+    int l = RECV(inbuff, MAXSTRLEN);
+    if(l < 0) SEND("ERROR: USB buffer overflow or string was too long\n");
+    else if(l){
+        const char *ans = cmd_parser(inbuff);
+        if(ans) SEND(ans);
+    }
+}

F0:F030,F042,F072/usbcan_gpio/gpioproto.h

@@ -0,0 +1,21 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2026 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+void GPIO_process();

F0:F030,F042,F072/usbcan_gpio/hardware.c

@@ -0,0 +1,85 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2022 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "hardware.h"
+
+uint8_t ledsON = 0;
+
+void gpio_setup(void){
+    RCC->AHBENR |= RCC_AHBENR_GPIOAEN | RCC_AHBENR_GPIOBEN;
+    // Set LEDS (PB15/PA8) as output
+    pin_set(LED0_port, LED0_pin); // clear LEDs
+    pin_set(LED1_port, LED1_pin);
+    GPIOB->MODER = (GPIOB->MODER & ~(GPIO_MODER_MODER15)) |
+                    GPIO_MODER_MODER15_O;
+    GPIOA->MODER = (GPIOA->MODER & ~(GPIO_MODER_MODER8)) |
+                   GPIO_MODER_MODER8_O;
+}
+
+void iwdg_setup(){
+    uint32_t tmout = 16000000;
+    /* Enable the peripheral clock RTC */
+    /* (1) Enable the LSI (40kHz) */
+    /* (2) Wait while it is not ready */
+    RCC->CSR |= RCC_CSR_LSION; /* (1) */
+    while((RCC->CSR & RCC_CSR_LSIRDY) != RCC_CSR_LSIRDY){if(--tmout == 0) break;} /* (2) */
+    /* Configure IWDG */
+    /* (1) Activate IWDG (not needed if done in option bytes) */
+    /* (2) Enable write access to IWDG registers */
+    /* (3) Set prescaler by 64 (1.6ms for each tick) */
+    /* (4) Set reload value to have a rollover each 2s */
+    /* (5) Check if flags are reset */
+    /* (6) Refresh counter */
+    IWDG->KR = IWDG_START; /* (1) */
+    IWDG->KR = IWDG_WRITE_ACCESS; /* (2) */
+    IWDG->PR = IWDG_PR_PR_1; /* (3) */
+    IWDG->RLR = 1250; /* (4) */
+    tmout = 16000000;
+    while(IWDG->SR){if(--tmout == 0) break;} /* (5) */
+    IWDG->KR = IWDG_REFRESH; /* (6) */
+}
+
+#ifdef STM32F072xB
+void Jump2Boot(){
+    void (*SysMemBootJump)(void);  
+    volatile uint32_t addr = 0x1FFFC800;
+    // reset systick
+    SysTick->CTRL = 0;
+    // reset clocks
+
+    RCC->APB1RSTR = RCC_APB1RSTR_CECRST    | RCC_APB1RSTR_DACRST    | RCC_APB1RSTR_PWRRST    | RCC_APB1RSTR_CRSRST  |
+                    RCC_APB1RSTR_CANRST    | RCC_APB1RSTR_USBRST    | RCC_APB1RSTR_I2C2RST   | RCC_APB1RSTR_I2C1RST |
+                    RCC_APB1RSTR_USART4RST | RCC_APB1RSTR_USART3RST | RCC_APB1RSTR_USART2RST | RCC_APB1RSTR_SPI2RST |
+                    RCC_APB1RSTR_WWDGRST   | RCC_APB1RSTR_TIM14RST  |
+            RCC_APB1RSTR_TIM7RST   | RCC_APB1RSTR_TIM6RST |
+                    RCC_APB1RSTR_TIM3RST   | RCC_APB1RSTR_TIM2RST;
+    RCC->APB2RSTR = RCC_APB2RSTR_DBGMCURST | RCC_APB2RSTR_TIM17RST | RCC_APB2RSTR_TIM16RST |
+            RCC_APB2RSTR_TIM15RST |
+                    RCC_APB2RSTR_USART1RST | RCC_APB2RSTR_SPI1RST  | RCC_APB2RSTR_TIM1RST  | RCC_APB2RSTR_ADCRST   | RCC_APB2RSTR_SYSCFGRST;
+    RCC->AHBRSTR = 0;
+    RCC->APB1RSTR = 0;
+    RCC->APB2RSTR = 0;
+    // remap memory to 0 (only for STM32F0)
+    SYSCFG->CFGR1 = 0x01; __DSB(); __ISB();
+    SysMemBootJump = (void (*)(void)) (*((uint32_t *)(addr + 4)));
+    // set main stack pointer
+    __set_MSP(*((uint32_t *)addr));
+    // jump to bootloader
+    SysMemBootJump();
+}
+#endif

F0:F030,F042,F072/usbcan_gpio/hardware.h

@@ -0,0 +1,51 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2022 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stm32f0.h>
+
+#define CONCAT(a,b)     a ## b
+#define STR_HELPER(s)   #s
+#define STR(s)          STR_HELPER(s)
+
+#define FORMUSART(X)    CONCAT(USART, X)
+#define USARTX          FORMUSART(USARTNUM)
+
+// LEDS: 0 - PB15, 1 - PA8
+// LED0
+#define LED0_port   GPIOB
+#define LED0_pin    (1<<15)
+// LED1
+#define LED1_port   GPIOA
+#define LED1_pin    (1<<8)
+
+#define LED_blink(x)    do{if(ledsON) pin_toggle(x ## _port, x ## _pin);}while(0)
+#define LED_on(x)       do{if(ledsON) pin_clear(x ## _port, x ## _pin);}while(0)
+#define LED_off(x)      do{pin_set(x ## _port, x ## _pin);}while(0)
+
+
+extern volatile uint32_t Tms;
+
+extern uint8_t ledsON;
+
+void gpio_setup(void);
+void iwdg_setup();
+#ifdef STM32F072xB
+void Jump2Boot();
+#endif

F0:F030,F042,F072/usbcan_gpio/main.c

@@ -0,0 +1,50 @@
+/*
+ * This file is part of the usbcangpio project.
+ * Copyright 2022 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "can.h"
+#include "flash.h"
+#include "gpioproto.h"
+#include "hardware.h"
+#include "canproto.h"
+
+volatile uint32_t Tms = 0;
+
+/* Called when systick fires */
+void sys_tick_handler(void){
+    ++Tms;
+}
+
+int main(void){
+    sysreset();
+    SysTick_Config(6000, 1);
+    flashstorage_init();
+    gpio_setup();
+    USB_setup();
+    CAN_setup(the_conf.CANspeed);
+    RCC->CSR |= RCC_CSR_RMVF; // remove reset flags
+#ifndef EBUG
+    iwdg_setup();
+#endif
+    while (1){
+        IWDG->KR = IWDG_REFRESH; // refresh watchdog
+        CANUSB_process();
+        GPIO_process();
+    }
+    return 0;
+}
+

F0:F030,F042,F072/usbcan_gpio/openocd.cfg

@@ -0,0 +1,4 @@
+set FLASH_SIZE 0x8000
+
+source [find interface/stlink-v2-1.cfg]
+source [find target/stm32f0x.cfg]

F0:F030,F042,F072/usbcan_gpio/ringbuffer.c

@@ -0,0 +1,185 @@
+/*
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+#include <stm32f0.h>
+#include "ringbuffer.h"
+
+static int datalen(ringbuffer *b){
+    if(b->tail >= b->head) return (b->tail - b->head);
+    else return (b->length - b->head + b->tail);
+}
+
+// stored data length
+int RB_datalen(ringbuffer *b){
+    if(!b || b->busy) return -1;
+    b->busy = 1;
+    int l = datalen(b);
+    b->busy = 0;
+    return l;
+}
+
+static int hasbyte(ringbuffer *b, uint8_t byte){
+    if(!b || 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;
+}
+
+/**
+ * @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 or busy
+ */
+int RB_hasbyte(ringbuffer *b, uint8_t byte){
+    if(!b || b->busy) return -1;
+    b->busy = 1;
+    int ret = hasbyte(b, byte);
+    b->busy = 0;
+    return ret;
+}
+
+// increment head or tail
+TRUE_INLINE void incr(ringbuffer *b, volatile int *what, int n){
+    *what += n;
+    if(*what >= b->length) *what -= b->length;
+}
+
+static int read(ringbuffer *b, uint8_t *s, int len){
+    int l = 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;
+    memcpy(s, b->data + b->head, _1st);
+    if(_1st < len && l > _1st){
+        memcpy(s+_1st, b->data, l - _1st);
+        incr(b, &b->head, l);
+        return l;
+    }
+    incr(b, &b->head, _1st);
+    return _1st;
+}
+
+/**
+ * @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 or -1 if busy
+ */
+int RB_read(ringbuffer *b, uint8_t *s, int len){
+    if(!b || b->busy || !s || len < 1) return -1;
+    b->busy = 1;
+    int r = read(b, s, len);
+    b->busy = 0;
+    return r;
+}
+
+// length of data from current position to `byte` (including byte)
+static int lento(ringbuffer *b, uint8_t byte){
+    int idx = hasbyte(b, byte);
+    if(idx < 0) return 0;
+    int partlen = idx + 1 - b->head;
+    // now calculate length of new data portion
+    if(idx < b->head) partlen += b->length;
+    return partlen;
+}
+
+static int readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
+    int partlen = lento(b, byte);
+    if(!partlen) return 0;
+    if(partlen > len) return -1;
+    return read(b, s, partlen);
+}
+
+/**
+ * @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 or NULL to clear data
+ * @param len - length of `s` or 0 to clear data
+ * @return amount of bytes written (negative, if len<data in buffer or buffer is busy)
+ */
+int RB_readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
+    if(!b || b->busy) return -1;
+    b->busy = 1;
+    int n = 0;
+    if(s && len > 0){
+        n = readto(b, byte, s, len);
+    }else{
+        incr(b, &b->head, lento(b, byte)); // just throw data out
+    }
+    b->busy = 0;
+    return n;
+}
+
+int RB_datalento(ringbuffer *b, uint8_t byte){
+    if(!b || b->busy) return -1;
+    b->busy = 1;
+    int n = lento(b, byte);
+    b->busy = 0;
+    return n;
+}
+
+// if l < rest of buffer, truncate and return actually written bytes
+static int write(ringbuffer *b, const uint8_t *str, int l){
+    int r = b->length - 1 - datalen(b); // rest length
+    if(r < 1) return 0;
+    if(l > r) l = r;
+    int _1st = b->length - b->tail;
+    if(_1st > l) _1st = l;
+    memcpy(b->data + b->tail, str, _1st);
+    if(_1st < l){ // add another piece from start
+        memcpy(b->data, str+_1st, l-_1st);
+    }
+    incr(b, &b->tail, l);
+    return l;
+}
+
+/**
+ * @brief RB_write - write some data to ringbuffer
+ * @param b - buffer
+ * @param str - data
+ * @param l - length
+ * @return amount of bytes written or -1 if busy
+ */
+int RB_write(ringbuffer *b, const uint8_t *str, int l){
+    if(!b || b->busy || !str || l < 1) return -1;
+    b->busy = 1;
+    int w = write(b, str, l);
+    b->busy = 0;
+    return w;
+}
+
+// just delete all information in buffer `b`
+int RB_clearbuf(ringbuffer *b){
+    if(!b || b->busy) return -1;
+    b->busy = 1;
+    b->head = 0;
+    b->tail = 0;
+    b->busy = 0;
+    return 1;
+}

F0:F030,F042,F072/usbcan_gpio/ringbuffer.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+typedef struct{
+    uint8_t *data;      // data buffer
+    const int length;   // its length
+    int head;           // head index
+    int tail;           // tail index
+    volatile int busy; // == TRUE if buffer is busy now
+} 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);
+int RB_datalento(ringbuffer *b, uint8_t byte);
+int RB_clearbuf(ringbuffer *b);

F0:F030,F042,F072/usbcan_gpio/strfunc.c

@@ -0,0 +1,264 @@
+/*
+ * Copyright 2026 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <stm32f0.h>
+
+/**
+ * @brief hexdump - dump hex array by 16 bytes in string
+ * @param sendfun - function to send data
+ * @param arr - array to dump
+ * @param len - length of `arr`
+ */
+void hexdump(int (*sendfun)(const char *s), uint8_t *arr, uint16_t len){
+    char buf[52], *bptr = buf;
+    for(uint16_t l = 0; l < len; ++l, ++arr){
+        for(int16_t j = 1; j > -1; --j){
+            register uint8_t half = (*arr >> (4*j)) & 0x0f;
+            if(half < 10) *bptr++ = half + '0';
+            else *bptr++ = half - 10 + 'a';
+        }
+        if(l % 16 == 15){
+            *bptr++ = '\n';
+            *bptr = 0;
+            sendfun(buf);
+            bptr = buf;
+        }else *bptr++ = ' ';
+    }
+    if(bptr != buf){
+        *bptr++ = '\n';
+        *bptr = 0;
+        sendfun(buf);
+    }
+}
+
+/**
+ * @brief _2str - convert value into string buffer
+ * @param val - |value|
+ * @param minus - ==0 if value > 0
+ * @return buffer with number
+ */
+static char *_2str(uint32_t  val, uint8_t minus){
+    static char strbuf[12];
+    char *bufptr = &strbuf[11];
+    *bufptr = 0;
+    if(!val){
+        *(--bufptr) = '0';
+    }else{
+        while(val){
+            uint32_t x = val / 10;
+            *(--bufptr) = (val - 10*x) + '0';
+            val = x;
+        }
+    }
+    if(minus) *(--bufptr) = '-';
+    return bufptr;
+}
+
+// return string with number `val`
+char *u2str(uint32_t val){
+    return _2str(val, 0);
+}
+char *i2str(int32_t i){
+    uint8_t minus = 0;
+    uint32_t val;
+    if(i < 0){
+        minus = 1;
+        val = -i;
+    }else val = i;
+    return _2str(val, minus);
+}
+
+/**
+ * @brief uhex2str - print 32bit unsigned int as hex
+ * @param val - value
+ * @return string with number
+ */
+char *uhex2str(uint32_t val){
+    static char buf[12] = "0x";
+    int npos = 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) buf[npos++] = half + '0';
+            else buf[npos++] = half - 10 + 'a';
+        }
+    }
+    buf[npos] = 0;
+    return buf;
+}
+
+/**
+ * @brief omit_spaces - eliminate leading spaces and other trash in string
+ * @param buf - string
+ * @return - pointer to first character in `buf` > ' '
+ */
+const char *omit_spaces(const char *buf){
+    while(*buf){
+        if(*buf > ' ') break;
+        ++buf;
+    }
+    return buf;
+}
+
+/**
+ * @brief getdec - read decimal number & return pointer to next non-number symbol
+ * @param buf - string
+ * @param N - number read
+ * @return Next non-number symbol. In case of overflow return `buf` and N==0xffffffff
+ */
+static const 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 buf;
+}
+// read hexadecimal number (without 0x prefix!)
+static const char *gethex(const char *buf, uint32_t *N){
+    const char *start = 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 buf;
+}
+// read octal number (without 0 prefix!)
+static const char *getoct(const char *buf, uint32_t *N){
+    const 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 buf;
+}
+// read binary number (without b prefix!)
+static const char *getbin(const char *buf, uint32_t *N){
+    const 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 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)
+ */
+const char *getnum(const char *txt, uint32_t *N){
+    const char *nxt = NULL;
+    const 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;
+}
+
+// get signed integer
+const char *getint(const char *txt, int32_t *I){
+    const char *s = omit_spaces(txt);
+    int32_t sign = 1;
+    uint32_t U;
+    if(*s == '-'){
+    	sign = -1;
+    	++s;
+    }
+    const char *nxt = getnum(s, &U);
+    if(nxt == s) return txt;
+    if(U & 0x80000000) return txt; // overfull
+    *I = sign * (int32_t)U;
+    return nxt;
+}

F0:F030,F042,F072/usbcan_gpio/strfunc.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2026 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifndef USBIF
+#error "Define USBIF to used interface before including this!"
+#endif
+
+#include <stdint.h>
+#include <string.h>
+#include "usb_dev.h"
+#include "usb_descr.h"
+#include "version.inc"
+
+// DEBUG/RELEASE build
+#ifdef EBUG
+#define RLSDBG "debug"
+#else
+#define RLSDBG "release"
+#endif
+
+#define REPOURL "https://github.com/eddyem/stm32samples/tree/master/F0:F030,F042,F072/usbcan_gpio " RLSDBG " build #" BUILD_NUMBER "@" BUILD_DATE "\n"
+
+// max string len to '\n' (including '\0')
+#define MAXSTRLEN    128
+
+void hexdump(int (*sendfun)(const char *s), uint8_t *arr, uint16_t len);
+const char *u2str(uint32_t val);
+const char *i2str(int32_t i);
+const char *uhex2str(uint32_t val);
+char *getnum(const char *txt, uint32_t *N);
+char *omit_spaces(const char *buf);
+char *getint(const char *txt, int32_t *I);
+
+#define printu(u)       USB_sendstr(USBIF, u2str(u))
+#define printuhex(u)    USB_sendstr(USBIF, uhex2str(u))
+

F0:F030,F042,F072/usbcan_gpio/usb_descr.c

@@ -0,0 +1,248 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h> // memcpy
+
+#include "flash.h" // MAX_IINTERFACE_SZ
+#include "usb_descr.h"
+
+// low/high for uint16_t
+#define L16(x)              (x & 0xff)
+#define H16(x)              (x >> 8)
+
+static const uint8_t USB_DeviceDescriptor[] = {
+    USB_DT_DEVICE_SIZE, // bLength
+    USB_DT_DEVICE, // bDescriptorType
+    L16(bcdUSB), // bcdUSB_L
+    H16(bcdUSB), // bcdUSB_H
+    USB_CLASS_MISC, // bDeviceClass
+    bDeviceSubClass, // bDeviceSubClass
+    bDeviceProtocol, // bDeviceProtocol
+    USB_EP0BUFSZ, // bMaxPacketSize
+    L16(idVendor), // idVendor_L
+    H16(idVendor), // idVendor_H
+    L16(idProduct), // idProduct_L
+    H16(idProduct), // idProduct_H
+    L16(bcdDevice_Ver), // bcdDevice_Ver_L
+    H16(bcdDevice_Ver), // bcdDevice_Ver_H
+    iMANUFACTURER_DESCR, // iManufacturer - indexes of string descriptors in array
+    iPRODUCT_DESCR, // iProduct
+    iSERIAL_DESCR, // iSerial
+    bNumConfigurations // bNumConfigurations
+};
+
+static const uint8_t USB_DeviceQualifierDescriptor[] = {
+    USB_DT_QUALIFIER_SIZE, //bLength
+    USB_DT_QUALIFIER, // bDescriptorType
+    L16(bcdUSB), // bcdUSB_L
+    H16(bcdUSB), // bcdUSB_H
+    USB_CLASS_PER_INTERFACE, // bDeviceClass
+    bDeviceSubClass, // bDeviceSubClass
+    bDeviceProtocol, // bDeviceProtocol
+    USB_EP0BUFSZ, // bMaxPacketSize0
+    bNumConfigurations, // bNumConfigurations
+    0 // Reserved
+};
+
+#define wTotalLength  (USB_DT_CONFIG_SIZE + (bTotNumEndpoints * 66))
+
+/*
+ *  _1stI - number of first interface
+ *  IDidx - 0 or index of string descriptor for given interface
+ *  EPx - number of virtual interrupt EP
+ *  EP - number of real EP in/out
+ */
+#define USB_IAD(_1stI, IDidx, EPx, EP)  \
+USB_DT_IAD_SIZE, /* bLength: IAD size */ \
+    USB_DT_IAD, /* bDescriptorType: IAD */ \
+    _1stI, /* bFirstInterface */ \
+    2, /* bInterfaceCount */ \
+    2, /* bFunctionClass: CDC */ \
+    2, /* bFunctionSubClass */ \
+    0, /* bFunctionProtocol */ \
+    0, /* iFunction */ \
+    /* Interface Descriptor */ \
+    USB_DT_INTERFACE_SIZE, /* bLength: Interface Descriptor size */ \
+    USB_DT_INTERFACE, /* bDescriptorType: Interface */ \
+    _1stI, /* bInterfaceNumber: Number of Interface */ \
+    0, /* bAlternateSetting: Alternate setting */ \
+    1, /* bNumEndpoints: one for this */ \
+    USB_CLASS_COMM, /* bInterfaceClass */ \
+    2, /* bInterfaceSubClass: ACM */ \
+    0, /* bInterfaceProtocol */ \
+    IDidx, /* iInterface */ \
+    /* CDC descriptor */ \
+    USB_DT_CS_INTERFACE_SIZE, /* bLength */ \
+    USB_DT_CS_INTERFACE, /* bDescriptorType: CS_INTERFACE */ \
+    0, /* bDescriptorSubtype: Header Func Desc */ \
+    0x10, /* bcdCDC: spec release number */ \
+    1, /* bDataInterface */ \
+    USB_DT_CS_INTERFACE_SIZE, /* bLength */ \
+    USB_DT_CS_INTERFACE, /* bDescriptorType: CS_INTERFACE */ \
+    1, /* bDescriptorSubtype: Call Management Func Desc */ \
+    0, /* bmCapabilities: D0+D1 */ \
+    (_1stI+1), /* bDataInterface */ \
+        USB_DT_CS_INTERFACE_SIZE-1, /* bLength */ \
+    USB_DT_CS_INTERFACE, /* bDescriptorType: CS_INTERFACE */ \
+    2, /* bDescriptorSubtype: Abstract Control Management desc */ \
+    2, /* bmCapabilities */ \
+    USB_DT_CS_INTERFACE_SIZE, /* bLength */ \
+    USB_DT_CS_INTERFACE, /* bDescriptorType: CS_INTERFACE */ \
+    6, /* bDescriptorSubtype: Union func desc */ \
+    _1stI, /* bMasterInterface: Communication class interface */ \
+    (_1stI+1), /* bSlaveInterface0: Data Class Interface */ \
+    /* Virtual endpoint 1 Descriptor */ \
+    USB_DT_ENDPOINT_SIZE, /* bLength: Endpoint Descriptor size */ \
+    USB_DT_ENDPOINT, /* bDescriptorType: Endpoint */ \
+    (0x80+EPx), /* bEndpointAddress IN8 - non-existant */ \
+    USB_BM_ATTR_INTERRUPT, /* bmAttributes: Interrupt */ \
+    L16(USB_EP1BUFSZ), /* wMaxPacketSize LO */ \
+    H16(USB_EP1BUFSZ), /* wMaxPacketSize HI */ \
+    0x10, /* bInterval: 16ms */ \
+    /* DATA endpoint */ \
+    USB_DT_INTERFACE_SIZE, /* bLength: Interface Descriptor size */ \
+    USB_DT_INTERFACE, /* bDescriptorType: Interface */ \
+    (_1stI+1), /* bInterfaceNumber: Number of Interface */ \
+    0, /* bAlternateSetting: Alternate setting */ \
+    2, /* bNumEndpoints: in and out */ \
+    USB_CLASS_DATA, /* bInterfaceClass */ \
+    2, /* bInterfaceSubClass: ACM */ \
+    0, /* bInterfaceProtocol */ \
+    0, /* iInterface */ \
+    /*Endpoint IN1 Descriptor */ \
+    USB_DT_ENDPOINT_SIZE, /* bLength: Endpoint Descriptor size */ \
+    USB_DT_ENDPOINT, /* bDescriptorType: Endpoint */ \
+    (0x80+EP), /* bEndpointAddress: IN1 */ \
+    USB_BM_ATTR_BULK, /* bmAttributes: Bulk */ \
+    L16(USB_TXBUFSZ), /* wMaxPacketSize LO */ \
+    H16(USB_TXBUFSZ), /* wMaxPacketSize HI */ \
+    0, /* bInterval: ignore for Bulk transfer */ \
+    /* Endpoint OUT1 Descriptor */ \
+    USB_DT_ENDPOINT_SIZE, /* bLength: Endpoint Descriptor size */ \
+    USB_DT_ENDPOINT, /* bDescriptorType: Endpoint */ \
+    EP, /* bEndpointAddress: OUT1 */ \
+    USB_BM_ATTR_BULK, /* bmAttributes: Bulk */ \
+    L16(USB_RXBUFSZ), /* wMaxPacketSize LO */ \
+    H16(USB_RXBUFSZ), /* wMaxPacketSize HI */ \
+    0 /* bInterval: ignore for Bulk transfer */
+
+static const uint8_t USB_ConfigDescriptor[] = {
+    // Configuration Descriptor
+    USB_DT_CONFIG_SIZE, // bLength: Configuration Descriptor size
+    USB_DT_CONFIG, // bDescriptorType: Configuration
+    L16(wTotalLength),   // wTotalLength.L :no of returned bytes
+    H16(wTotalLength), // wTotalLength.H
+    bNumInterfaces, // bNumInterfaces
+    1, // bConfigurationValue: Current configuration value
+    0, // iConfiguration: Index of string descriptor describing the configuration or 0
+    BusPowered, // bmAttributes - Bus powered
+    50, // MaxPower in 2mA units
+    //--IADs-------------------------------------------------------------------------
+    USB_IAD(0,  iINTERFACE_DESCR1, 8,  1),
+    USB_IAD(2,  iINTERFACE_DESCR2, 9,  2),
+};
+
+
+_USB_LANG_ID_(LD, LANG_US);
+_USB_STRING_(SD, u"0.0.2");
+_USB_STRING_(MD, u"eddy@sao.ru");
+_USB_STRING_(PD, u"USB-Serial Controller");
+
+// iInterface will change on initialisation by config
+#define _USB_IIDESCR_(str) {sizeof(str), 0x03, str}
+typedef struct{
+    uint8_t  bLength;
+    uint8_t  bDescriptorType;
+    uint16_t bString[MAX_IINTERFACE_SZ];
+}iidescr_t;
+static iidescr_t iids[InterfacesAmount] = {
+    _USB_IIDESCR_(u"iface0"),
+    _USB_IIDESCR_(u"iface1"),
+};
+
+static const void* const StringDescriptor[iDESCR_AMOUNT] = {
+    [iLANGUAGE_DESCR] = &LD,
+    [iMANUFACTURER_DESCR] = &MD,
+    [iPRODUCT_DESCR] = &PD,
+    [iSERIAL_DESCR] = &SD,
+    [iINTERFACE_DESCR1] = &iids[0],
+    [iINTERFACE_DESCR2] = &iids[1],
+};
+
+static void wr0(const uint8_t *buf, uint16_t size, uint16_t askedsize){
+    if(askedsize < size) size = askedsize; // shortened request
+    if(size < USB_EP0BUFSZ){
+        EP_WriteIRQ(0, buf, size);
+        return;
+    }
+    while(size){
+        uint16_t l = size;
+        if(l > USB_EP0BUFSZ) l = USB_EP0BUFSZ;
+        EP_WriteIRQ(0, buf, l);
+        buf += l;
+        size -= l;
+        uint8_t needzlp = (l == USB_EP0BUFSZ) ? 1 : 0;
+        if(size || needzlp){ // send last data buffer
+            uint16_t epstatus = KEEP_DTOG(USB->EPnR[0]);
+            // keep DTOGs, clear CTR_RX,TX, set TX VALID, leave stat_Rx
+            USB->EPnR[0] = (epstatus & ~(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, NULL, 0);
+        }
+    }
+}
+
+void get_descriptor(config_pack_t *pack){
+    uint8_t descrtype = pack->wValue >> 8,
+        descridx = pack->wValue & 0xff;
+    switch(descrtype){
+        case DEVICE_DESCRIPTOR:
+            wr0(USB_DeviceDescriptor, sizeof(USB_DeviceDescriptor), pack->wLength);
+            break;
+        case CONFIGURATION_DESCRIPTOR:
+            wr0(USB_ConfigDescriptor, sizeof(USB_ConfigDescriptor), pack->wLength);
+            break;
+        case STRING_DESCRIPTOR:
+            if(descridx < iDESCR_AMOUNT){
+                wr0((const uint8_t *)StringDescriptor[descridx], *((uint8_t*)StringDescriptor[descridx]), pack->wLength);
+            }else{
+                EP_WriteIRQ(0, NULL, 0);
+            }
+            break;
+        case DEVICE_QUALIFIER_DESCRIPTOR:
+            wr0(USB_DeviceQualifierDescriptor, sizeof(USB_DeviceQualifierDescriptor), pack->wLength);
+            break;
+        default:
+            break;
+    }
+}
+
+// change values of iInterface by content of global config
+void setup_interfaces(){
+    for(int i = 0; i < InterfacesAmount; ++i){
+        if(the_conf.iIlengths[i]){
+            iids[i].bLength = the_conf.iIlengths[i] + 2; // +2 - for bLength and bDescriptorType
+            memcpy(iids[i].bString, the_conf.iInterface[i], the_conf.iIlengths[i]);
+        }
+        iids[i].bDescriptorType = 0x03;
+    }
+}

F0:F030,F042,F072/usbcan_gpio/usb_descr.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <stdint.h>
+
+#include "usb_lib.h"
+
+// amount of interfaces
+#define InterfacesAmount    2
+// index of interface (ep number minus one): IF1..IF7
+#define ICAN                0
+#define IGPIO               1
+// EP number of interface
+#define EPNO(i) (i + 1)
+// interface number of EPno
+#define IFNO(e) (e - 1)
+
+// amount of interfaces (including virtual) except 0
+#define bNumInterfaces      (2*InterfacesAmount)
+// amount of endpoints used
+#define bTotNumEndpoints    (1+InterfacesAmount)
+
+// definition of parts common for USB_DeviceDescriptor & USB_DeviceQualifierDescriptor
+// bcdUSB: 1.10
+#define bcdUSB              0x0110
+// Class - Misc (EF), subclass - common (2), protocol - interface association descr (1)
+#define bDeviceSubClass     0x02
+#define bDeviceProtocol     0x01
+#define idVendor            0x0483
+#define idProduct           0x5740
+#define bcdDevice_Ver       0x0200
+#define bNumConfigurations  1
+
+// powered
+#define BusPowered          (1<<7)
+#define SelfPowered         (1<<6)
+#define RemoteWakeup        (1<<5)
+
+// buffer sizes
+// Rx buffer should be not more than 64 and multiple of 2 (or 4 for STM32G0), or multiple of 32
+// Tx buffer should be multiple of 2 (or 4 for STM32G0)
+// for USB FS EP0 buffers are from 8 to 64 bytes long
+#define USB_EP0BUFSZ    64
+#define USB_EP1BUFSZ    10
+// Rx/Tx EPs (not more than 64 bytes for CDC)
+#define USB_RXBUFSZ     64
+#define USB_TXBUFSZ     64
+
+// string descriptors
+enum{
+    iLANGUAGE_DESCR,
+    iMANUFACTURER_DESCR,
+    iPRODUCT_DESCR,
+    iSERIAL_DESCR,
+    iINTERFACE_DESCR1,
+    iINTERFACE_DESCR2,
+    iDESCR_AMOUNT
+};
+
+void get_descriptor(config_pack_t *pack);
+void setup_interfaces();

F0:F030,F042,F072/usbcan_gpio/usb_dev.c

@@ -0,0 +1,356 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "ringbuffer.h"
+#include "usb_descr.h"
+#include "usb_dev.h"
+
+// 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
+
+// inbuf overflow when receiving
+static volatile uint8_t bufovrfl[InterfacesAmount] = {0};
+
+extern volatile uint32_t Tms;
+
+// receive buffer: hold data until chkin() call
+static uint8_t volatile rcvbuf[InterfacesAmount][USB_RXBUFSZ] __attribute__((aligned(4)));
+static uint8_t volatile rcvbuflen[InterfacesAmount] = {0};
+// line coding
+#define DEFL    {9600, 0, 0, 8}
+static usb_LineCoding lineCoding[InterfacesAmount] = {DEFL,DEFL};
+// CDC configured and ready to use
+volatile uint8_t CDCready[InterfacesAmount] = {0};
+// also we need to check timeouts of sending data to detect disconnection as
+// stupid CDC have no `break` signal and, of course, as we have more than one
+// interface, there's no interrupt on disconnection
+
+// ring buffers for incoming and outgoing data
+static uint8_t obuf[InterfacesAmount][RBOUTSZ], ibuf[InterfacesAmount][RBINSZ];
+#define OBUF(N)  {.data = obuf[N], .length = RBOUTSZ, .head = 0, .tail = 0}
+static volatile ringbuffer rbout[InterfacesAmount] = {OBUF(0), OBUF(1)};
+#define IBUF(N)  {.data = ibuf[N], .length = RBINSZ, .head = 0, .tail = 0}
+static volatile ringbuffer rbin[InterfacesAmount] = {IBUF(0), IBUF(1)};
+// last send data size (<0 if USB transfer ready)
+static volatile int lastdsz[InterfacesAmount] = {-1, -1};
+
+// check incoming data and set ACK if need
+static void chkin(uint8_t ifno){
+    if(bufovrfl[ifno]) return; // allow user to know that previous buffer was overflowed and cleared
+    if(!rcvbuflen[ifno]) return;
+    int w = RB_write((ringbuffer*)&rbin[ifno], (uint8_t*)rcvbuf[ifno], rcvbuflen[ifno]);
+    if(w < 0){
+        return;
+    }
+    if(w != rcvbuflen[ifno]) bufovrfl[ifno] = 1;
+    rcvbuflen[ifno] = 0;
+    uint16_t status = KEEP_DTOG(USB->EPnR[EPNO(ifno)]); // don't change DTOG
+    USB->EPnR[EPNO(ifno)] = (status & ~(USB_EPnR_STAT_TX|USB_EPnR_CTR_RX)) ^ USB_EPnR_STAT_RX; // prepare to get next data portion
+}
+
+// called from transmit EP to send next data portion or by user - when new transmission starts
+static void send_next(uint8_t ifno){
+    uint8_t usbbuff[USB_TXBUFSZ];
+    int buflen = RB_read((ringbuffer*)&rbout[ifno], (uint8_t*)usbbuff, USB_TXBUFSZ);
+    if(!CDCready[ifno]){
+        lastdsz[ifno] = -1;
+        return;
+    }
+    if(buflen == 0){
+        if(lastdsz[ifno] == USB_TXBUFSZ){
+            EP_Write(EPNO(ifno), NULL, 0); // send ZLP after 64 bits packet when nothing more to send
+            lastdsz[ifno] = 0;
+        }else lastdsz[ifno] = -1; // OK. User can start sending data
+        return;
+    }else if(buflen < 0){
+        lastdsz[ifno] = -1;
+        return;
+    }
+    EP_Write(EPNO(ifno), (uint8_t*)usbbuff, buflen);
+    lastdsz[ifno] = buflen;
+}
+
+// data IN/OUT handler
+static void rxtx_handler(){
+    uint8_t epno = (USB->ISTR & USB_ISTR_EPID), ifno = IFNO(epno);
+    if(ifno > InterfacesAmount-1){
+        return;
+    }
+    uint16_t epstatus = KEEP_DTOG(USB->EPnR[epno]);
+    if(RX_FLAG(epstatus)){ // receive data
+        if(rcvbuflen[ifno]){
+            bufovrfl[ifno] = 1; // lost last data
+            rcvbuflen[ifno] = 0;
+        }
+        rcvbuflen[ifno] = EP_Read(epno, (uint8_t*)rcvbuf[ifno]);
+        USB->EPnR[epno] = epstatus & ~(USB_EPnR_CTR_RX | USB_EPnR_STAT_RX | USB_EPnR_STAT_TX); // keep RX in STALL state until read data
+        chkin(ifno); // try to write current data into RXbuf if it's not busy
+    }else{ // tx successfull
+        USB->EPnR[epno] = (epstatus & ~(USB_EPnR_CTR_TX | USB_EPnR_STAT_TX)) ^ USB_EPnR_STAT_RX;
+        send_next(ifno);
+    }
+}
+
+// clear IN/OUT buffers on connection
+static void clearbufs(uint8_t ifno){
+    uint32_t T0 = Tms;
+    while(Tms - T0 < 10){ // wait no more than 10ms
+        if(1 == RB_clearbuf((ringbuffer*)&rbin[ifno])) break;
+    }
+    T0 = Tms;
+    while(Tms - T0 < 10){
+        if(1 == RB_clearbuf((ringbuffer*)&rbout[ifno])) break;
+    }
+}
+
+// SET_LINE_CODING
+void linecoding_handler(uint8_t ifno, usb_LineCoding *lc){
+    lineCoding[ifno] = *lc;
+    // next lines could be using to add direct USART-USB interface
+    //usart_config(ifno, &lineCoding[ifno]); // lc would be real speed!
+    //usart_start(ifno); // restart again with new configuration
+}
+
+// SET_CONTROL_LINE_STATE
+void clstate_handler(uint8_t ifno, uint16_t val){
+    CDCready[ifno] = val; // CONTROL_DTR | CONTROL_RTS -> interface connected; 0 -> disconnected
+    lastdsz[ifno] = -1;
+    if(val){
+        clearbufs(ifno);
+        EP_reset(EPNO(ifno));
+        // usart_start(ifno);
+    }//else usart_stop(ifno); // turn of USART (if it is @ this interface)
+}
+
+// SEND_BREAK - disconnect interface and clear its buffers
+// this is a fake handler as classic CDC ACM never receives this
+void break_handler(uint8_t ifno){
+    CDCready[ifno] = 0;
+    // usart_stop(ifno); // turn of USART (if it is @ this interface)
+}
+
+// Interface is configured: setup endpoints
+void set_configuration(){
+    for(int i = 0; i < InterfacesAmount; ++i){
+        IWDG->KR = IWDG_REFRESH;
+        int r = EP_Init(EPNO(i), EP_TYPE_BULK, USB_TXBUFSZ, USB_RXBUFSZ, rxtx_handler);
+        if(r){
+            // OOPS, can't init EP. What to do? Cry?
+            break;
+        }
+    }
+}
+
+// USB CDC CLASS request
+void usb_class_request(config_pack_t *req, uint8_t *data, uint16_t datalen){
+    uint8_t recipient = REQUEST_RECIPIENT(req->bmRequestType);
+    uint8_t dev2host = (req->bmRequestType & 0x80) ? 1 : 0;
+    uint8_t ifno = req->wIndex >> 1;
+    if(ifno > InterfacesAmount-1){ // wrong interface number
+        EP_WriteIRQ(0, NULL, 0);
+        return;
+    }
+    switch(recipient){
+    case REQ_RECIPIENT_INTERFACE:
+        switch(req->bRequest){
+        case SET_LINE_CODING:
+            if(!data || !datalen) break; // wait for data
+            if(datalen == sizeof(usb_LineCoding))
+                linecoding_handler(ifno, (usb_LineCoding*)data);
+            break;
+        case GET_LINE_CODING:
+            EP_WriteIRQ(0, (uint8_t*)&lineCoding[ifno], sizeof(lineCoding));
+            break;
+        case SET_CONTROL_LINE_STATE:
+            clstate_handler(ifno, req->wValue);
+            break;
+        case SEND_BREAK:
+            break_handler(ifno);
+            break;
+        default: // WTF?
+            break;
+        }
+        break;
+    default: // WTF?
+        if(dev2host) EP_WriteIRQ(0, NULL, 0);
+    }
+    if(!dev2host) EP_WriteIRQ(0, NULL, 0);
+}
+
+// blocking send full content of ring buffer
+int USB_sendall(uint8_t ifno){
+    uint32_t T0 = Tms;
+    while(lastdsz[ifno] > 0){
+        if(Tms - T0 > DISCONN_TMOUT){
+            //break_handler(ifno);
+            return FALSE;
+        }
+        if(!CDCready[ifno]) return FALSE;
+        IWDG->KR = IWDG_REFRESH;
+    }
+    return TRUE;
+}
+
+// return amount of free space in buffer
+int USB_sendbufspace(uint8_t ifno){
+    if(!CDCready[ifno]) return 0;
+    return rbout[ifno].length - RB_datalen((ringbuffer*)&rbout[ifno]);
+}
+
+// put `buf` into queue to send
+int USB_send(uint8_t ifno, const uint8_t *buf, int len){
+    if(!buf || !CDCready[ifno] || !len){
+        return FALSE;
+    }
+    uint32_t T0 = Tms;
+    while(len){
+        if(Tms - T0 > DISCONN_TMOUT){
+            //break_handler(ifno);
+            return FALSE;
+        }
+        if(!CDCready[ifno]){
+            return FALSE;
+        }
+        IWDG->KR = IWDG_REFRESH;
+        int l = RB_datalen((ringbuffer*)&rbout[ifno]);
+        if(l < 0) continue;
+        int portion = rbout[ifno].length - 1 - l;
+        if(portion < 1){
+            if(lastdsz[ifno] < 0) send_next(ifno);
+            continue;
+        }
+        if(portion > len) portion = len;
+        int a = RB_write((ringbuffer*)&rbout[ifno], buf, portion);
+        if(a > 0){
+            len -= a;
+            buf += a;
+        }else if(a == 0){ // overfull
+            if(lastdsz[ifno] < 0) send_next(ifno);
+        }
+    }
+    if(buf[len-1] == '\n' && lastdsz[ifno] < 0){
+        send_next(ifno);
+    }
+    return TRUE;
+}
+
+int USB_putbyte(uint8_t ifno, uint8_t byte){
+    if(!CDCready[ifno]) return FALSE;
+    int l = 0;
+    uint32_t T0 = Tms;
+    while((l = RB_write((ringbuffer*)&rbout[ifno], &byte, 1)) != 1){
+        if(Tms - T0 > DISCONN_TMOUT){
+            //break_handler(ifno);
+            return FALSE;
+        }
+        if(!CDCready[ifno]) return FALSE;
+        IWDG->KR = IWDG_REFRESH;
+        if(l == 0){ // overfull
+            if(lastdsz[ifno] < 0) send_next(ifno);
+            continue;
+        }
+    }
+    // send line if got EOL
+    if(byte == '\n' && lastdsz[ifno] < 0){
+        send_next(ifno);
+    }
+    return TRUE;
+}
+
+int USB_sendstr(uint8_t ifno, const char *string){
+    if(!string || !CDCready[ifno]) return FALSE;
+    int len = strlen(string);
+    if(!len) return FALSE;
+    return USB_send(ifno, (const uint8_t*)string, len);
+}
+
+int USB_rcvlen(uint8_t ifno){
+    return RB_datalen((ringbuffer*)&rbin[ifno]);
+}
+
+/**
+ * @brief USB_receive - get binary data from receiving ring-buffer
+ * @param buf (i) - buffer for received data
+ * @param len - length of `buf`
+ * @return amount of received bytes (negative, if overfull happened)
+ */
+int USB_receive(uint8_t ifno, uint8_t *buf, int len){
+    if(!CDCready[ifno]) return 0;
+    chkin(ifno); // rxtx_handler could leave last message unwritten if buffer was busy
+    if(bufovrfl[ifno]){
+        while(1 != RB_clearbuf((ringbuffer*)&rbin[ifno])); // run watchdog in case of problems
+        bufovrfl[ifno] = 0;
+        return -1;
+    }
+    int sz = RB_read((ringbuffer*)&rbin[ifno], buf, len);
+    if(sz < 0) return 0; // buffer in writting state
+    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(uint8_t ifno, char *buf, int len){
+    if(!CDCready[ifno]) return 0;
+    chkin(ifno); // rxtx_handler could leave last message unwritten if buffer was busy
+    if(bufovrfl[ifno]){
+        while(1 != RB_clearbuf((ringbuffer*)&rbin[ifno]));
+        bufovrfl[ifno] = 0;
+        return -1;
+    }
+    int l = RB_readto((ringbuffer*)&rbin[ifno], '\n', (uint8_t*)buf, len);
+    if(l < 1){
+        if((rbin[ifno].length <= RB_datalen((ringbuffer*)&rbin[ifno]) + 1) ||
+            (RB_datalento((ringbuffer*)&rbin[ifno], '\n') > len - 1)){ // buffer is full but no '\n' found or string too long
+            while(1 != RB_clearbuf((ringbuffer*)&rbin[ifno]));
+            return -1;
+        }
+        return 0;
+    }
+    buf[l-1] = 0; // replace '\n' with strend
+    return l;
+}
+
+/**
+ * @brief IFconfig - interface configuration
+ * @param ifno - index
+ * @param l (o, user allocated) - settings
+ * @return value of CDCready
+ */
+uint8_t IFconfig(uint8_t ifno, usb_LineCoding *l){
+    if(ifno >= InterfacesAmount) return 0;
+    if(l) *l = lineCoding[ifno];
+    return CDCready[ifno];
+}
+

F0:F030,F042,F072/usbcan_gpio/usb_dev.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <stdint.h>
+#include "usb_lib.h"
+
+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;
+
+extern volatile uint8_t CDCready[];
+
+void break_handler(uint8_t ifno);
+void clstate_handler(uint8_t ifno, uint16_t val);
+void linecoding_handler(uint8_t ifno, usb_LineCoding *lc);
+
+// as ugly CDC have no BREAK after disconnected client in non-canonical mode, we should use timeout - near 2s
+#define DISCONN_TMOUT   (2)
+
+// sizes of ringbuffers for outgoing and incoming data
+#define RBOUTSZ     (1024)
+#define RBINSZ      (1024)
+
+#define newline(ifno)   USB_putbyte(ifno, '\n')
+#define USND(ifno, s)   do{USB_sendstr(ifno, s); USB_putbyte(ifno, '\n');}while(0)
+// 'shortcuts' for files used only one interface "USBIF"
+#ifdef USBIF
+#define SEND(x)     USB_sendstr(USBIF, x)
+#define RECV(b,l)   USB_receivestr(USBIF, b, l)
+#define PUTCHAR(x)  USB_putbyte(USBIF, x)
+#define SENDn(x)    do{USB_sendstr(USBIF, x); USB_putbyte(USBIF, '\n');}while(0)
+#define NL(x)       USB_putbyte(USBIF, '\n')
+#endif
+
+int USB_sendbufspace(uint8_t ifno);
+int USB_sendall(uint8_t ifno);
+int USB_send(uint8_t ifno, const uint8_t *buf, int len);
+int USB_putbyte(uint8_t ifno, uint8_t byte);
+int USB_sendstr(uint8_t ifno, const char *string);
+int USB_rcvlen(uint8_t ifno);
+int USB_receive(uint8_t ifno, uint8_t *buf, int len);
+int USB_receivestr(uint8_t ifno, char *buf, int len);
+uint8_t IFconfig(uint8_t ifno, usb_LineCoding *l);

F0:F030,F042,F072/usbcan_gpio/usb_lib.c

@@ -0,0 +1,446 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+#include <stdint.h>
+
+#include "usb_lib.h"
+#include "usb_descr.h"
+#include "usb_dev.h"
+
+static ep_t endpoints[STM32ENDPOINTS];
+
+static uint16_t USB_Addr = 0;
+static uint8_t setupdatabuf[EP0DATABUF_SIZE] __attribute__((aligned(4)));
+static config_pack_t *setup_packet = (config_pack_t*) setupdatabuf;
+volatile uint8_t usbON = 0; // device is configured and active
+
+static uint16_t configuration = 0; // reply for GET_CONFIGURATION (==1 if configured)
+static inline void std_d2h_req(){
+    uint16_t st = 0;
+    switch(setup_packet->bRequest){
+        case GET_DESCRIPTOR:
+            get_descriptor(setup_packet);
+        break;
+        case GET_STATUS:
+            EP_WriteIRQ(0, (uint8_t *)&st, 2); // send status: Bus Powered
+        break;
+        case GET_CONFIGURATION:
+            EP_WriteIRQ(0, (uint8_t*)&configuration, 1);
+        break;
+        default:
+            EP_WriteIRQ(0, NULL, 0);
+        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_Addr = setup_packet->wValue;
+        break;
+        case SET_CONFIGURATION:
+            // Now device configured
+            configuration = setup_packet->wValue;
+            set_configuration();
+            usbON = 1;
+        break;
+        default:
+        break;
+    }
+}
+
+void WEAK usb_standard_request(){
+    uint8_t recipient = REQUEST_RECIPIENT(setup_packet->bmRequestType);
+    uint8_t dev2host = (setup_packet->bmRequestType & 0x80) ? 1 : 0;
+    switch(recipient){
+        case REQ_RECIPIENT_DEVICE:
+            if(dev2host){
+                std_d2h_req();
+            }else{
+                std_h2d_req();
+            }
+        break;
+        case REQ_RECIPIENT_INTERFACE:
+            if(dev2host && setup_packet->bRequest == GET_DESCRIPTOR){
+                get_descriptor(setup_packet);
+            }
+        break;
+        case REQ_RECIPIENT_ENDPOINT:
+            if(setup_packet->bRequest == CLEAR_FEATURE){
+            }else{ /* wrong */ }
+        break;
+        default:
+        break;
+    }
+    if(!dev2host) EP_WriteIRQ(0, NULL, 0);
+}
+
+void WEAK usb_class_request(config_pack_t *req, uint8_t _U_ *data, uint16_t _U_ datalen){
+    switch(req->bRequest){
+        case GET_INTERFACE:
+        break;
+        case SET_CONFIGURATION: // set featuring by req->wValue
+        break;
+        default:
+            break;
+    }
+    if(0 == (setup_packet->bmRequestType & 0x80)) // host2dev
+        EP_WriteIRQ(0, NULL, 0);
+}
+
+void WEAK usb_vendor_request(config_pack_t _U_ *packet, uint8_t _U_ *data, uint16_t _U_ datalen){
+    if(0 == (setup_packet->bmRequestType & 0x80)) // host2dev
+        EP_WriteIRQ(0, NULL, 0);
+}
+
+/*
+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
+ */
+static void EP0_Handler(){
+    uint8_t ep0dbuflen = 0;
+    uint8_t ep0databuf[EP0DATABUF_SIZE] __attribute__((aligned(4)));
+    uint16_t epstatus = KEEP_DTOG(USB->EPnR[0]); // EP0R on input -> return this value after modifications
+    int rxflag = RX_FLAG(epstatus);
+    // 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(epstatus & USB_EPnR_SETUP){ // setup packet -> copy data to conf_pack
+                EP_Read(0, setupdatabuf);
+                // interrupt handler will be called later
+            }else if(epstatus & USB_EPnR_CTR_RX){ // data packet -> push received data to ep0databuf
+                //if(endpoints[0].rx_cnt){ }
+                ep0dbuflen = EP_Read(0, ep0databuf);
+            }
+    }
+    if(rxflag){
+        uint8_t reqtype = REQUEST_TYPE(setup_packet->bmRequestType);
+        switch(reqtype){
+            case REQ_TYPE_STANDARD:
+                if(SETUP_FLAG(epstatus)){
+                    usb_standard_request();
+                }else{ }
+                break;
+            case REQ_TYPE_CLASS:
+                usb_class_request(setup_packet, ep0databuf, ep0dbuflen);
+                break;
+            case REQ_TYPE_VENDOR:
+                usb_vendor_request(setup_packet, ep0databuf, ep0dbuflen);
+                break;
+            default:
+                EP_WriteIRQ(0, NULL, 0);
+                break;
+        }
+    }
+    if(TX_FLAG(epstatus)){
+        // now we can change address after enumeration
+        if ((USB->DADDR & USB_DADDR_ADD) != USB_Addr){
+            USB->DADDR = USB_DADDR_EF | USB_Addr;
+            usbON = 0;
+        }
+    }
+    //epstatus = KEEP_DTOG(USB->EPnR[0]);
+    if(rxflag) epstatus ^= USB_EPnR_STAT_TX; // start ZLP or 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 > endpoints[number].txbufsz) size = endpoints[number].txbufsz;
+#ifndef USB32
+    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;
+#else
+    int N4 = (size + 3) >> 2;
+    uint32_t *buf32 = (uint32_t *)buf;
+#endif
+#if defined USB1_16
+    // very bad: what if `size` is odd?
+    uint32_t *out = (uint32_t *)endpoints[number].tx_buf;
+    for(int i = 0; i < N2; ++i, ++out){
+        *out = buf16[i];
+    }
+#elif defined USB2_16
+    // use memcpy instead?
+    for(int i = 0; i < N2; ++i){
+        endpoints[number].tx_buf[i] = buf16[i];
+    }
+#elif defined USB32
+    for(int i = 0; i < N4; ++i) endpoints[number].tx_buf[i] = buf32[i];
+#else
+#error "Define USB1_16 / USB2_16 / USB32"
+#endif
+#ifndef USB32
+    USB_BTABLE->EP[number].USB_COUNT_TX = size;
+#else
+    USB_BTABLE->EP[number].USB_ADDR_COUNT_TX = (USB_BTABLE->EP[number].USB_ADDR_COUNT_TX & 0xffff) | (size << 16);
+#endif
+}
+
+/**
+ * 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 epstatus = KEEP_DTOG(USB->EPnR[number]);
+    // keep DTOGs and RX stat, clear CTR_TX & set TX VALID to start transmission
+    USB->EPnR[number] = (epstatus & ~(USB_EPnR_CTR_TX | USB_EPnR_STAT_RX)) ^ 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 sz = endpoints[number].rx_cnt;
+    if(!sz) return 0;
+    endpoints[number].rx_cnt = 0;
+#if defined USB1_16
+    int n = (sz + 1) >> 1;
+    uint32_t *in = (uint32_t*)endpoints[number].rx_buf;
+    uint16_t *out = (uint16_t*)buf;
+    for(int i = 0; i < n; ++i, ++in)
+        out[i] = *(uint16_t*)in;
+#elif defined USB2_16
+    // use memcpy instead?
+    for(int i = 0; i < sz; ++i)
+        buf[i] = endpoints[number].rx_buf[i];
+#elif defined USB32
+    uint32_t *u32buf = (uint32_t*) buf;
+    int N4 = (sz + 3) >> 2;
+    for(int i = 0; i < N4; ++i) u32buf[i] = endpoints[number].rx_buf[i];
+#else
+#error "Define USB1_16 / USB2_16 / USB32"
+#endif
+    return sz;
+}
+
+
+static uint16_t lastaddr = LASTADDR_DEFAULT;
+/**
+ * Endpoint initialisation
+ * @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)(ep_t ep)){
+#ifdef STM32G0
+    // in STM32G0 all buffers should be aligned by 32 bits
+    if(txsz & 3) txsz = ((txsz >> 2)+1) << 2;
+    if(rxsz & 3) rxsz = ((rxsz >> 2)+1) << 2;
+#endif
+    if(number >= STM32ENDPOINTS) return 4; // out of configured amount
+    if(txsz > USB_BTABLE_SIZE/ACCESSZ || rxsz > USB_BTABLE_SIZE/ACCESSZ) return 1; // buffer too large
+    if(lastaddr + txsz + rxsz >= USB_BTABLE_SIZE/ACCESSZ) 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;
+    if(rxsz & 1) 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;
+    }
+#ifdef USB32
+    endpoints[number].tx_buf = (uint32_t *)(USB_BTABLE_BASE + lastaddr * ACCESSZ);
+#else
+    endpoints[number].tx_buf = (uint16_t *)(USB_BTABLE_BASE + lastaddr * ACCESSZ);
+#endif
+    endpoints[number].txbufsz = txsz;
+#ifdef USB32
+    USB_BTABLE->EP[number].USB_ADDR_COUNT_TX = (uint32_t) lastaddr;
+#else
+    USB_BTABLE->EP[number].USB_ADDR_TX = lastaddr;
+    USB_BTABLE->EP[number].USB_COUNT_TX = 0;
+#endif
+    lastaddr += txsz;
+#ifdef USB32
+    endpoints[number].rx_buf = (uint32_t *)(USB_BTABLE_BASE + lastaddr * ACCESSZ);
+    USB_BTABLE->EP[number].USB_ADDR_COUNT_RX = (uint32_t) lastaddr | countrx << 26;
+#else
+    endpoints[number].rx_buf = (uint8_t *)(USB_BTABLE_BASE + lastaddr * ACCESSZ);
+    USB_BTABLE->EP[number].USB_ADDR_RX = lastaddr;
+    USB_BTABLE->EP[number].USB_COUNT_RX = countrx << 10;
+#endif
+    lastaddr += rxsz;
+    endpoints[number].func = func;
+    return 0;
+}
+
+// refresh EP after interface reconnected
+void EP_reset(uint8_t number){
+    if(number >= STM32ENDPOINTS) return;
+    USB->EPnR[number] ^= USB_EPnR_STAT_RX | USB_EPnR_STAT_TX;
+    USB_BTABLE->EP[number].USB_COUNT_TX = 0;
+}
+
+// standard IRQ handler
+void USB_IRQ(){
+    uint32_t CNTR = USB->CNTR;
+    USB->CNTR = 0;
+    uint32_t istr = USB->ISTR;
+    if(istr & USB_ISTR_RESET){
+        usbON = 0;
+        // Reinit registers
+        CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM | USB_CNTR_SUSPM;
+        // Endpoint 0 - CONTROL
+        // ON USB LS size of EP0 may be 8 bytes, but on FS it should be 64 bytes!
+        lastaddr = LASTADDR_DEFAULT;
+        // clear address, leave only enable bit
+        USB->DADDR = USB_DADDR_EF;
+        //USB->ISTR = ~(USB_ISTR_RESET); // clear all flags
+        if(EP_Init(0, EP_TYPE_CONTROL, USB_EP0BUFSZ, USB_EP0BUFSZ, EP0_Handler)){
+            return;
+        };
+    }
+    if(istr & USB_ISTR_CTR){
+        // EP number
+        uint8_t n = istr & USB_ISTR_EPID;
+        if (istr & USB_ISTR_DIR){ // OUT
+        }else{ // IN
+        }
+        // copy received bytes amount
+        endpoints[n].rx_cnt =
+#ifdef USB32
+            (USB_BTABLE->EP[n].USB_ADDR_COUNT_RX >> 16) & 0x3FF;
+#else
+        USB_BTABLE->EP[n].USB_COUNT_RX & 0x3FF; // low 10 bits is counter
+#endif
+        // call EP handler
+        if(endpoints[n].func) endpoints[n].func();
+    }
+    if(istr & USB_ISTR_WKUP){ // wakeup
+#if defined STM32F0
+        CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LPMODE | USB_CNTR_WKUPM);
+#elif defined STM32G0
+        CNTR &= ~(USB_CNTR_SUSPEN | USB_CNTR_PDWN | USB_CNTR_WKUPM);
+#else
+        CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LP_MODE | USB_CNTR_WKUPM); // clear suspend flags
+#endif
+        //USB->ISTR = ~USB_ISTR_WKUP;
+    }
+    if(istr & USB_ISTR_SUSP){ // suspend -> still no connection, may sleep
+        usbON = 0;
+#if defined STM32F0
+        CNTR |= USB_CNTR_FSUSP | USB_CNTR_LPMODE | USB_CNTR_WKUPM;
+#elif defined STM32G0
+        CNTR |= USB_CNTR_SUSPEN | USB_CNTR_WKUPM;
+#else
+        CNTR |= USB_CNTR_FSUSP | USB_CNTR_LP_MODE | USB_CNTR_WKUPM;
+#endif
+        CNTR &= ~(USB_CNTR_SUSPM);
+        //USB->ISTR = ~USB_ISTR_SUSP;
+    }
+    USB->ISTR = 0; // clear all flags
+    USB->CNTR = CNTR; // rewoke interrupts
+}
+
+// here we suppose that all PIN settings done in hw_setup earlier
+void USB_setup(){
+    lastaddr = LASTADDR_DEFAULT; // clear last address settings
+#if defined STM32F3
+    NVIC_DisableIRQ(USB_LP_IRQn);
+    // remap USB LP & Wakeup interrupts to 75 and 76 - works only on pure F303
+    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN; // enable tacting of SYSCFG
+    SYSCFG->CFGR1 |= SYSCFG_CFGR1_USB_IT_RMP;
+#elif defined STM32F1
+    NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
+    NVIC_DisableIRQ(USB_HP_CAN1_TX_IRQn);
+#elif defined STM32F0
+    // All is clocking from HSI48
+    NVIC_DisableIRQ(USB_IRQn);
+    RCC->APB1ENR |= RCC_APB1ENR_CRSEN;
+    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;
+#elif defined STM32G0
+    NVIC_DisableIRQ(USB_UCPD1_2_IRQn);
+    PWR->CR2 |= PWR_CR2_USV; // enable USB powering
+    //RCC->APBENR2 |= RCC_APBENR2_SYSCFGEN; // enable tacting of SYSCFG
+    // independent clocking of USB from HSI48
+    RCC->CR |= RCC_CR_HSI48ON;
+    uint32_t tmout = 16000000;
+    while(!(RCC->CR & RCC_CR_HSI48RDY)) if(--tmout == 0) break;
+    RCC->CCIPR2 &= ~RCC_CCIPR2_USBSEL; // select HSI48 for USB
+    RCC->APBENR1 |= RCC_APBENR1_CRSEN; // CRS clocking
+    CRS->CFGR = (31LL << CRS_CFGR_FELIM_Pos) | // tolerance (usually 31)
+                (48000LL / 1LL - 1LL) << CRS_CFGR_RELOAD_Pos | // 48MHz / 1kHZ (SOF)
+                CRS_CFGR_SYNCSRC_1; // USB SOF as sync source (0x2)
+    CRS->CR |= CRS_CR_AUTOTRIMEN | CRS_CR_CEN; // Enable autotrim and turn on Clock Recovery System
+    RCC->APBENR1 |= RCC_APBENR1_USBEN;
+#endif
+#ifndef STM32G0
+    RCC->APB1ENR |= RCC_APB1ENR_USBEN;
+    USB->CNTR   = USB_CNTR_FRES; // Force USB Reset
+    USB->BTABLE = 0;
+#else
+    USB->CNTR   = USB_CNTR_USBRST;
+#endif
+    for(uint32_t ctr = 0; ctr < 72000; ++ctr) nop(); // wait >1ms
+    USB->CNTR   = USB_CNTR_RESETM; // allow only reset interrupts
+    USB->DADDR  = 0;
+    USB->ISTR   = 0;
+#if defined STM32F3
+    NVIC_EnableIRQ(USB_LP_IRQn);
+#elif defined STM32F1
+    NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
+#elif defined STM32F0
+    USB->BCDR |= USB_BCDR_DPPU;
+    NVIC_EnableIRQ(USB_IRQn);
+#elif defined STM32G0
+    USB->BCDR |= USB_BCDR_DPPU; // turn ON DP pullup
+    NVIC_EnableIRQ(USB_UCPD1_2_IRQn);
+#endif
+    setup_interfaces(); // refresh interfaces' names
+}
+
+
+#if defined STM32F3
+void usb_lp_isr() __attribute__ ((alias ("USB_IRQ")));
+#elif defined STM32F1
+void usb_lp_can_rx0_isr() __attribute__ ((alias ("USB_IRQ")));
+#elif defined STM32F0
+void usb_isr() __attribute__ ((alias ("USB_IRQ")));
+#elif defined STM32G0
+void usb_ucpd1_2_isr() __attribute__ ((alias ("USB_IRQ")));
+#endif

F0:F030,F042,F072/usbcan_gpio/usb_lib.h

@@ -0,0 +1,353 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <stdint.h>
+#include <wchar.h>
+
+#ifndef _U_
+#define _U_         __attribute__((unused))
+#endif
+
+/******************************************************************
+ *             Hardware registers etc                             *
+ *****************************************************************/
+#if defined STM32F0
+#include <stm32f0.h>
+#elif defined STM32F1
+#include <stm32f1.h>
+// there's no this define in standard header
+#define USB_BASE                ((uint32_t)0x40005C00)
+#elif defined STM32F3
+#include <stm32f3.h>
+#elif defined STM32G0
+#include <stm32g0.h>
+#endif
+
+// max endpoints number
+#define STM32ENDPOINTS          8
+/**
+ *                 Buffers size definition
+ **/
+
+//  F0 - USB2_16; F1 - USB1_16; F3 - 1/2 depending on series; G0 - USB32
+#if !defined USB1_16 && !defined USB2_16 && !defined USB32
+#if defined STM32F0
+#define USB2_16
+#elif defined STM32F1
+#define USB1_16
+#elif defined STM32G0
+#define USB32
+#else
+#error "Can't determine USB1_16/USB2_16/USB32, define by hands"
+#endif
+#endif
+
+// BTABLE_SIZE FOR STM32F3:
+// In STM32F303/302xB/C, 512 bytes SRAM is not shared with CAN.
+// In STM32F302x6/x8 and STM32F30xxD/E, 726 bytes dedicated SRAM and 256 bytes shared SRAM with CAN i.e.
+//     1Kbytes dedicated SRAM in case CAN is disabled.
+// remember, that USB_BTABLE_SIZE will be divided by ACCESSZ, so don't divide it twice for 32-bit addressing
+
+#ifdef NOCAN
+#if defined STM32F0
+#define USB_BTABLE_SIZE         1024
+#elif defined STM32F3
+#define USB_BTABLE_SIZE         1024
+//#warning "Please, check real buffer size due to docs"
+#else
+#error "define STM32F0 or STM32F3"
+#endif
+#else // !NOCAN: F0/F3 with CAN or F1 (can't simultaneously run CAN and USB)
+#if defined STM32F0
+#define USB_BTABLE_SIZE         768
+#elif defined STM32F3
+#define USB_BTABLE_SIZE         768
+#elif defined STM32G0
+#define USB_BTABLE_SIZE         2048
+//#warning "Please, check real buffer size due to docs"
+#else // STM32F103: 1024 bytes but with 32-bit addressing
+#define USB_BTABLE_SIZE         1024
+#endif
+#endif // NOCAN
+
+// first 64 bytes of USB_BTABLE are registers!
+#ifndef STM32G0
+#define USB_BTABLE_BASE         0x40006000
+#else
+#define USB_BTABLE_BASE         0x40009800
+#endif
+#define USB                     ((USB_TypeDef *) USB_BASE)
+
+#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;
+#ifndef USB32
+    __IO uint32_t BTABLE;
+#else
+    __IO uint32_t RESERVED1; // there's no BTABLE register in STM32G0
+#endif
+#if defined STM32F0 || defined USB32
+    __IO uint32_t LPMCSR;
+    __IO uint32_t BCDR;
+#endif
+} USB_TypeDef;
+
+// F303 D/E have 2x16 access scheme
+typedef struct{
+#if defined USB2_16
+    __IO uint16_t USB_ADDR_TX;
+    __IO uint16_t USB_COUNT_TX;
+    __IO uint16_t USB_ADDR_RX;
+    __IO uint16_t USB_COUNT_RX;
+#define ACCESSZ (1)
+#elif defined USB1_16
+    __IO uint32_t USB_ADDR_TX;
+    __IO uint32_t USB_COUNT_TX;
+    __IO uint32_t USB_ADDR_RX;
+    __IO uint32_t USB_COUNT_RX;
+#define ACCESSZ (2)
+#elif defined USB32
+    // 32-bit registers: addr & count in one!
+    __IO uint32_t USB_ADDR_COUNT_TX;
+    __IO uint32_t USB_ADDR_COUNT_RX;
+#define ACCESSZ (1)
+#else
+#error "Define USB1_16 (16 bits over 32bit register), USB2_16 (16 bits over 16 bit register) or USB32 (32 bist over 32 bit register)"
+#endif
+} USB_EPDATA_TypeDef;
+
+
+typedef struct{
+    __IO USB_EPDATA_TypeDef EP[STM32ENDPOINTS];
+} USB_BtableDef;
+
+#define EP0DATABUF_SIZE                 (64)
+#define LASTADDR_DEFAULT                (STM32ENDPOINTS * 8)
+
+/******************************************************************
+ *             Defines from usb.h                                 *
+ *****************************************************************/
+
+/*
+ * Device and/or Interface Class codes
+ */
+#define USB_CLASS_PER_INTERFACE         0
+#define USB_CLASS_AUDIO                 1
+#define USB_CLASS_COMM                  2
+#define USB_CLASS_HID                   3
+#define USB_CLASS_PRINTER               7
+#define USB_CLASS_PTP                   6
+#define USB_CLASS_MASS_STORAGE          8
+#define USB_CLASS_HUB                   9
+#define USB_CLASS_DATA                  10
+#define USB_CLASS_MISC                  0xef
+#define USB_CLASS_VENDOR_SPEC           0xff
+
+/*
+ * Descriptor types
+ */
+#define USB_DT_DEVICE                   0x01
+#define USB_DT_CONFIG                   0x02
+#define USB_DT_STRING                   0x03
+#define USB_DT_INTERFACE                0x04
+#define USB_DT_ENDPOINT                 0x05
+#define USB_DT_QUALIFIER                0x06
+#define USB_DT_IAD                      0x0B
+
+#define USB_DT_HID                      0x21
+#define USB_DT_REPORT                   0x22
+#define USB_DT_PHYSICAL                 0x23
+#define USB_DT_CS_INTERFACE             0x24
+#define USB_DT_HUB                      0x29
+
+/*
+ * Descriptor sizes per descriptor type
+ */
+#define USB_DT_DEVICE_SIZE              18
+#define USB_DT_CONFIG_SIZE              9
+#define USB_DT_INTERFACE_SIZE           9
+#define USB_DT_HID_SIZE                 9
+#define USB_DT_ENDPOINT_SIZE            7
+#define USB_DT_QUALIFIER_SIZE           10
+#define USB_DT_CS_INTERFACE_SIZE        5
+#define USB_DT_IAD_SIZE                 8
+
+
+// bmRequestType & 0x80 == dev2host (1) or host2dev (0)
+// recipient: bmRequestType & 0x1f
+#define REQUEST_RECIPIENT(b)    (b & 0x1f)
+#define REQ_RECIPIENT_DEVICE    0
+#define REQ_RECIPIENT_INTERFACE 1
+#define REQ_RECIPIENT_ENDPOINT  2
+#define REQ_RECIPIENT_OTHER     3
+// type: [bmRequestType & 0x60 >> 5]
+#define REQUEST_TYPE(b)         ((b&0x60)>>5)
+#define REQ_TYPE_STANDARD       0
+#define REQ_TYPE_CLASS          1
+#define REQ_TYPE_VENDOR         2
+#define REQ_TYPE_RESERVED       3
+
+
+//#define VENDOR_REQUEST                  0x01
+
+// standard device requests
+#define GET_STATUS                      0x00
+#define CLEAR_FEATURE                   0x01
+#define SET_FEATURE                     0x03
+#define SET_ADDRESS                     0x05
+#define GET_DESCRIPTOR                  0x06
+#define SET_DESCRIPTOR                  0x07
+#define GET_CONFIGURATION               0x08
+#define SET_CONFIGURATION               0x09
+// and some standard interface requests
+#define GET_INTERFACE                   0x0A
+#define SET_INTERFACE                   0x0B
+// and some standard endpoint requests
+#define SYNC_FRAME                      0x0C
+
+// Types of descriptors
+#define DEVICE_DESCRIPTOR               0x01
+#define CONFIGURATION_DESCRIPTOR        0x02
+#define STRING_DESCRIPTOR               0x03
+#define DEVICE_QUALIFIER_DESCRIPTOR     0x06
+#define DEBUG_DESCRIPTOR                0x0a
+#define HID_REPORT_DESCRIPTOR           0x22
+
+// EP types for EP_init
+#define EP_TYPE_BULK                    0x00
+#define EP_TYPE_CONTROL                 0x01
+#define EP_TYPE_ISO                     0x02
+#define EP_TYPE_INTERRUPT               0x03
+
+// EP types for descriptors
+#define USB_BM_ATTR_CONTROL             0x00
+#define USB_BM_ATTR_ISO                 0x01
+#define USB_BM_ATTR_BULK                0x02
+#define USB_BM_ATTR_INTERRUPT           0x03
+
+
+/******************************************************************
+ *                 Other stuff                                    *
+ *****************************************************************/
+
+#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))
+
+#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}
+
+// 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{
+#ifdef USB32
+    uint32_t *tx_buf;           // transmission buffer address
+#else
+    uint16_t *tx_buf;           // transmission buffer address
+#endif
+    uint16_t txbufsz;           // transmission buffer size
+#ifdef USB32
+    uint32_t *rx_buf;            // reception buffer address
+#else
+    uint8_t *rx_buf;            // reception buffer address
+#endif
+    void (*func)();             // endpoint action function
+    unsigned rx_cnt  : 10;      // received data counter
+} ep_t;
+
+extern volatile uint8_t usbON;
+
+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);
+void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size);
+int EP_Read(uint8_t number, uint8_t *buf);
+void EP_reset(uint8_t number);
+
+// could be [re]defined in usb_dev.c
+extern void usb_class_request(config_pack_t *packet, uint8_t *data, uint16_t datalen);
+extern void usb_vendor_request(config_pack_t *packet, uint8_t *data, uint16_t datalen);
+extern void set_configuration();

F0:F030,F042,F072/usbcan_gpio/usbcangpio.cflags

@@ -0,0 +1 @@
+-std=c17

F0:F030,F042,F072/usbcan_gpio/usbcangpio.config

@@ -0,0 +1,6 @@
+// Add predefined macros for your project here. For example:
+// #define THE_ANSWER 42
+#define EBUG
+#define STM32F0
+#define STM32F042x6
+#define USB2_16

F0:F030,F042,F072/usbcan_gpio/usbcangpio.creator

@@ -0,0 +1 @@
+[General]

F0:F030,F042,F072/usbcan_gpio/usbcangpio.creator.user

@@ -0,0 +1,218 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE QtCreatorProject>
+<!-- Written by QtCreator 18.0.2, 2026-03-07T01:14:33. -->
+<qtcreator>
+ <data>
+  <variable>EnvironmentId</variable>
+  <value type="QByteArray">{7bd84e39-ca37-46d3-be9d-99ebea85bc0d}</value>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.ActiveTarget</variable>
+  <value type="qlonglong">0</value>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.EditorSettings</variable>
+  <valuemap type="QVariantMap">
+   <value type="bool" key="EditorConfiguration.AutoDetect">true</value>
+   <value type="bool" key="EditorConfiguration.AutoIndent">true</value>
+   <value type="bool" key="EditorConfiguration.CamelCaseNavigation">true</value>
+   <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
+    <value type="QString" key="language">Cpp</value>
+    <valuemap type="QVariantMap" key="value">
+     <value type="QByteArray" key="CurrentPreferences">CppGlobal</value>
+    </valuemap>
+   </valuemap>
+   <valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
+    <value type="QString" key="language">QmlJS</value>
+    <valuemap type="QVariantMap" key="value">
+     <value type="QByteArray" key="CurrentPreferences">QmlJSGlobal</value>
+    </valuemap>
+   </valuemap>
+   <value type="qlonglong" key="EditorConfiguration.CodeStyle.Count">2</value>
+   <value type="QByteArray" key="EditorConfiguration.Codec">KOI8-R</value>
+   <value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
+   <value type="int" key="EditorConfiguration.IndentSize">4</value>
+   <value type="bool" key="EditorConfiguration.KeyboardTooltips">false</value>
+   <value type="int" key="EditorConfiguration.LineEndingBehavior">0</value>
+   <value type="int" key="EditorConfiguration.MarginColumn">80</value>
+   <value type="bool" key="EditorConfiguration.MouseHiding">true</value>
+   <value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
+   <value type="int" key="EditorConfiguration.PaddingMode">1</value>
+   <value type="int" key="EditorConfiguration.PreferAfterWhitespaceComments">0</value>
+   <value type="bool" key="EditorConfiguration.PreferSingleLineComments">false</value>
+   <value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
+   <value type="bool" key="EditorConfiguration.ShowMargin">false</value>
+   <value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
+   <value type="bool" key="EditorConfiguration.SmartSelectionChanging">true</value>
+   <value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
+   <value type="int" key="EditorConfiguration.TabKeyBehavior">0</value>
+   <value type="int" key="EditorConfiguration.TabSize">8</value>
+   <value type="bool" key="EditorConfiguration.UseGlobal">true</value>
+   <value type="bool" key="EditorConfiguration.UseIndenter">false</value>
+   <value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
+   <value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
+   <value type="bool" key="EditorConfiguration.cleanIndentation">false</value>
+   <value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
+   <value type="QString" key="EditorConfiguration.ignoreFileTypes">*.md, *.MD, Makefile</value>
+   <value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
+   <value type="bool" key="EditorConfiguration.skipTrailingWhitespace">true</value>
+   <value type="bool" key="EditorConfiguration.tintMarginArea">true</value>
+  </valuemap>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.PluginSettings</variable>
+  <valuemap type="QVariantMap">
+   <valuemap type="QVariantMap" key="AutoTest.ActiveFrameworks">
+    <value type="bool" key="AutoTest.Framework.Boost">true</value>
+    <value type="bool" key="AutoTest.Framework.CTest">false</value>
+    <value type="bool" key="AutoTest.Framework.Catch">true</value>
+    <value type="bool" key="AutoTest.Framework.GTest">true</value>
+    <value type="bool" key="AutoTest.Framework.QtQuickTest">true</value>
+    <value type="bool" key="AutoTest.Framework.QtTest">true</value>
+   </valuemap>
+   <value type="bool" key="AutoTest.ApplyFilter">false</value>
+   <valuemap type="QVariantMap" key="AutoTest.CheckStates"/>
+   <valuelist type="QVariantList" key="AutoTest.PathFilters"/>
+   <value type="int" key="AutoTest.RunAfterBuild">0</value>
+   <value type="bool" key="AutoTest.UseGlobal">true</value>
+   <valuemap type="QVariantMap" key="ClangTools">
+    <value type="bool" key="ClangTools.AnalyzeOpenFiles">true</value>
+    <value type="bool" key="ClangTools.BuildBeforeAnalysis">true</value>
+    <value type="QString" key="ClangTools.DiagnosticConfig">Builtin.DefaultTidyAndClazy</value>
+    <value type="int" key="ClangTools.ParallelJobs">8</value>
+    <value type="bool" key="ClangTools.PreferConfigFile">true</value>
+    <valuelist type="QVariantList" key="ClangTools.SelectedDirs"/>
+    <valuelist type="QVariantList" key="ClangTools.SelectedFiles"/>
+    <valuelist type="QVariantList" key="ClangTools.SuppressedDiagnostics"/>
+    <value type="bool" key="ClangTools.UseGlobalSettings">true</value>
+   </valuemap>
+   <value type="int" key="RcSync">0</value>
+  </valuemap>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.Target.0</variable>
+  <valuemap type="QVariantMap">
+   <value type="QString" key="DeviceType">Desktop</value>
+   <value type="bool" key="HasPerBcDcs">true</value>
+   <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
+   <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
+   <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{65a14f9e-e008-4c1b-89df-4eaa4774b6e3}</value>
+   <value type="qlonglong" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
+   <value type="qlonglong" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
+   <value type="qlonglong" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
+   <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
+    <value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/Big/Data/00__Electronics/STM32/F0-nolib/usbcan_ringbuffer</value>
+    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
+     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
+      <valuelist type="QVariantList" key="GenericProjectManager.GenericMakeStep.BuildTargets">
+       <value type="QString">all</value>
+      </valuelist>
+      <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
+      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">GenericProjectManager.GenericMakeStep</value>
+     </valuemap>
+     <value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Build</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
+    </valuemap>
+    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
+     <valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
+      <valuelist type="QVariantList" key="GenericProjectManager.GenericMakeStep.BuildTargets">
+       <value type="QString">clean</value>
+      </valuelist>
+      <value type="bool" key="ProjectExplorer.BuildStep.Enabled">true</value>
+      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">GenericProjectManager.GenericMakeStep</value>
+     </valuemap>
+     <value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Clean</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
+    </valuemap>
+    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
+    <value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
+    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.CustomParsers"/>
+    <value type="bool" key="ProjectExplorer.BuildConfiguration.ParseStandardOutput">false</value>
+    <valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
+    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Default</value>
+    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">GenericProjectManager.GenericBuildConfiguration</value>
+    <value type="qlonglong" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
+    <value type="qlonglong" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
+    <valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
+     <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
+      <value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
+      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Deploy</value>
+      <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Deploy</value>
+      <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
+     </valuemap>
+     <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
+     <valuemap type="QVariantMap" key="ProjectExplorer.DeployConfiguration.CustomData"/>
+     <value type="bool" key="ProjectExplorer.DeployConfiguration.CustomDataEnabled">false</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
+    </valuemap>
+    <value type="qlonglong" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
+    <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
+     <value type="bool" key="Analyzer.Perf.Settings.UseGlobalSettings">true</value>
+     <value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
+     <value type="int" key="Analyzer.Valgrind.Callgrind.CostFormat">0</value>
+     <value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
+     <value type="QList&lt;int&gt;" key="Analyzer.Valgrind.VisibleErrorKinds"></value>
+     <valuelist type="QVariantList" key="CustomOutputParsers"/>
+     <value type="int" key="PE.EnvironmentAspect.Base">2</value>
+     <valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
+     <value type="bool" key="PE.EnvironmentAspect.PrintOnRun">false</value>
+     <value type="QString" key="PerfRecordArgsId">-e cpu-cycles --call-graph dwarf,4096 -F 250</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
+     <value type="QString" key="ProjectExplorer.RunConfiguration.BuildKey"></value>
+     <value type="bool" key="ProjectExplorer.RunConfiguration.Customized">false</value>
+     <value type="QString" key="ProjectExplorer.RunConfiguration.UniqueId"></value>
+     <value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
+     <value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
+    </valuemap>
+    <value type="qlonglong" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
+   </valuemap>
+   <value type="qlonglong" key="ProjectExplorer.Target.BuildConfigurationCount">1</value>
+   <valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
+    <valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
+     <value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Deploy</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Deploy</value>
+     <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
+    </valuemap>
+    <value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
+    <valuemap type="QVariantMap" key="ProjectExplorer.DeployConfiguration.CustomData"/>
+    <value type="bool" key="ProjectExplorer.DeployConfiguration.CustomDataEnabled">false</value>
+    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
+   </valuemap>
+   <value type="qlonglong" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
+   <valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
+    <value type="bool" key="Analyzer.Perf.Settings.UseGlobalSettings">true</value>
+    <value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
+    <value type="int" key="Analyzer.Valgrind.Callgrind.CostFormat">0</value>
+    <value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
+    <value type="QList&lt;int&gt;" key="Analyzer.Valgrind.VisibleErrorKinds"></value>
+    <valuelist type="QVariantList" key="CustomOutputParsers"/>
+    <value type="int" key="PE.EnvironmentAspect.Base">2</value>
+    <valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
+    <value type="bool" key="PE.EnvironmentAspect.PrintOnRun">false</value>
+    <value type="QString" key="PerfRecordArgsId">-e cpu-cycles --call-graph dwarf,4096 -F 250</value>
+    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
+    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
+    <value type="QString" key="ProjectExplorer.RunConfiguration.BuildKey"></value>
+    <value type="bool" key="ProjectExplorer.RunConfiguration.Customized">false</value>
+    <value type="QString" key="ProjectExplorer.RunConfiguration.UniqueId"></value>
+    <value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
+    <value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
+   </valuemap>
+   <value type="qlonglong" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
+  </valuemap>
+ </data>
+ <data>
+  <variable>ProjectExplorer.Project.TargetCount</variable>
+  <value type="qlonglong">1</value>
+ </data>
+ <data>
+  <variable>Version</variable>
+  <value type="int">22</value>
+ </data>
+</qtcreator>

F0:F030,F042,F072/usbcan_gpio/usbcangpio.cxxflags

@@ -0,0 +1 @@
+-std=c++17

F0:F030,F042,F072/usbcan_gpio/usbcangpio.files

@@ -0,0 +1,26 @@
+can.c
+can.h
+canproto.c
+canproto.h
+flash.c
+flash.h
+gpioproto.c
+gpioproto.h
+hardware.c
+hardware.h
+main.c
+ringbuffer.c
+ringbuffer.h
+strfunc.c
+strfunc.h
+usb.c
+usb.h
+usb_defs.h
+usb_descr.c
+usb_descr.h
+usb_dev.c
+usb_dev.h
+usb_lib.c
+usb_lib.h
+usbhw.c
+usbhw.h

F0:F030,F042,F072/usbcan_gpio/usbcangpio.includes

@@ -0,0 +1,6 @@
+.
+../inc
+../inc/Fx
+../inc/cm
+../inc/ld
+../inc/startup

F0:F030,F042,F072/usbcan_gpio/version.inc

@@ -0,0 +1,2 @@
+#define BUILD_NUMBER "81"
+#define BUILD_DATE "2026-03-07"

F0:F030,F042,F072/usbcan_ringbuffer/kicad/stm32.kicad_prl

@@ -10,6 +10,7 @@
     "opacity": {
       "images": 0.6,
       "pads": 1.0,
+      "shapes": 1.0,
       "tracks": 1.0,
       "vias": 1.0,
       "zones": 0.6
@@ -29,42 +30,25 @@
       "zones": true
     },
     "visible_items": [
-      0,
+      "vias",
-      1,
+      "footprint_text",
-      2,
+      "footprint_anchors",
-      3,
+      "ratsnest",
-      4,
+      "grid",
-      5,
+      "footprints_front",
-      8,
+      "footprints_back",
-      9,
+      "footprint_values",
-      10,
+      "footprint_references",
-      11,
+      "tracks",
-      12,
+      "drc_errors",
-      13,
+      "drawing_sheet",
-      14,
+      "bitmaps",
-      15,
+      "pads",
-      16,
+      "zones",
-      17,
+      "drc_warnings",
-      18,
+      "shapes"
-      19,
-      20,
-      21,
-      22,
-      23,
-      24,
-      25,
-      26,
-      27,
-      28,
-      29,
-      30,
-      32,
-      33,
-      34,
-      35,
-      36
     ],
-    "visible_layers": "00290a0_00000000",
+    "visible_layers": "00000000_00000000_00000008_82000022",
     "zone_display_mode": 1
   },
   "git": {
@@ -75,9 +59,72 @@
   },
   "meta": {
     "filename": "stm32.kicad_prl",
-    "version": 3
+    "version": 5
   },
+  "net_inspector_panel": {
+    "col_hidden": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ],
+    "col_order": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9
+    ],
+    "col_widths": [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0
+    ],
+    "custom_group_rules": [],
+    "expanded_rows": [],
+    "filter_by_net_name": true,
+    "filter_by_netclass": true,
+    "filter_text": "",
+    "group_by_constraint": false,
+    "group_by_netclass": false,
+    "show_unconnected_nets": false,
+    "show_zero_pad_nets": false,
+    "sort_ascending": true,
+    "sorting_column": 0
+  },
+  "open_jobsets": [],
   "project": {
     "files": []
+  },
+  "schematic": {
+    "selection_filter": {
+      "graphics": true,
+      "images": true,
+      "labels": true,
+      "lockedItems": false,
+      "otherItems": true,
+      "pins": true,
+      "symbols": true,
+      "text": true,
+      "wires": true
+    }
   }
 }

F0:F030,F042,F072/usbcan_ringbuffer/kicad/stm32.kicad_pro

@@ -3,14 +3,17 @@
     "3dviewports": [],
     "design_settings": {
       "defaults": {
+        "apply_defaults_to_fp_fields": false,
+        "apply_defaults_to_fp_shapes": false,
+        "apply_defaults_to_fp_text": false,
         "board_outline_line_width": 0.15,
-        "copper_line_width": 0.19999999999999998,
+        "copper_line_width": 0.2,
         "copper_text_italic": false,
         "copper_text_size_h": 1.5,
         "copper_text_size_v": 1.5,
         "copper_text_thickness": 0.3,
         "copper_text_upright": false,
-        "courtyard_line_width": 0.049999999999999996,
+        "courtyard_line_width": 0.05,
         "dimension_precision": 4,
         "dimension_units": 3,
         "dimensions": {
@@ -21,13 +24,13 @@
           "text_position": 0,
           "units_format": 1
         },
-        "fab_line_width": 0.09999999999999999,
+        "fab_line_width": 0.1,
         "fab_text_italic": false,
         "fab_text_size_h": 1.0,
         "fab_text_size_v": 1.0,
         "fab_text_thickness": 0.15,
         "fab_text_upright": false,
-        "other_line_width": 0.09999999999999999,
+        "other_line_width": 0.1,
         "other_text_italic": false,
         "other_text_size_h": 1.0,
         "other_text_size_v": 1.0,
@@ -68,15 +71,20 @@
         "copper_edge_clearance": "error",
         "copper_sliver": "warning",
         "courtyards_overlap": "warning",
+        "creepage": "error",
         "diff_pair_gap_out_of_range": "error",
         "diff_pair_uncoupled_length_too_long": "error",
         "drill_out_of_range": "error",
         "duplicate_footprints": "warning",
         "extra_footprint": "warning",
         "footprint": "error",
+        "footprint_filters_mismatch": "ignore",
+        "footprint_symbol_mismatch": "warning",
         "footprint_type_mismatch": "error",
         "hole_clearance": "error",
         "hole_near_hole": "error",
+        "hole_to_hole": "error",
+        "holes_co_located": "warning",
         "invalid_outline": "error",
         "isolated_copper": "warning",
         "item_on_disabled_layer": "error",
@@ -86,9 +94,11 @@
         "lib_footprint_mismatch": "warning",
         "malformed_courtyard": "error",
         "microvia_drill_out_of_range": "error",
+        "mirrored_text_on_front_layer": "warning",
         "missing_courtyard": "ignore",
         "missing_footprint": "warning",
         "net_conflict": "warning",
+        "nonmirrored_text_on_back_layer": "warning",
         "npth_inside_courtyard": "ignore",
         "padstack": "error",
         "pth_inside_courtyard": "ignore",
@@ -100,10 +110,13 @@
         "solder_mask_bridge": "error",
         "starved_thermal": "error",
         "text_height": "warning",
+        "text_on_edge_cuts": "error",
         "text_thickness": "warning",
         "through_hole_pad_without_hole": "error",
         "too_many_vias": "error",
+        "track_angle": "error",
         "track_dangling": "warning",
+        "track_segment_length": "error",
         "track_width": "error",
         "tracks_crossing": "error",
         "unconnected_items": "error",
@@ -119,58 +132,63 @@
         "max_error": 0.005,
         "min_clearance": 0.0,
         "min_connection": 0.0,
-        "min_copper_edge_clearance": 0.09999999999999999,
+        "min_copper_edge_clearance": 0.1,
+        "min_groove_width": 0.0,
         "min_hole_clearance": 0.25,
         "min_hole_to_hole": 0.25,
-        "min_microvia_diameter": 0.19999999999999998,
+        "min_microvia_diameter": 0.2,
-        "min_microvia_drill": 0.09999999999999999,
+        "min_microvia_drill": 0.1,
         "min_resolved_spokes": 2,
         "min_silk_clearance": 0.0,
-        "min_text_height": 0.7999999999999999,
+        "min_text_height": 0.8,
         "min_text_thickness": 0.08,
         "min_through_hole_diameter": 0.3,
         "min_track_width": 0.15,
-        "min_via_annular_width": 0.049999999999999996,
+        "min_via_annular_width": 0.05,
-        "min_via_diameter": 0.39999999999999997,
+        "min_via_diameter": 0.4,
         "solder_mask_to_copper_clearance": 0.0,
         "use_height_for_length_calcs": true
       },
       "teardrop_options": [
         {
-          "td_allow_use_two_tracks": true,
+          "td_onpthpad": true,
-          "td_curve_segcount": 5,
-          "td_on_pad_in_zone": false,
-          "td_onpadsmd": true,
           "td_onroundshapesonly": false,
+          "td_onsmdpad": true,
           "td_ontrackend": false,
-          "td_onviapad": true
+          "td_onvia": true
         }
       ],
       "teardrop_parameters": [
         {
-          "td_curve_segcount": 0,
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 1,
           "td_height_ratio": 1.0,
           "td_length_ratio": 0.5,
           "td_maxheight": 2.0,
           "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
           "td_target_name": "td_round_shape",
           "td_width_to_size_filter_ratio": 0.9
         },
         {
-          "td_curve_segcount": 0,
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 1,
           "td_height_ratio": 1.0,
           "td_length_ratio": 0.5,
           "td_maxheight": 2.0,
           "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
           "td_target_name": "td_rect_shape",
           "td_width_to_size_filter_ratio": 0.9
         },
         {
-          "td_curve_segcount": 0,
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 1,
           "td_height_ratio": 1.0,
           "td_length_ratio": 0.5,
           "td_maxheight": 2.0,
           "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
           "td_target_name": "td_track_end",
           "td_width_to_size_filter_ratio": 0.9
         }
@@ -181,6 +199,32 @@
         0.25,
         0.5
       ],
+      "tuning_pattern_settings": {
+        "diff_pair_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 1.0
+        },
+        "diff_pair_skew_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 0.6
+        },
+        "single_track_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 0.6
+        }
+      },
       "via_dimensions": [
         {
           "diameter": 0.0,
@@ -209,6 +253,7 @@
       "mfg": "",
       "mpn": ""
     },
+    "layer_pairs": [],
     "layer_presets": [],
     "viewports": []
   },
@@ -403,10 +448,15 @@
       "duplicate_sheet_names": "error",
       "endpoint_off_grid": "warning",
       "extra_units": "error",
+      "footprint_filter": "ignore",
+      "footprint_link_issues": "warning",
+      "four_way_junction": "ignore",
       "global_label_dangling": "warning",
       "hier_label_mismatch": "error",
       "label_dangling": "error",
+      "label_multiple_wires": "warning",
       "lib_symbol_issues": "warning",
+      "lib_symbol_mismatch": "warning",
       "missing_bidi_pin": "warning",
       "missing_input_pin": "warning",
       "missing_power_pin": "error",
@@ -419,9 +469,15 @@
       "pin_not_driven": "error",
       "pin_to_pin": "warning",
       "power_pin_not_driven": "error",
+      "same_local_global_label": "warning",
+      "similar_label_and_power": "warning",
       "similar_labels": "warning",
+      "similar_power": "warning",
       "simulation_model_issue": "ignore",
+      "single_global_label": "ignore",
       "unannotated": "error",
+      "unconnected_wire_endpoint": "warning",
+      "undefined_netclass": "error",
       "unit_value_mismatch": "error",
       "unresolved_variable": "error",
       "wire_dangling": "error"
@@ -433,7 +489,7 @@
   },
   "meta": {
     "filename": "stm32.kicad_pro",
-    "version": 1
+    "version": 3
   },
   "net_settings": {
     "classes": [
@@ -448,6 +504,7 @@
         "microvia_drill": 0.1,
         "name": "Default",
         "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "priority": 2147483647,
         "schematic_color": "rgba(0, 0, 0, 0.000)",
         "track_width": 0.2,
         "via_diameter": 0.8,
@@ -465,6 +522,7 @@
         "microvia_drill": 0.1,
         "name": "0.25",
         "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "priority": 0,
         "schematic_color": "rgba(0, 0, 0, 0.000)",
         "track_width": 0.25,
         "via_diameter": 1.0,
@@ -482,6 +540,7 @@
         "microvia_drill": 0.1,
         "name": "0.5",
         "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "priority": 1,
         "schematic_color": "rgba(0, 0, 0, 0.000)",
         "track_width": 0.5,
         "via_diameter": 1.4,
@@ -490,7 +549,7 @@
       }
     ],
     "meta": {
-      "version": 3
+      "version": 4
     },
     "net_colors": null,
     "netclass_assignments": null,
@@ -512,6 +571,7 @@
   },
   "schematic": {
     "annotate_start_num": 0,
+    "bom_export_filename": "${PROJECTNAME}.csv",
     "bom_fmt_presets": [],
     "bom_fmt_settings": {
       "field_delimiter": ",",
@@ -565,6 +625,7 @@
       ],
       "filter_string": "",
       "group_symbols": true,
+      "include_excluded_from_bom": false,
       "name": "Grouped By Value",
       "sort_asc": true,
       "sort_field": "Обозначение"
@@ -611,6 +672,7 @@
     },
     "page_layout_descr_file": "",
     "plot_directory": "",
+    "space_save_all_events": true,
     "spice_adjust_passive_values": false,
     "spice_current_sheet_as_root": false,
     "spice_external_command": "spice \"%I\"",
@@ -624,7 +686,7 @@
   "sheets": [
     [
       "ce45f0ed-5b96-460f-9f82-e8a7af322e24",
-      "Корневой лист"
+      "Root"
     ]
   ],
   "text_variables": {}

F0:F030,F042,F072/usbcan_ringbuffer/openocd.cfg

@@ -1,96 +1,4 @@
-# script for stm32f0x family
+set FLASH_SIZE 0x8000
 
-#
-# stm32 devices support SWD transports only.
-#
 source [find interface/stlink-v2-1.cfg]
-source [find target/swj-dp.tcl]
+source [find target/stm32f0x.cfg]
-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 }