restructuring

F0:F030,F042,F072/usbcan_relay/Makefile

@@ -0,0 +1,147 @@
+BINARY		= usbcan
+BOOTPORT	?= /dev/ttyUSB0
+BOOTSPEED	?= 57600
+# MCU FAMILY
+FAMILY		= F0
+# MCU code
+MCU			= F042x6
+# hardware definitions
+#DEFS		+= -DEBUG
+# change this linking script depending on particular MCU model,
+# for example, if you have STM32F103VBT6, you should write:
+LDSCRIPT	= stm32f042x6.ld
+
+INDEPENDENT_HEADERS=
+
+FP_FLAGS	?= -msoft-float
+ASM_FLAGS	= -mthumb -mcpu=cortex-m0 -march=armv6-m -mtune=cortex-m0
+ARCH_FLAGS	= $(ASM_FLAGS) $(FP_FLAGS)
+
+###############################################################################
+# Executables
+OPREFIX		?= /opt/bin/arm-none-eabi
+#PREFIX		?= /usr/x86_64-pc-linux-gnu/arm-none-eabi/gcc-bin/7.3.0/arm-none-eabi
+PREFIX		?= $(OPREFIX)
+
+RM			:= rm -f
+RMDIR		:= rmdir
+CC			:= $(PREFIX)-gcc
+LD			:= $(PREFIX)-gcc
+AR			:= $(PREFIX)-ar
+AS			:= $(PREFIX)-as
+OBJCOPY		:= $(OPREFIX)-objcopy
+OBJDUMP		:= $(OPREFIX)-objdump
+GDB			:= $(OPREFIX)-gdb
+STFLASH		:= $(shell which st-flash)
+STBOOT		:= $(shell which stm32flash)
+DFUUTIL		:= $(shell which dfu-util)
+
+###############################################################################
+# Source files
+OBJDIR 		= mk
+LDSCRIPT	?= $(BINARY).ld
+SRC			:= $(wildcard *.c)
+OBJS		:= $(addprefix $(OBJDIR)/, $(SRC:%.c=%.o))
+STARTUP		= $(OBJDIR)/startup.o
+OBJS 		+= $(STARTUP)
+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
+CFLAGS		+= -Wredundant-decls $(INCLUDE)
+# -Wmissing-prototypes -Wstrict-prototypes
+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)
+
+#.SUFFIXES: .elf .bin .hex .srec .list .map .images
+#.SECONDEXPANSION:
+#.SECONDARY:
+
+ELF		:= $(OBJDIR)/$(BINARY).elf
+LIST	:= $(OBJDIR)/$(BINARY).list
+BIN		:= $(BINARY).bin
+HEX		:= $(BINARY).hex
+
+all: bin list
+
+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) $(ARCH_FLAGS) -o $@ -c $<
+
+$(OBJDIR)/%.o: %.c
+	@echo "  CC      $<"
+	$(CC) $(CFLAGS) $(DEFS) $(INCLUDE) $(ARCH_FLAGS) -o $@ -c $<
+
+#$(OBJDIR)/%.d: %.c $(OBJDIR)
+#	$(CC) -MM -MG $< | sed -e 's,^\([^:]*\)\.o[ ]*:,$(@D)/\1.o $(@D)/\1.d:,' >$@
+
+$(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)
+
+clean:
+	@echo "  CLEAN"
+	$(RM) $(OBJS) $(DEPS) $(ELF) $(HEX) $(LIST) $(OBJDIR)/*.map *.d
+	@rmdir $(OBJDIR) 2>/dev/null || true
+
+dfuboot: $(BIN)
+	@echo "  LOAD  $(BIN) THROUGH DFU"
+	$(DFUUTIL) -a0 -R -D $(BIN) -s 0x08000000
+
+flash: $(BIN)
+	@echo "  FLASH  $(BIN)"
+	$(STFLASH) write $(BIN) 0x8000000
+
+boot: $(BIN)
+	@echo "  LOAD $(BIN) through bootloader"
+	$(STBOOT) -b$(BOOTSPEED) $(BOOTPORT) -w $(BIN)
+
+gentags:
+	CFLAGS="$(CFLAGS) $(DEFS)" geany -g $(BINARY).c.tags *[hc] 2>/dev/null
+
+.PHONY: clean flash boot gentags

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

@@ -0,0 +1,31 @@
+CAN/USB management of 2 relays and some other things
+===================================================
+
+The device can also work as USB-CAN converter.
+
+CAN protocol is quite simple. The node receives data to selected CAN ID, transmission done with the 
+ID = CANID + 0x100.
+
+
+Pinout:
+- PA0/1 - Relay0/1 
+- PA2..5 - Button0..3 (user buttons)
+- PA6/7 - ADC inputs through resistive divider (0..5 and 0..12V)
+- PA8..10 - PWM0..2 outputs (opendrain through SI2300, 5 or 12V)
+- PA13/14 - SWD; the SWD pin +3.3V connected through 22Ohm resistor
+- PA11. PA12 - USB DM/DP
+- PB0..PB7 - CAN ID 
+- PB8, PB9 - CAN Rx/Tx
+- PB12..15 - LED0..3 outputs (direct outputs without any protection!!!)
+ 
+The pins LEDr0 and LEDr1 are indicated relay works (12V through 2.2kOhm resistor)
+
+
+### Buttons standalone
+
+BTN1 - switch relay1
+
+BTN2 - switch relay 2
+
+BTN3 - change PWM0: hold to turn ON or turn OFF; press shortly BTN1/BTN2 to increase/decrease PWM0 to 1, 
+hold BTN1/BTN2 to inc/dec PWM0 to 25 (do as many presses as need).

F0:F030,F042,F072/usbcan_relay/adc.c

@@ -0,0 +1,105 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 "adc.h"
+
+/**
+ * @brief ADC_array - array for ADC channels with median filtering:
+ * 0 & 1 - external channels (5 & 12V)
+ * 2 - internal Tsens
+ * 3 - Vref
+ */
+static uint16_t ADC_array[NUMBER_OF_ADC_CHANNELS*9];
+
+void adc_setup(){
+    uint16_t ctr = 0; // 0xfff0 - more than 1.3ms
+    ADC1->CR &= ~ADC_CR_ADEN;
+    DMA1_Channel1->CCR &= ~DMA_CCR_EN;
+    RCC->APB2ENR |= RCC_APB2ENR_ADC1EN; // Enable the peripheral clock of the ADC
+    RCC->CR2 |= RCC_CR2_HSI14ON; // Start HSI14 RC oscillator
+    while ((RCC->CR2 & RCC_CR2_HSI14RDY) == 0 && ++ctr < 0xfff0){}; // Wait HSI14 is ready
+    // calibration
+    if(ADC1->CR & ADC_CR_ADEN){ // Ensure that ADEN = 0
+        ADC1->CR &= (uint32_t)(~ADC_CR_ADEN);  // Clear ADEN
+    }
+    ADC1->CR |= ADC_CR_ADCAL; // Launch the calibration by setting ADCAL
+    ctr = 0; // ADC calibration time is 5.9us
+    while(ADC1->CR & ADC_CR_ADCAL && ++ctr < 0xfff0); // Wait until ADCAL=0
+    // enable ADC
+    ctr = 0;
+    do{
+          ADC1->CR |= ADC_CR_ADEN;
+    }while((ADC1->ISR & ADC_ISR_ADRDY) == 0 && ++ctr < 0xfff0);
+    // configure ADC
+    ADC1->CFGR1 |= ADC_CFGR1_CONT; // Select the continuous mode
+    // channels 6,7,16 and 17
+    ADC1->CHSELR =  ADC_CHSELR_CHSEL6 | ADC_CHSELR_CHSEL7 | ADC_CHSELR_CHSEL16 | ADC_CHSELR_CHSEL17;
+    ADC1->SMPR |= ADC_SMPR_SMP; // Select a sampling mode of 111 i.e. 239.5 ADC clk to be greater than 17.1us
+    ADC->CCR |= ADC_CCR_TSEN | ADC_CCR_VREFEN; // Wake-up the VREFINT and Temperature sensor
+    // configure DMA for ADC
+    RCC->AHBENR |= RCC_AHBENR_DMA1EN; // Enable the peripheral clock on DMA
+    ADC1->CFGR1 |= ADC_CFGR1_DMAEN | ADC_CFGR1_DMACFG; // Enable DMA transfer on ADC and circular mode
+    DMA1_Channel1->CPAR = (uint32_t) (&(ADC1->DR)); // Configure the peripheral data register address
+    DMA1_Channel1->CMAR = (uint32_t)(ADC_array); // Configure the memory address
+    DMA1_Channel1->CNDTR = NUMBER_OF_ADC_CHANNELS * 9; // Configure the number of DMA tranfer to be performs on DMA channel 1
+    DMA1_Channel1->CCR |= DMA_CCR_MINC | DMA_CCR_MSIZE_0 | DMA_CCR_PSIZE_0 | DMA_CCR_CIRC; // Configure increment, size, interrupts and circular mode
+    DMA1_Channel1->CCR |= DMA_CCR_EN; // Enable DMA Channel 1
+    ADC1->CR |= ADC_CR_ADSTART; // start the ADC conversions
+}
+
+/**
+ * @brief getADCval - calculate median value for `nch` channel
+ * @param nch - number of channel
+ * @return
+ */
+uint16_t getADCval(int nch){
+    int i, addr = nch;
+    register uint16_t temp;
+#define PIX_SORT(a,b) { if ((a)>(b)) PIX_SWAP((a),(b)); }
+#define PIX_SWAP(a,b) { temp=(a);(a)=(b);(b)=temp; }
+    uint16_t p[9];
+    for(i = 0; i < 9; ++i, addr += NUMBER_OF_ADC_CHANNELS) // first we should prepare array for optmed
+        p[i] = ADC_array[addr];
+    PIX_SORT(p[1], p[2]) ; PIX_SORT(p[4], p[5]) ; PIX_SORT(p[7], p[8]) ;
+    PIX_SORT(p[0], p[1]) ; PIX_SORT(p[3], p[4]) ; PIX_SORT(p[6], p[7]) ;
+    PIX_SORT(p[1], p[2]) ; PIX_SORT(p[4], p[5]) ; PIX_SORT(p[7], p[8]) ;
+    PIX_SORT(p[0], p[3]) ; PIX_SORT(p[5], p[8]) ; PIX_SORT(p[4], p[7]) ;
+    PIX_SORT(p[3], p[6]) ; PIX_SORT(p[1], p[4]) ; PIX_SORT(p[2], p[5]) ;
+    PIX_SORT(p[4], p[7]) ; PIX_SORT(p[4], p[2]) ; PIX_SORT(p[6], p[4]) ;
+    PIX_SORT(p[4], p[2]) ;
+    return p[4];
+#undef PIX_SORT
+#undef PIX_SWAP
+}
+
+// return MCU temperature (degrees of celsius * 10)
+int32_t getMCUtemp(){
+    int32_t ADval = getADCval(2);
+    int32_t temperature = (int32_t) *TEMP30_CAL_ADDR - ADval;
+    temperature *= (int32_t)(1100 - 300);
+    temperature /= (int32_t)(*TEMP30_CAL_ADDR - *TEMP110_CAL_ADDR);
+    temperature += 300;
+    return(temperature);
+}
+
+// return Vdd * 100 (V)
+uint32_t getVdd(){
+    uint32_t vdd = ((uint32_t) *VREFINT_CAL_ADDR) * (uint32_t)330; // 3.3V
+    vdd /= getADCval(3);
+    return vdd;
+}

F0:F030,F042,F072/usbcan_relay/adc.h

@@ -0,0 +1,32 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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/>.
+ */
+
+#ifndef ADC_H
+#define ADC_H
+#include "stm32f0.h"
+
+// 2 external & 2 internal
+#define NUMBER_OF_ADC_CHANNELS (4)
+
+void adc_setup();
+int32_t getMCUtemp();
+uint32_t getVdd();
+uint16_t getADCval(int nch);
+int16_t getNTC(int nch);
+
+#endif // ADC_H

F0:F030,F042,F072/usbcan_relay/buttons.c

@@ -0,0 +1,90 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 "buttons.h"
+#include "hardware.h"
+
+typedef struct{
+    keyevent event;         // current key event
+    int16_t counter;        // press/release counter
+    uint32_t lastTms;       // time of last event change
+} keybase;
+
+static keybase allkeys[BTNSNO] = {0}; // array for buttons' states
+
+uint32_t lastUnsleep = 0; // last keys activity time
+
+void process_keys(){
+    static uint32_t lastT = 0;
+    if(Tms == lastT) return;
+    uint16_t d = (uint16_t)(Tms - lastT);
+    lastT = Tms;
+    for(int i = 0; i < BTNSNO; ++i){
+        keybase *k = &allkeys[i];
+        keyevent e = k->event;
+        if(BTN_state(i)){ // key is in pressed state
+            switch(e){
+                case EVT_NONE: // just pressed
+                case EVT_RELEASE:
+                    if((k->counter += d) > PRESSTHRESHOLD){
+                        k->event = EVT_PRESS;
+                    }
+                break;
+                case EVT_PRESS: // hold
+                    if((k->counter += d)> HOLDTHRESHOLD){
+                        k->event = EVT_HOLD;
+                    }
+                break;
+                default:
+                break;
+            }
+        }else{ // released
+            if(e == EVT_PRESS || e == EVT_HOLD){ // released
+                if(k->counter > PRESSTHRESHOLD) k->counter = PRESSTHRESHOLD;
+                else if((k->counter -= d) < 0){
+                    k->event = EVT_RELEASE; // button released
+                }
+            }
+        }
+        if(e != k->event){
+            k->lastTms = Tms;
+            lastUnsleep = Tms;
+        }
+    }
+}
+
+/**
+ * @brief keystate - curent key state
+ * @param k   - key number
+ * @param T   - last event changing time
+ * @return key event
+ */
+keyevent keystate(uint8_t k, uint32_t *T){
+    if(k >= BTNSNO) return EVT_NONE;
+    keyevent evt = allkeys[k].event;
+    // change state `release` to `none` after 1st check
+    if(evt == EVT_RELEASE) allkeys[k].event = EVT_NONE;
+    if(T) *T = allkeys[k].lastTms;
+    return evt;
+}
+
+// getter of keyevent for allkeys[]
+keyevent keyevt(uint8_t k){
+    if(k >= BTNSNO) return EVT_NONE;
+    return allkeys[k].event;
+}

F0:F030,F042,F072/usbcan_relay/buttons.h

@@ -0,0 +1,43 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 BUTTONS_H__
+
+#include <stm32f0.h>
+
+// threshold in ms for press/hold
+#define PRESSTHRESHOLD  (9)
+#define HOLDTHRESHOLD   (199)
+
+// events
+typedef enum{
+    EVT_NONE,   // no events with given key
+    EVT_PRESS,  // pressed (hold more than PRESSTHRESHOLD ms)
+    EVT_HOLD,   // hold more than HOLDTHRESHOLD ms
+    EVT_RELEASE // released after press or hold state
+} keyevent;
+
+extern uint32_t lastUnsleep; // last keys activity time
+
+void process_keys();
+keyevent keystate(uint8_t k, uint32_t *T);
+keyevent keyevt(uint8_t k);
+
+#define BUTTONS_H__
+#endif // BUTTONS_H__

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

@@ -0,0 +1,336 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 "canproto.h"
+#include "hardware.h"
+#include "proto.h"
+
+#include <string.h> // memcpy
+
+// 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
+static uint16_t oldspeed = DEFAULT_CAN_SPEED; // speed of last init
+
+#ifdef EBUG
+static uint32_t last_err_code = 0;
+#endif
+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;
+    if(st == CAN_FIFO_OVERRUN) can_status = CAN_READY;
+    return st;
+}
+
+// push next message into buffer; return 1 if buffer overfull
+static int CAN_messagebuf_push(CAN_message *msg){
+    //MSG("Try to push\n");
+    if(first_free_idx == first_nonfree_idx) return 1; // no free space
+    if(first_nonfree_idx < 0) first_nonfree_idx = 0;  // first message in empty buffer
+    memcpy(&messages[first_free_idx++], msg, sizeof(CAN_message));
+    // 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;
+    #ifdef EBUG
+    //MSG("read from idx "); printu(first_nonfree_idx); NL();
+    #endif
+    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;
+}
+
+void 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;
+    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
+*/
+
+// speed - in kbps
+void CAN_setup(uint16_t speed){
+    if(speed == 0) speed = oldspeed;
+    else if(speed < 50) speed = 50;
+    else if(speed > 3000) speed = 3000;
+    oldspeed = speed;
+    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
+    CAN->MCR |= CAN_MCR_INRQ; // Enter CAN init mode to write the configuration
+    while((CAN->MSR & CAN_MSR_INAK) != CAN_MSR_INAK){
+        IWDG->KR = IWDG_REFRESH;
+        if(--tmout == 0) break;
+    }
+    CAN->MCR &=~ CAN_MCR_SLEEP;
+    CAN->MCR |= CAN_MCR_ABOM; // allow automatically bus-off
+    CAN->BTR =  2 << 20 | 3 << 16 | (6000/speed - 1); // speed
+    CAN->MCR &=~ CAN_MCR_INRQ;
+    tmout = 16000000;
+    while((CAN->MSR & CAN_MSR_INAK) == CAN_MSR_INAK){ // Wait the init mode leaving
+        IWDG->KR = IWDG_REFRESH;
+        if(--tmout == 0) break;
+    }
+    // accept self ID at filter 0, ALL other at filters 1 and 2
+    CAN->FMR = CAN_FMR_FINIT;
+    CAN->FA1R = CAN_FA1R_FACT0 | CAN_FA1R_FACT1 | CAN_FA1R_FACT2;
+    CAN->FM1R = CAN_FM1R_FBM0; // identifier mode for bank#0, mask mode for #1 and #2
+    // set to 1 all needed bits of CAN->FFA1R to switch given filters to FIFO1
+    CAN->sFilterRegister[0].FR1 = CANID << 5; // self ID
+    CAN->sFilterRegister[1].FR1 = (1<<21)|(1<<5); // all odd IDs
+    CAN->sFilterRegister[2].FR1 = (1<<21); // all even IDs
+    CAN->FFA1R = 2; // filter 1 for FIFO1, filters 0&2 - for FIFO0
+    CAN->FMR &=~ CAN_FMR_FINIT; // end of filters init
+    CAN->IER |= CAN_IER_ERRIE | CAN_IER_FOVIE0 | CAN_IER_FOVIE1;
+
+    /* Configure IT */
+    NVIC_SetPriority(CEC_CAN_IRQn, 0);
+    NVIC_EnableIRQ(CEC_CAN_IRQn);
+    can_status = CAN_READY;
+}
+
+void can_proc(){
+#ifdef EBUG
+    if(last_err_code){
+        MSG("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");
+        SEND("Receive error counter: ");
+        printu((CAN->ESR & CAN_ESR_REC)>>24);
+        SEND("\nTransmit error counter: ");
+        printu((CAN->ESR & CAN_ESR_TEC)>>16);
+        SEND("\nLast error code: ");
+        int lec = (CAN->ESR & 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(CAN->ESR & CAN_ESR_BOFF) SEND("Bus off");
+        if(CAN->ESR & CAN_ESR_EPVF) SEND("Passive error limit");
+        if(CAN->ESR & CAN_ESR_EWGF) SEND("Error counter limit");
+        NL();
+        IWDG->KR = IWDG_REFRESH;
+        // 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;
+    if(flood_msg && (Tms - lastFloodTime) > (FLOOD_PERIOD_MS-1)){ // flood every ~5ms
+        lastFloodTime = Tms;
+        can_send(flood_msg->data, flood_msg->length, flood_msg->ID);
+    }
+}
+
+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
+        //SEND("No free mailboxes"); NL();
+        return CAN_BUSY;
+    }
+#ifdef EBUG
+    MSG("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;
+            __attribute__((fallthrough));
+        case 7:
+            hb |= (uint32_t)msg[6] << 16;
+            __attribute__((fallthrough));
+        case 6:
+            hb |= (uint32_t)msg[5] << 8;
+            __attribute__((fallthrough));
+        case 5:
+            hb |= (uint32_t)msg[4];
+            __attribute__((fallthrough));
+        case 4:
+            lb |= (uint32_t)msg[3] << 24;
+            __attribute__((fallthrough));
+        case 3:
+            lb |= (uint32_t)msg[2] << 16;
+            __attribute__((fallthrough));
+        case 2:
+            lb |= (uint32_t)msg[1] << 8;
+            __attribute__((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){
+    if(!msg) flood_msg = NULL;
+    else{
+        memcpy(&loc_flood_msg, msg, sizeof(CAN_message));
+        flood_msg = &loc_flood_msg;
+    }
+}
+
+static void can_process_fifo(uint8_t fifo_num){
+    if(fifo_num > 1) return;
+    CAN_FIFOMailBox_TypeDef *box = &CAN->sFIFOMailBox[fifo_num];
+    volatile uint32_t *RFxR = (fifo_num) ? &CAN->RF1R : &CAN->RF0R;
+    // 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
+        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;
+                    __attribute__((fallthrough));
+                case 7:
+                    dat[6] = (hb>>16) & 0xff;
+                    __attribute__((fallthrough));
+                case 6:
+                    dat[5] = (hb>>8) & 0xff;
+                    __attribute__((fallthrough));
+                case 5:
+                    dat[4] = hb & 0xff;
+                    __attribute__((fallthrough));
+                case 4:
+                    dat[3] = lb>>24;
+                    __attribute__((fallthrough));
+                case 3:
+                    dat[2] = (lb>>16) & 0xff;
+                    __attribute__((fallthrough));
+                case 2:
+                    dat[1] = (lb>>8) & 0xff;
+                    __attribute__((fallthrough));
+                case 1:
+                    dat[0] = lb & 0xff;
+            }
+        }
+        if(msg.ID == CANID) parseCANcommand(&msg);
+        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_relay/can.h

@@ -0,0 +1,63 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 __CAN_H__
+#define __CAN_H__
+
+#include "hardware.h"
+
+// CAN ID mask (11 bits)
+#define CANIDMASK           (0x7ff)
+
+// 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)
+
+// 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();
+
+void CAN_reinit(uint16_t speed);
+void CAN_setup(uint16_t speed);
+
+CAN_status can_send(uint8_t *msg, uint8_t len, uint16_t target_id);
+void can_proc();
+
+CAN_message *CAN_messagebuf_pop();
+
+void set_flood(CAN_message *msg);
+
+#endif // __CAN_H__

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

@@ -0,0 +1,179 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 "adc.h"
+#include "buttons.h"
+#include "canproto.h"
+#include "hardware.h"
+#include "proto.h"
+
+/*
+ * Protocol (endian format depends on command!):
+ * answer will be send to `OUTPID` CAN ID, length depends on received command
+ * IN packet (sent to `CANID`) data bytes:
+ *  0 - command (any from CAN_commands), 1..7 - data
+ * To set value command should have CAN_CMD_SETFLAG == 1
+ * OUT packet depending on command:
+ * CAN_CMD_PING (or any incoming packet with zero lenght) - zero length answer
+ * other commands have data[0] equal to in command (without CAN_CMD_SETFLAG)
+ * CAN_CMD_ADC: data[1]..data[6] - 12bits*4channels RAW ADC data (ADC channels 0..3)
+ * CAN_CMD_BTNS: data[1] = button number (0..3), data[2] - state (keyevent), data[4..7] - event time (LITTLE endian!)
+ * CAN_CMD_LED: data[1] = LEDs state (bits 0..3 for LEDs number 0..3)
+ * CAN_CMD_MCU: data[2,3] = int16_t MCUT*10, data[4,5] = uint16_t Vdd*100 (LITTLE endian!)
+ * CAN_CMD_PWM: data[1..3] = pwm value for each channel (0..2)
+ * CAN_CMD_RELAY: data[1] = (bits 0 & 1) - state of relay N]
+ * CAN_CMD_TMS: data[4..7] = Tms (LITTLE endian!)
+ */
+
+// return total message length
+TRUE_INLINE uint8_t ADCget(uint8_t values[8]){
+    uint16_t v[NUMBER_OF_ADC_CHANNELS];
+    for(int i = 0; i < NUMBER_OF_ADC_CHANNELS; ++i) v[i] = getADCval(i);
+    // if NUMBER_OF_ADC_CHANNELS != 4 - need for manual refactoring!
+    values[1] = v[0] >> 4;
+    values[2] = (v[0] << 4) | ((v[1] >> 8) & 0x0f);
+    values[3] = v[1] & 0xff;
+    values[4] = v[2] >> 4;
+    values[5] = (v[2] << 4) | ((v[3] >> 8) & 0x0f);
+    values[6] = v[3] & 0xff;
+    return 7;
+}
+
+TRUE_INLINE void BTNSget(uint8_t values[8]){
+    uint32_t T;
+    uint8_t start = 0, stop = BTNSNO;
+    if(values[1] < BTNSNO){ // check only one button
+        start = values[1]; stop = start + 1;
+    }
+    for(uint8_t i = start; i < stop; ++i){
+        values[1] = i;
+        values[2] = keystate(i, &T);
+        values[3] = 0;
+        *((uint32_t*)&values[4]) = T;
+        T = Tms;
+        while(CAN_BUSY == can_send(values, 8, OUTPID)){
+            if(Tms - T > 5) break;
+        }
+    }
+}
+
+TRUE_INLINE void LEDSset(uint8_t data[8]){
+    for(int i = 0; i < LEDSNO; ++i){
+        if(data[1] & 1<<i) LED_on(i);
+        else LED_off(i);
+    }
+}
+
+TRUE_INLINE uint8_t LEDSget(uint8_t data[8]){
+    uint8_t x = 0;
+    for(int i = 0; i < LEDSNO; ++i)
+        if(LED_chk(i)) x |= 1<<i;
+    data[1] = x;
+    return 2;
+}
+
+TRUE_INLINE uint8_t MCUget(uint8_t data[8]){
+    *((int16_t*)&data[2]) = (int16_t)getMCUtemp();
+    *((uint16_t*)&data[4]) = (int16_t)getVdd();
+    return 6;
+}
+
+TRUE_INLINE void PWMset(uint8_t data[8]){
+    volatile uint32_t *reg = &TIM1->CCR1;
+    for(int i = 0; i < 3; ++i)
+        reg[i] = data[i+1];
+}
+
+TRUE_INLINE uint8_t PWMget(uint8_t data[8]){
+    volatile uint32_t *reg = &TIM1->CCR1;
+    for(int i = 0; i < 3; ++i)
+        data[i+1] = reg[i];
+    return 4;
+}
+
+TRUE_INLINE void Rset(uint8_t data[8]){
+    for(int i = 0; i < RelaysNO; ++i){
+        if(data[1] & 1<<i) Relay_ON(i);
+        else Relay_OFF(i);
+    }
+}
+
+TRUE_INLINE uint8_t Rget(uint8_t data[8]){
+    uint8_t x = 0;
+    for(int i = 0; i < RelaysNO; ++i){
+        if(Relay_chk(i)) x |= 1<<i;
+    }
+    data[1] = x;
+    return 2;
+}
+
+TRUE_INLINE uint8_t showTms(uint8_t data[8]){
+    *((uint32_t*)&data[4]) = Tms;
+    return 8;
+}
+
+void parseCANcommand(CAN_message *msg){
+    uint8_t outpdata[8], len = 0;
+#ifdef EBUG
+    SEND("Get data: ");
+    for(int i = 0; i < msg->length; ++i){
+        printuhex(msg->data[i]); bufputchar(' ');
+    }
+    NL();
+#endif
+    int N = 1000;
+    uint8_t cmd = msg->data[0] & CANCMDMASK, setter = msg->data[0] & CAN_CMD_SETFLAG;
+    if(msg->length == 0 || cmd == CAN_CMD_PING){ // no commands or ping cmd -> return empty message (ping)
+        goto sendans;
+    }
+    outpdata[0] = cmd;
+    switch(cmd){
+        case CAN_CMD_ADC:
+            len = ADCget(outpdata);
+        break;
+        case CAN_CMD_BTNS:
+            if(msg->length == 2) outpdata[1] = msg->data[1]; // check only one button
+            else outpdata[1] = BTNSNO;
+            BTNSget(outpdata);
+            return;
+        break;
+        case CAN_CMD_LED:
+            if(setter && msg->length > 1) LEDSset(msg->data);
+            len = LEDSget(outpdata);
+        break;
+        case CAN_CMD_MCU:
+            len = MCUget(outpdata);
+        break;
+        case CAN_CMD_PWM:
+            if(setter && msg->length > 3) PWMset(msg->data);
+            len = PWMget(outpdata);
+        break;
+        case CAN_CMD_RELAY:
+            if(setter && msg->length > 1) Rset(msg->data);
+            len = Rget(outpdata);
+        break;
+        case CAN_CMD_TMS:
+            len = showTms(outpdata);
+        break;
+        default: // wrong command ->
+            outpdata[0] = CAN_CMD_ERRCMD;
+            len = 1;
+    }
+sendans:
+    while(CAN_BUSY == can_send(outpdata, len, OUTPID)) if(--N == 0) break;
+}

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

@@ -0,0 +1,47 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 CANPROTO_H__
+#define CANPROTO_H__
+
+#include "stm32f0.h"
+#include "can.h"
+
+// command without setter flag
+#define CANCMDMASK  (0x7f)
+
+typedef enum{
+    CAN_CMD_PING,   // ping (without setter)
+    CAN_CMD_RELAY,  // relay get/set
+    CAN_CMD_PWM,    // PWM get/set
+    CAN_CMD_ADC,    // get ADC (without setter)
+    CAN_CMD_MCU,    // MCU T and Vdd
+    CAN_CMD_LED,    // LEDs get/set
+    CAN_CMD_BTNS,   // get Buttons state (without setter)
+    CAN_CMD_TMS,    // get time from start (in ms)
+    CAN_CMD_ERRCMD, // wrong command
+    CAN_CMD_SETFLAG = 0x80 // command is setter
+} CAN_commands;
+
+// output messages identifier
+#define OUTPID  (CANID)
+
+void parseCANcommand(CAN_message *msg);
+
+#endif // CANPROTO_H__

F0:F030,F042,F072/usbcan_relay/custom_buttons.c

@@ -0,0 +1,67 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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/>.
+ */
+
+// custom standalone buttons reaction
+
+#include <stm32f0.h>
+#include "buttons.h"
+#include "custom_buttons.h"
+#include "hardware.h"
+
+
+/*
+ * check buttons, on long press of button:
+ * 1 - switch relay1
+ * 2 - switch relay2
+ * 3 - work with PWM out 0 (when btn3 pressed, btn1 increased & btn2 decreased PWM width)
+ *        press once btn2/3 to change PWM @1, hold to change @25 (repeat as many times as need)
+ */
+void custom_buttons_process(){
+    static uint32_t lastT = 0;
+    static uint8_t pwmval = 127;
+    static uint8_t trig = 0; // == 1 if given btn3 was off
+    if(lastUnsleep == lastT) return; // no buttons activity
+    lastT = lastUnsleep;
+    if(keyevt(3) == EVT_HOLD){ // PWM
+        if(keyevt(2) == EVT_HOLD){ // decrease PWM by 25
+            if(pwmval > 25) pwmval -= 25;
+            else pwmval = 0;
+        }else if(keyevt(2) == EVT_PRESS){ // decrease PWM by 1
+            if(pwmval > 0) --pwmval;
+        }else if(keyevt(1) == EVT_HOLD){ // increase PWM by 25
+            if(pwmval < 230) pwmval += 25;
+            else pwmval = 255;
+        }else if(keyevt(1) == EVT_PRESS){
+            if(pwmval < 254) ++pwmval;
+        }
+        if(trig == 0){ // first hold after release
+            if(TIM1->CCR1) TIM1->CCR1 = 0; // turn off if was ON
+            else{
+                TIM1->CCR1 = pwmval;
+                trig = 1;
+            }
+        }else TIM1->CCR1 = pwmval;
+        return;
+    }else trig = 0;
+    if(keyevt(1) == EVT_HOLD){ // relay1
+        Relay_TGL(0);
+    }
+    if(keyevt(2) == EVT_HOLD){ // relay2
+        Relay_TGL(1);
+    }
+}

F0:F030,F042,F072/usbcan_relay/custom_buttons.h

@@ -0,0 +1,25 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 CUSTOM_BUTTONS_H__
+#define CUSTOM_BUTTONS_H__
+
+void custom_buttons_process();
+
+#endif // CUSTOM_BUTTONS_H__

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

@@ -0,0 +1,148 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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"
+#include "can.h"
+
+uint16_t CANID = 0xFFFF; // self CAN ID (read @ init)
+
+// LEDS: 0 - PB12, 1 - PB13, 2 - PB14, 3 - PB15
+GPIO_TypeDef *LEDports[LEDSNO] = {GPIOB, GPIOB, GPIOB, GPIOB};
+const uint32_t LEDpins[LEDSNO] = {1<<12, 1<<13, 1<<14, 1<<15};
+// Buttons: PA2..PA5, pullup
+GPIO_TypeDef *BTNports[BTNSNO] = {GPIOA, GPIOA, GPIOA, GPIOA};
+const uint32_t BTNpins[BTNSNO] = {1<<2, 1<<3, 1<<4, 1<<5};
+// relays: PA0/1
+GPIO_TypeDef *R_ports[RelaysNO] = {GPIOA, GPIOA};
+const uint32_t R_pins[RelaysNO] = {1<<0, 1<<1};
+
+
+void gpio_setup(void){
+    RCC->AHBENR |= RCC_AHBENR_GPIOAEN | RCC_AHBENR_GPIOBEN;
+    // Set LEDS (PB12..15) as output, ADDR (PB0..7) - pullup inputs
+    // WARNING! All code here is hardcore!
+    pin_set(GPIOB, 0xf<<12); // clear LEDs
+    GPIOB->MODER = GPIO_MODER_MODER12_O | GPIO_MODER_MODER13_O | GPIO_MODER_MODER14_O | GPIO_MODER_MODER15_O;
+    GPIOB->PUPDR = GPIO_PUPDR0_PU | GPIO_PUPDR1_PU | GPIO_PUPDR2_PU | GPIO_PUPDR3_PU | GPIO_PUPDR4_PU |
+                   GPIO_PUPDR5_PU | GPIO_PUPDR6_PU | GPIO_PUPDR7_PU;
+    // relays (PA0..1) as outputs, buttons (PA2..5) as pullup inputs
+    // PA6,7 - ADC IN, PA8..10 - PWM @ TIM1
+    GPIOA->MODER = GPIO_MODER_MODER0_O | GPIO_MODER_MODER1_O | GPIO_MODER_MODER6_AI | GPIO_MODER_MODER7_AI |
+                   GPIO_MODER_MODER8_AF | GPIO_MODER_MODER9_AF | GPIO_MODER_MODER10_AF;
+    GPIOA->PUPDR = GPIO_PUPDR2_PU | GPIO_PUPDR3_PU | GPIO_PUPDR4_PU | GPIO_PUPDR5_PU;
+    CANID = (~READ_INV_CAN_ADDR()) & CAN_INV_ID_MASK;
+    // alternate functions @TIM1 PWM (AF2), PA8..10
+    GPIOA->AFR[1] = (2 << (0*4)) | (2 << (1*4)) | (2 << (2*4));
+}
+
+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) */
+}
+
+void tim1_setup(){
+    // TIM1 channels 1..3 - PWM output
+    RCC->APB2ENR |= RCC_APB2ENR_TIM1EN; // enable clocking
+    TIM1->PSC = 9; // F=48/10 = 4.8MHz
+    TIM1->ARR = 255; // PWM frequency = 4800/256 = 18.75kHz
+    // PWM mode 1 (OCxM = 110), preload enable
+    TIM1->CCMR1 =   TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1PE |
+                    TIM_CCMR1_OC2M_2 | TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2PE;
+    TIM1->CCMR2 =   TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3PE;
+    TIM1->CCER = TIM_CCER_CC1E | TIM_CCER_CC2E | TIM_CCER_CC3E; // active high (CC1P=0), enable outputs
+    TIM1->BDTR |= TIM_BDTR_MOE; // enable main output
+    TIM1->CR1 |= TIM_CR1_CEN; // enable timer
+    TIM1->EGR |= TIM_EGR_UG; // force update generation
+}
+
+// pause in milliseconds for some purposes
+void pause_ms(uint32_t pause){
+    uint32_t Tnxt = Tms + pause;
+    while(Tms < Tnxt) nop();
+}
+
+
+#ifdef EBUG
+void Jump2Boot(){
+    __disable_irq();
+    IWDG->KR = IWDG_REFRESH;
+    void (*SysMemBootJump)(void);
+    volatile uint32_t addr = SystemMem;
+    // 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  |
+#ifdef STM32F072xB
+            RCC_APB1RSTR_TIM7RST   | RCC_APB1RSTR_TIM6RST |
+#endif
+                    RCC_APB1RSTR_TIM3RST   | RCC_APB1RSTR_TIM2RST;
+    RCC->APB2RSTR = RCC_APB2RSTR_DBGMCURST | RCC_APB2RSTR_TIM17RST | RCC_APB2RSTR_TIM16RST |
+#ifdef STM32F072xB
+            RCC_APB2RSTR_TIM15RST |
+#endif
+                    RCC_APB2RSTR_USART1RST | RCC_APB2RSTR_SPI1RST  | RCC_APB2RSTR_TIM1RST  | RCC_APB2RSTR_ADCRST   | RCC_APB2RSTR_SYSCFGRST;
+    RCC->AHBRSTR = 0;
+    RCC->APB1RSTR = 0;
+    RCC->APB2RSTR = 0;
+    // enable SYSCFG clocking
+    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
+    __DSB();
+    // remap system flash 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));
+    IWDG->KR = IWDG_REFRESH;
+    // due to "empty check" mechanism, STM32F042 can jump to bootloader only with empty first 4 bytes of user code
+    while ((FLASH->SR & FLASH_SR_BSY) != 0){}
+    FLASH->SR = FLASH_SR_EOP | FLASH_SR_PGERR | FLASH_SR_WRPRTERR;
+    if ((FLASH->CR & FLASH_CR_LOCK) != 0){
+        FLASH->KEYR = FLASH_KEY1;
+        FLASH->KEYR = FLASH_KEY2;
+    }
+    FLASH->CR |= FLASH_CR_PER;
+    FLASH->AR = 0x08000000; // erase zero's page
+    FLASH->CR |= FLASH_CR_STRT;
+    while(!(FLASH->SR & FLASH_SR_EOP));
+    FLASH->SR |= FLASH_SR_EOP;
+    FLASH->CR &= ~FLASH_CR_PER;
+    // jump to bootloader (don't work :( )
+    SysMemBootJump();
+}
+#endif

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

@@ -0,0 +1,89 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 __HARDWARE_H__
+#define __HARDWARE_H__
+
+#include <stm32f0.h>
+
+// default CAN bus speed in kbaud
+#define DEFAULT_CAN_SPEED       (250)
+
+#define SYSMEM03x 0x1FFFEC00
+#define SYSMEM04x 0x1FFFC400
+#define SYSMEM05x 0x1FFFEC00
+#define SYSMEM07x 0x1FFFC800
+#define SYSMEM09x 0x1FFFD800
+// define SystemMem to other in MAKEFILE
+#ifndef SystemMem
+#define SystemMem SYSMEM04x
+#endif
+
+#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 amount
+#define LEDSNO      (4)
+// LEDs ports & pins
+extern GPIO_TypeDef *LEDports[LEDSNO];
+extern const uint32_t LEDpins[LEDSNO];
+// LEDS: 0 - PB12, 1 - PB13, 2 - PB14, 3 - PB15
+#define LED_toggle(x)   do{pin_toggle(LEDports[x], LEDpins[x]);}while(0)
+#define LED_on(x)       do{pin_clear(LEDports[x], LEDpins[x]);}while(0)
+#define LED_off(x)      do{pin_set(LEDports[x], LEDpins[x]);}while(0)
+#define LED_chk(x)      ((LEDports[x]->IDR & LEDpins[x]) ? 0 : 1)
+
+#define RelaysNO    (2)
+extern GPIO_TypeDef *R_ports[RelaysNO];
+extern const uint32_t R_pins[RelaysNO];
+#define Relay_ON(x)     do{pin_set(R_ports[x], R_pins[x]);}while(0)
+#define Relay_OFF(x)    do{pin_clear(R_ports[x], R_pins[x]);}while(0)
+#define Relay_TGL(x)    do{pin_toggle(R_ports[x], R_pins[x]);}while(0)
+#define Relay_chk(x)    (pin_read(R_ports[x], R_pins[x]))
+
+// Buttons amount
+#define BTNSNO      (4)
+// Buttons ports & pins
+extern GPIO_TypeDef *BTNports[BTNSNO];
+extern const uint32_t BTNpins[BTNSNO];
+// state 1 - pressed, 0 - released
+#define BTN_state(x)    ((BTNports[x]->IDR & BTNpins[x]) ? 0 : 1)
+
+// mask for PB0..7
+#define CAN_INV_ID_MASK (0xff)
+// CAN address - PB0..7
+#define READ_INV_CAN_ADDR()     (GPIOB->IDR & 0xff)
+
+extern uint16_t CANID; // self CAN ID (read @ init)
+
+extern volatile uint32_t Tms;
+
+void gpio_setup();
+void iwdg_setup();
+void tim1_setup();
+void pause_ms(uint32_t pause);
+#ifdef EBUG
+void Jump2Boot();
+#endif
+
+#endif // __HARDWARE_H__

F0:F030,F042,F072/usbcan_relay/kicad/elements.lib

@@ -0,0 +1,210 @@
+EESchema-LIBRARY Version 2.4
+#encoding utf-8
+#
+# 74HC4051
+#
+DEF 74HC4051 U 0 10 Y Y 1 F N
+F0 "U" 0 0 50 H V C CNN
+F1 "74HC4051" 0 -150 50 H V C CNN
+F2 "" 0 0 50 H V C CNN
+F3 "" 0 0 50 H V C CNN
+$FPLIST
+ SO16
+ TSSOP16
+ SSOP16
+ DHVQFN16
+$ENDFPLIST
+DRAW
+S -400 450 400 -450 0 1 0 N
+X Y4 1 700 -50 300 L 50 50 1 1 B
+X S1 10 -700 250 300 R 50 50 1 1 I
+X S0 11 -700 350 300 R 50 50 1 1 I
+X Y3 12 700 50 300 L 50 50 1 1 B
+X Y0 13 700 350 300 L 50 50 1 1 B
+X Y1 14 700 250 300 L 50 50 1 1 B
+X Y2 15 700 150 300 L 50 50 1 1 B
+X VCC 16 -700 -100 300 R 50 50 1 1 W
+X Y6 2 700 -250 300 L 50 50 1 1 B
+X Z 3 0 -750 300 U 50 50 1 1 B
+X Y7 4 700 -350 300 L 50 50 1 1 B
+X Y5 5 700 -150 300 L 50 50 1 1 B
+X ~E 6 -700 -350 300 R 50 50 1 1 I I
+X VEE 7 -700 0 300 R 50 50 1 1 W
+X GND 8 -700 -200 300 R 50 50 1 1 W
+X S2 9 -700 150 300 R 50 50 1 1 I
+ENDDRAW
+ENDDEF
+#
+# B0x0xS-1W
+#
+DEF B0x0xS-1W Q? 0 40 Y Y 1 F N
+F0 "Q?" 0 250 50 H V C CNN
+F1 "B0x0xS-1W" 0 -250 50 H V C CNN
+F2 "my_footprints:B0x0xS" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+ALIAS B0305S B0505S
+$FPLIST
+ b0x0xs
+$ENDFPLIST
+DRAW
+S -200 200 200 -200 0 1 0 N
+X GND 1 -400 -100 200 R 50 50 1 1 W
+X Vin 2 -400 100 200 R 50 50 1 1 W
+X 0V 3 400 -100 200 L 50 50 1 1 w
+X +Vo 4 400 100 200 L 50 50 1 1 w
+ENDDRAW
+ENDDEF
+#
+# D_Schottky_x2_ACom_AKK
+#
+DEF D_Schottky_x2_ACom_AKK D 0 30 Y N 1 F N
+F0 "D" 50 -100 50 H V C CNN
+F1 "D_Schottky_x2_ACom_AKK" 0 100 50 H V C CNN
+F2 "" 0 0 50 H V C CNN
+F3 "" 0 0 50 H V C CNN
+DRAW
+P 2 0 1 0 -140 0 150 0 N
+P 2 0 1 0 0 0 0 -100 N
+P 3 0 1 8 -150 50 -150 -50 -150 -50 N
+P 3 0 1 8 150 50 150 -50 150 -50 N
+P 4 0 1 8 -150 50 -170 50 -170 40 -170 40 N
+P 4 0 1 8 150 -50 170 -50 170 -40 170 -40 N
+P 4 0 1 8 150 50 130 50 130 40 130 40 N
+P 5 0 1 8 -130 -40 -130 -50 -150 -50 -150 -50 -150 -50 N
+P 6 0 1 8 -50 -50 -150 0 -50 50 -50 -50 -50 -50 -50 -50 N
+P 6 0 1 8 50 50 150 0 50 -50 50 50 50 50 50 50 N
+X A 1 0 -200 100 U 50 50 0 1 P
+X K 2 -300 0 150 R 50 50 0 1 P
+X K 3 300 0 150 L 50 50 0 1 P
+ENDDRAW
+ENDDEF
+#
+# LM1117-ADJ
+#
+DEF LM1117-ADJ U 0 30 Y Y 1 F N
+F0 "U" 100 -250 50 H V C CNN
+F1 "LM1117-ADJ" 0 250 50 H V C CNN
+F2 "" 0 0 50 H V C CNN
+F3 "" 0 0 50 H V C CNN
+ALIAS LM1117-1.8 LM1117-2.5 LM1117-3.3 LM1117-5.0
+$FPLIST
+ SOT-223*
+ TO-263*
+ TO-252*
+$ENDFPLIST
+DRAW
+S -200 -200 200 200 0 1 10 f
+X GND/ADJ 1 0 -300 100 U 50 50 1 1 W
+X VO 2 300 0 100 L 50 50 1 1 w
+X VI 3 -300 0 100 R 50 50 1 1 W
+ENDDRAW
+ENDDEF
+#
+# PESD1CAN
+#
+DEF PESD1CAN D 0 30 Y N 1 F N
+F0 "D" 0 -350 50 H V C CNN
+F1 "PESD1CAN" 50 150 50 H V C CNN
+F2 "" 0 0 50 H V C CNN
+F3 "" 0 0 50 H V C CNN
+$FPLIST
+ SOT23
+$ENDFPLIST
+DRAW
+S -200 100 300 -300 0 1 0 N
+P 2 0 1 0 -140 -200 150 -200 N
+P 2 0 1 0 -140 0 150 0 N
+P 3 0 1 8 -150 -150 -150 -250 -150 -250 N
+P 3 0 1 8 -150 50 -150 -50 -150 -50 N
+P 3 0 1 8 150 -150 150 -250 150 -250 N
+P 3 0 1 8 150 50 150 -50 150 -50 N
+P 4 0 1 8 -150 -150 -170 -150 -170 -160 -170 -160 N
+P 4 0 1 8 -150 50 -170 50 -170 40 -170 40 N
+P 4 0 1 8 150 -250 170 -250 170 -240 170 -240 N
+P 4 0 1 8 150 -150 130 -150 130 -160 130 -160 N
+P 4 0 1 8 150 -50 170 -50 170 -40 170 -40 N
+P 4 0 1 0 150 0 250 0 250 -200 150 -200 N
+P 4 0 1 8 150 50 130 50 130 40 130 40 N
+P 5 0 1 8 -130 -240 -130 -250 -150 -250 -150 -250 -150 -250 N
+P 5 0 1 8 -130 -40 -130 -50 -150 -50 -150 -50 -150 -50 N
+P 6 0 1 8 -50 -250 -150 -200 -50 -150 -50 -250 -50 -250 -50 -250 N
+P 6 0 1 8 -50 -50 -150 0 -50 50 -50 -50 -50 -50 -50 -50 N
+P 6 0 1 8 50 -150 150 -200 50 -250 50 -150 50 -150 50 -150 N
+P 6 0 1 8 50 50 150 0 50 -50 50 50 50 50 50 50 N
+X K 1 -300 0 150 R 50 50 0 1 P
+X K 2 -300 -200 150 R 50 50 0 1 P
+X O 3 400 -100 150 L 50 50 0 1 P
+ENDDRAW
+ENDDEF
+#
+# TPS2051
+#
+DEF TPS2051 U 0 40 Y Y 1 F N
+F0 "U" 0 -300 60 H V C CNN
+F1 "TPS2051" 0 300 60 H V C CNN
+F2 "" 0 0 60 H I C CNN
+F3 "" 0 0 60 H I C CNN
+DRAW
+S -250 250 250 -250 0 1 0 N
+X GND 1 -450 150 200 R 50 50 1 1 W
+X IN 2 -450 50 200 R 50 50 1 1 W
+X IN 3 -450 -50 200 R 50 50 1 1 P
+X EN 4 -450 -150 200 R 50 50 1 1 I
+X ~OC 5 450 -150 200 L 50 50 1 1 O
+X OUT 6 450 -50 200 L 50 50 1 1 P
+X OUT 7 450 50 200 L 50 50 1 1 P
+X OUT 8 450 150 200 L 50 50 1 1 w
+ENDDRAW
+ENDDEF
+#
+# USB6B1
+#
+DEF USB6B1 D 0 30 Y N 1 F N
+F0 "D" 0 -450 50 H V C CNN
+F1 "USB6B1" 0 400 50 H V C CNN
+F2 "" 200 -100 50 V V C CNN
+F3 "" 200 -100 50 V V C CNN
+$FPLIST
+ SO8
+$ENDFPLIST
+DRAW
+C -150 -300 7 0 1 0 N
+C -150 100 7 0 1 0 N
+C -150 300 7 0 1 0 N
+C 0 -300 7 0 1 0 N
+C 0 -100 7 0 1 0 N
+C 0 300 7 0 1 0 N
+C 200 -300 7 0 1 0 N
+C 200 300 7 0 1 0 N
+S -300 -100 300 -100 0 1 0 N
+S -300 300 300 300 0 1 0 N
+S -200 -150 -100 -150 0 1 0 N
+S -200 250 -100 250 0 1 0 N
+S -150 300 -150 -300 0 1 0 N
+S -50 -150 50 -150 0 1 0 N
+S -50 250 50 250 0 1 0 N
+S 0 300 0 -300 0 1 0 N
+S 200 300 200 -300 0 1 0 N
+S 300 -300 -300 -300 0 1 0 N
+S 300 100 -300 100 0 1 0 N
+P 3 0 1 8 150 50 250 50 250 50 N
+P 4 0 1 8 150 50 150 30 160 30 160 30 N
+P 4 0 1 8 250 50 250 70 240 70 240 70 N
+P 5 0 1 0 -250 350 300 350 300 -350 -250 -350 -250 350 N
+P 6 0 1 8 -200 -250 -150 -150 -100 -250 -200 -250 -200 -250 -200 -250 N
+P 6 0 1 8 -200 150 -150 250 -100 150 -200 150 -200 150 -200 150 N
+P 6 0 1 8 -50 -250 0 -150 50 -250 -50 -250 -50 -250 -50 -250 N
+P 6 0 1 8 -50 150 0 250 50 150 -50 150 -50 150 -50 150 N
+P 6 0 1 8 150 -50 200 50 250 -50 150 -50 150 -50 150 -50 N
+X VCC 1 -500 300 200 R 50 50 1 1 P
+X I/O1 2 -500 100 200 R 50 50 1 1 P
+X I/O2 3 -500 -100 200 R 50 50 1 1 P
+X GND 4 -500 -300 200 R 50 50 1 1 P
+X GND 5 500 -300 200 L 50 50 1 1 P
+X I/O2 6 500 -100 200 L 50 50 1 1 P
+X I/O1 7 500 100 200 L 50 50 1 1 P
+X VCC 8 500 300 200 L 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+#End Library

F0:F030,F042,F072/usbcan_relay/kicad/fp-lib-table

@@ -0,0 +1,7 @@
+(fp_lib_table
+  (lib (name my_footprints)(type KiCad)(uri "$(KIPRJMOD)/my_footprints.pretty")(options "")(descr ""))
+  (lib (name Connector_Dsub)(type KiCad)(uri ${KISYSMOD}/Connector_Dsub.pretty)(options "")(descr ""))
+  (lib (name Inductor_SMD)(type KiCad)(uri ${KISYSMOD}/Inductor_SMD.pretty)(options "")(descr ""))
+  (lib (name Inductor_THT)(type KiCad)(uri ${KISYSMOD}/Inductor_THT.pretty)(options "")(descr ""))
+  (lib (name Relay_THT)(type KiCad)(uri ${KISYSMOD}/Relay_THT.pretty)(options "")(descr ""))
+)

F0:F030,F042,F072/usbcan_relay/kicad/my_footprints.pretty/B0x0xS.kicad_mod

@@ -0,0 +1,18 @@
+(module B0x0xS (layer F.Cu) (tedit 5EC4EFC6)
+  (fp_text reference REF** (at 0.127 2.286) (layer F.SilkS)
+    (effects (font (size 1 1) (thickness 0.15)))
+  )
+  (fp_text value B0x0xS (at 0 -3.048) (layer F.Fab)
+    (effects (font (size 1 1) (thickness 0.15)))
+  )
+  (fp_line (start -5.8 0.9) (end 5.8 0.9) (layer F.SilkS) (width 0.12))
+  (fp_line (start -5.8 -5.1) (end 5.8 -5.1) (layer F.SilkS) (width 0.12))
+  (fp_line (start -5.8 -5.1) (end -5.8 0.9) (layer F.SilkS) (width 0.12))
+  (fp_line (start 5.8 -5.1) (end 5.8 0.9) (layer F.SilkS) (width 0.12))
+  (fp_line (start -0.381 -5.334) (end -0.381 1.27) (layer F.SilkS) (width 0.15))
+  (fp_line (start 0.381 1.27) (end 0.381 -5.334) (layer F.SilkS) (width 0.15))
+  (pad 1 thru_hole circle (at -3.81 0) (size 1.5 1.5) (drill 0.8) (layers *.Cu *.Mask))
+  (pad 2 thru_hole circle (at -1.27 0) (size 1.5 1.5) (drill 0.8) (layers *.Cu *.Mask))
+  (pad 3 thru_hole circle (at 1.27 0) (size 1.5 1.5) (drill 0.8) (layers *.Cu *.Mask))
+  (pad 4 thru_hole circle (at 3.81 0) (size 1.5 1.5) (drill 0.8) (layers *.Cu *.Mask))
+)

F0:F030,F042,F072/usbcan_relay/kicad/my_footprints.pretty/Hole_3mm.kicad_mod

@@ -0,0 +1,9 @@
+(module Hole_3mm (layer F.Cu) (tedit 5913F6E4)
+  (fp_text reference REF** (at 0 3.81) (layer F.SilkS) hide
+    (effects (font (size 1 1) (thickness 0.15)))
+  )
+  (fp_text value Hole_3mm (at 0 -7.62) (layer F.Fab) hide
+    (effects (font (size 1 1) (thickness 0.15)))
+  )
+  (pad 1 thru_hole circle (at 0 0) (size 5 5) (drill 3) (layers *.Cu *.Mask))
+)

F0:F030,F042,F072/usbcan_relay/kicad/stm32 (2).csv

@@ -0,0 +1,151 @@
+"Source:","/home/eddy/Docs/SAO/ELECTRONICS/STM32/F0-srcs/CANUSB+relays/kicad/stm32.sch"
+"Date:","óÒ 16 ÉÀÎ 2021 11:40:04"
+"Tool:","Eeschema 5.1.7"
+"Generator:","/usr/local/share/kicad/plugins/bom_csv_grouped_by_value.py"
+"Component Count:","93"
+
+"Individual Components:"
+
+"Item","Qty","Reference(s)","Value","LibPart","Footprint","Datasheet","Manufacturer"
+"","","C1","1","stm32-rescue:C","Capacitor_SMD:C_0805_2012Metric_Pad1.15x1.40mm_HandSolder","",""
+"","","C2","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C3","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C4","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C5","1","stm32-rescue:C","Capacitor_SMD:C_0805_2012Metric_Pad1.15x1.40mm_HandSolder","",""
+"","","C6","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C7","0.1","Device:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","C8","0.1","Device:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","C9","0.1","Device:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","C10","47u 16V","Device:CP","Capacitor_Tantalum_SMD:CP_EIA-6032-28_Kemet-C_Pad2.25x2.35mm_HandSolder","~",""
+"","","C11","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C12","47u 10V","stm32-rescue:CP","Capacitor_Tantalum_SMD:CP_EIA-1608-08_AVX-J_Pad1.25x1.05mm_HandSolder","",""
+"","","C13","47u 10V","Device:CP","Capacitor_Tantalum_SMD:CP_EIA-1608-08_AVX-J_Pad1.25x1.05mm_HandSolder","~",""
+"","","C14","0.1","Device:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","C15","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","D1","PESD1CAN","elements:PESD1CAN","TO_SOT_Packages_SMD:SOT-23","",""
+"","","D2","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D3","USB6B1","elements:USB6B1","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"","","D4","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D5","MM3Z7V5","Device:D_Zener","Diode_SMD:D_0805_2012Metric_Pad1.15x1.40mm_HandSolder","~",""
+"","","D6","CESD3v3","Device:D","Diode_SMD:D_SOD-523","~",""
+"","","D7","CESD3v3","Device:D","Diode_SMD:D_SOD-523","~",""
+"","","D8","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D9","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D10","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D11","1N5822","Device:D","Diode_THT:D_DO-201_P12.70mm_Horizontal","~",""
+"","","J1","Conn_01x01_Female","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J2","Conn_01x01_Female","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J3","Conn_01x01_Female","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J4","Conn_01x01_Female","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J5","Conn_01x01_Female","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J6","Conn_01x01_Female","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J7","01x05","Connector:Conn_01x05_Male","Connector_PinHeader_2.54mm:PinHeader_1x05_P2.54mm_Vertical","~",""
+"","","J8","Connector_Generic:Conn_02x04_Odd_Even","Connector_Generic:Conn_02x04_Odd_Even","Connector_PinHeader_2.54mm:PinHeader_2x04_P2.54mm_Vertical","~",""
+"","","J9","Conn_01x02_Female","Connector:Conn_01x02_Female","Connector_PinSocket_2.54mm:PinSocket_1x02_P2.54mm_Vertical","~",""
+"","","J10","Screw_Terminal_01x02","Connector:Screw_Terminal_01x02","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-3-2-5.08_1x02_P5.08mm_Horizontal","~",""
+"","","J11","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"","","J12","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"","","J13","USB_B","Connector:USB_B","Connectors_USB:USB_B_OST_USB-B1HSxx_Horizontal"," ~",""
+"","","J14","DB9_Female","Connector:DB9_Female","Connector_Dsub:DSUB-9_Female_Horizontal_P2.77x2.84mm_EdgePinOffset7.70mm_Housed_MountingHolesOffset9.12mm"," ~",""
+"","","J15","01x03","Connector:Conn_01x03_Male","Connector_PinSocket_2.54mm:PinSocket_1x03_P2.54mm_Vertical","~",""
+"","","J16","Conn_01x02_Female","Connector:Conn_01x02_Female","Connector_PinSocket_2.54mm:PinSocket_1x02_P2.54mm_Vertical","~",""
+"","","J17","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"","","J18","01x05","Connector:Conn_01x05_Male","Connector_PinSocket_2.54mm:PinSocket_1x05_P2.54mm_Vertical","~",""
+"","","JP1","NON-ISOL","Device:Jumper","Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P5.08mm_Vertical","~",""
+"","","K1","G5LE-1","Relay:G5LE-1","Relay_THT:Relay_SPDT_Omron-G5LE-1","http://www.omron.com/ecb/products/pdf/en-g5le.pdf",""
+"","","K2","G5LE-1","Relay:G5LE-1","Relay_THT:Relay_SPDT_Omron-G5LE-1","http://www.omron.com/ecb/products/pdf/en-g5le.pdf",""
+"","","L1","100u","Device:L","Inductor_SMD:L_12x12mm_H4.5mm","~",""
+"","","P1","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P2","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P3","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P4","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","Q1","B0505S","elements:B0505S","my_footprints:B0x0xS","",""
+"","","Q2","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q3","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q4","AO3407","Device:Q_PMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q5","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q6","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q7","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","R1","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R2","4k7","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","R3","22","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R4","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R5","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R6","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R7","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R8","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R9","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R10","22","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","R11","22","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","R12","2k2","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R13","120","stm32-rescue:R","Resistor_SMD:R_1210_3225Metric_Pad1.42x2.65mm_HandSolder","",""
+"","","R14","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R15","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R16","2k2","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R17","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R18","47k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R19","15k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R20","15k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R21","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R22","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R23","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R24","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R25","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R26","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R27","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","SW1","SW_DIP_x08","Switch:SW_DIP_x08","Button_Switch_THT:SW_DIP_SPSTx08_Slide_9.78x22.5mm_W7.62mm_P2.54mm","~",""
+"","","SW2","SW_DIP_x01","Switch:SW_DIP_x01","Button_Switch_THT:SW_DIP_SPSTx01_Slide_6.7x4.1mm_W7.62mm_P2.54mm_LowProfile","~",""
+"","","U1","MCP2551-I/SN","stm32-rescue:MCP2551-I_SN","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"","","U2","ISO1050DUB","Interface_CAN_LIN:ISO1050DUB","Package_SO:SOP-8_6.62x9.15mm_P2.54mm","http://www.ti.com/lit/ds/symlink/iso1050.pdf",""
+"","","U3","STM32F072C8Tx","MCU_ST_STM32F0:STM32F072C8Tx","Package_QFP:LQFP-48_7x7mm_P0.5mm","http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00090510.pdf",""
+"","","U4","LM2576","vreg:LM2576","TO_SOT_Packages_THT:TO-220-5_P3.4x3.7mm_StaggerEven_Lead3.8mm_Vertical","","Texas Instruments"
+"","","U5","LM1117-3.3","Regulator_Linear:LM1117-3.3","TO_SOT_Packages_SMD:SOT-223-3_TabPin2","http://www.ti.com/lit/ds/symlink/lm1117.pdf",""
+
+
+
+"Collated Components:"
+
+"Item","Qty","Reference(s)","Value","LibPart","Footprint","Datasheet","Manufacturer"
+"1","2","C1, C5","1","stm32-rescue:C","Capacitor_SMD:C_0805_2012Metric_Pad1.15x1.40mm_HandSolder","",""
+"2","10","C2, C3, C4, C6, C7, C8, C9, C11, C14, C15","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"3","1","C10","47u 16V","Device:CP","Capacitor_Tantalum_SMD:CP_EIA-6032-28_Kemet-C_Pad2.25x2.35mm_HandSolder","~",""
+"4","2","C12, C13","47u 10V","Device:CP","Capacitor_Tantalum_SMD:CP_EIA-1608-08_AVX-J_Pad1.25x1.05mm_HandSolder","~",""
+"5","1","D1","PESD1CAN","elements:PESD1CAN","TO_SOT_Packages_SMD:SOT-23","",""
+"6","5","D2, D4, D8, D9, D10","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"7","1","D3","USB6B1","elements:USB6B1","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"8","1","D5","MM3Z7V5","Device:D_Zener","Diode_SMD:D_0805_2012Metric_Pad1.15x1.40mm_HandSolder","~",""
+"9","2","D6, D7","CESD3v3","Device:D","Diode_SMD:D_SOD-523","~",""
+"10","1","D11","1N5822","Device:D","Diode_THT:D_DO-201_P12.70mm_Horizontal","~",""
+"11","6","J1, J2, J3, J4, J5, J6","Conn_01x01_Female","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"12","1","J7","01x05","Connector:Conn_01x05_Male","Connector_PinHeader_2.54mm:PinHeader_1x05_P2.54mm_Vertical","~",""
+"13","1","J8","Connector_Generic:Conn_02x04_Odd_Even","Connector_Generic:Conn_02x04_Odd_Even","Connector_PinHeader_2.54mm:PinHeader_2x04_P2.54mm_Vertical","~",""
+"14","2","J9, J16","Conn_01x02_Female","Connector:Conn_01x02_Female","Connector_PinSocket_2.54mm:PinSocket_1x02_P2.54mm_Vertical","~",""
+"15","1","J10","Screw_Terminal_01x02","Connector:Screw_Terminal_01x02","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-3-2-5.08_1x02_P5.08mm_Horizontal","~",""
+"16","3","J11, J12, J17","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"17","1","J13","USB_B","Connector:USB_B","Connectors_USB:USB_B_OST_USB-B1HSxx_Horizontal"," ~",""
+"18","1","J14","DB9_Female","Connector:DB9_Female","Connector_Dsub:DSUB-9_Female_Horizontal_P2.77x2.84mm_EdgePinOffset7.70mm_Housed_MountingHolesOffset9.12mm"," ~",""
+"19","1","J15","01x03","Connector:Conn_01x03_Male","Connector_PinSocket_2.54mm:PinSocket_1x03_P2.54mm_Vertical","~",""
+"20","1","J18","01x05","Connector:Conn_01x05_Male","Connector_PinSocket_2.54mm:PinSocket_1x05_P2.54mm_Vertical","~",""
+"21","1","JP1","NON-ISOL","Device:Jumper","Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P5.08mm_Vertical","~",""
+"22","2","K1, K2","G5LE-1","Relay:G5LE-1","Relay_THT:Relay_SPDT_Omron-G5LE-1","http://www.omron.com/ecb/products/pdf/en-g5le.pdf",""
+"23","1","L1","100u","Device:L","Inductor_SMD:L_12x12mm_H4.5mm","~",""
+"24","4","P1, P2, P3, P4","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"25","1","Q1","B0505S","elements:B0505S","my_footprints:B0x0xS","",""
+"26","5","Q2, Q3, Q5, Q6, Q7","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"27","1","Q4","AO3407","Device:Q_PMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"28","8","R1, R8, R14, R17, R21, R25, R26, R27","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"29","1","R2","4k7","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"30","3","R3, R10, R11","22","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"31","4","R4, R5, R6, R7","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"32","5","R9, R15, R22, R23, R24","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"33","2","R12, R16","2k2","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"34","1","R13","120","stm32-rescue:R","Resistor_SMD:R_1210_3225Metric_Pad1.42x2.65mm_HandSolder","",""
+"35","1","R18","47k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"36","2","R19, R20","15k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"37","1","SW1","SW_DIP_x08","Switch:SW_DIP_x08","Button_Switch_THT:SW_DIP_SPSTx08_Slide_9.78x22.5mm_W7.62mm_P2.54mm","~",""
+"38","1","SW2","SW_DIP_x01","Switch:SW_DIP_x01","Button_Switch_THT:SW_DIP_SPSTx01_Slide_6.7x4.1mm_W7.62mm_P2.54mm_LowProfile","~",""
+"39","1","U1","MCP2551-I/SN","stm32-rescue:MCP2551-I_SN","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"40","1","U2","ISO1050DUB","Interface_CAN_LIN:ISO1050DUB","Package_SO:SOP-8_6.62x9.15mm_P2.54mm","http://www.ti.com/lit/ds/symlink/iso1050.pdf",""
+"41","1","U3","STM32F072C8Tx","MCU_ST_STM32F0:STM32F072C8Tx","Package_QFP:LQFP-48_7x7mm_P0.5mm","http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00090510.pdf",""
+"42","1","U4","LM2576","vreg:LM2576","TO_SOT_Packages_THT:TO-220-5_P3.4x3.7mm_StaggerEven_Lead3.8mm_Vertical","","Texas Instruments"
+"43","1","U5","LM1117-3.3","Regulator_Linear:LM1117-3.3","TO_SOT_Packages_SMD:SOT-223-3_TabPin2","http://www.ti.com/lit/ds/symlink/lm1117.pdf",""

F0:F030,F042,F072/usbcan_relay/kicad/stm32-rescue.lib

@@ -0,0 +1,801 @@
+EESchema-LIBRARY Version 2.4
+#encoding utf-8
+#
+# +3.3V
+#
+DEF +3.3V #PWR 0 0 Y Y 1 F P
+F0 "#PWR" 0 -150 50 H I C CNN
+F1 "+3.3V" 0 140 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+P 2 0 1 0 -30 50 0 100 N
+P 2 0 1 0 0 0 0 100 N
+P 2 0 1 0 0 100 30 50 N
+X +3V3 1 0 0 0 U 50 50 1 1 W N
+ENDDRAW
+ENDDEF
+#
+# +5V
+#
+DEF +5V #PWR 0 0 Y Y 1 F P
+F0 "#PWR" 0 -150 50 H I C CNN
+F1 "+5V" 0 140 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+P 2 0 1 0 -30 50 0 100 N
+P 2 0 1 0 0 0 0 100 N
+P 2 0 1 0 0 100 30 50 N
+X +5V 1 0 0 0 U 50 50 1 1 W N
+ENDDRAW
+ENDDEF
+#
+# B0505S-elements
+#
+DEF B0505S-elements Q? 0 40 Y Y 1 F N
+F0 "Q?" 0 250 50 H V C CNN
+F1 "B0505S-elements" 0 -250 50 H V C CNN
+F2 "my_footprints:B0x0xS" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ b0x0xs
+$ENDFPLIST
+DRAW
+S -200 200 200 -200 0 1 0 N
+X GND 1 -400 -100 200 R 50 50 1 1 W
+X Vin 2 -400 100 200 R 50 50 1 1 W
+X 0V 3 400 -100 200 L 50 50 1 1 w
+X +Vo 4 400 100 200 L 50 50 1 1 w
+ENDDRAW
+ENDDEF
+#
+# C
+#
+DEF C C 0 10 N Y 1 F N
+F0 "C" 25 100 50 H V L CNN
+F1 "C" 25 -100 50 H V L CNN
+F2 "" 38 -150 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ C_*
+$ENDFPLIST
+DRAW
+P 2 0 1 20 -80 -30 80 -30 N
+P 2 0 1 20 -80 30 80 30 N
+X ~ 1 0 150 110 D 50 50 1 1 P
+X ~ 2 0 -150 110 U 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# CONN_01X01
+#
+DEF CONN_01X01 J 0 40 Y N 1 F N
+F0 "J" 0 100 50 H V C CNN
+F1 "CONN_01X01" 100 0 50 V V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ Pin_Header_Straight_1X*
+ Pin_Header_Angled_1X*
+ Socket_Strip_Straight_1X*
+ Socket_Strip_Angled_1X*
+$ENDFPLIST
+DRAW
+S -50 5 10 -5 0 1 0 N
+S -50 50 50 -50 0 1 0 N
+X P1 1 -200 0 150 R 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# CONN_01X03
+#
+DEF CONN_01X03 J 0 40 Y N 1 F N
+F0 "J" 0 200 50 H V C CNN
+F1 "CONN_01X03" 100 0 50 V V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ Pin_Header_Straight_1X*
+ Pin_Header_Angled_1X*
+ Socket_Strip_Straight_1X*
+ Socket_Strip_Angled_1X*
+$ENDFPLIST
+DRAW
+S -50 -95 10 -105 0 1 0 N
+S -50 5 10 -5 0 1 0 N
+S -50 105 10 95 0 1 0 N
+S -50 150 50 -150 0 1 0 N
+X P1 1 -200 100 150 R 50 50 1 1 P
+X P2 2 -200 0 150 R 50 50 1 1 P
+X P3 3 -200 -100 150 R 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# CONN_02X03
+#
+DEF CONN_02X03 J 0 1 Y N 1 F N
+F0 "J" 0 200 50 H V C CNN
+F1 "CONN_02X03" 0 -200 50 H V C CNN
+F2 "" 0 -1200 50 H I C CNN
+F3 "" 0 -1200 50 H I C CNN
+$FPLIST
+ Pin_Header_Straight_2X*
+ Pin_Header_Angled_2X*
+ Socket_Strip_Straight_2X*
+ Socket_Strip_Angled_2X*
+ IDC_Header_Straight_*
+$ENDFPLIST
+DRAW
+S -100 -95 -50 -105 0 1 0 N
+S -100 5 -50 -5 0 1 0 N
+S -100 105 -50 95 0 1 0 N
+S -100 150 100 -150 0 1 0 N
+S 50 -95 100 -105 0 1 0 N
+S 50 5 100 -5 0 1 0 N
+S 50 105 100 95 0 1 0 N
+X P1 1 -250 100 150 R 50 50 1 1 P
+X P2 2 250 100 150 L 50 50 1 1 P
+X P3 3 -250 0 150 R 50 50 1 1 P
+X P4 4 250 0 150 L 50 50 1 1 P
+X P5 5 -250 -100 150 R 50 50 1 1 P
+X P6 6 250 -100 150 L 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# CP
+#
+DEF CP C 0 10 N Y 1 F N
+F0 "C" 25 100 50 H V L CNN
+F1 "CP" 25 -100 50 H V L CNN
+F2 "" 38 -150 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ CP_*
+$ENDFPLIST
+DRAW
+S -90 20 -90 40 0 1 0 N
+S -90 20 90 20 0 1 0 N
+S 90 -20 -90 -40 0 1 0 F
+S 90 40 -90 40 0 1 0 N
+S 90 40 90 20 0 1 0 N
+P 2 0 1 0 -70 90 -30 90 N
+P 2 0 1 0 -50 110 -50 70 N
+X ~ 1 0 150 110 D 50 50 1 1 P
+X ~ 2 0 -150 110 U 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# Conn_01x01
+#
+DEF Conn_01x01 J 0 40 Y N 1 F N
+F0 "J" 0 100 50 H V C CNN
+F1 "Conn_01x01" 0 -100 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ Connector*:*_??x*mm*
+ Connector*:*1x??x*mm*
+ Pin?Header?Straight?1X*
+ Pin?Header?Angled?1X*
+ Socket?Strip?Straight?1X*
+ Socket?Strip?Angled?1X*
+$ENDFPLIST
+DRAW
+S -50 5 0 -5 1 1 6 N
+S -50 50 50 -50 1 1 10 f
+X Pin_1 1 -200 0 150 R 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# Conn_01x02
+#
+DEF Conn_01x02 J 0 40 Y N 1 F N
+F0 "J" 0 100 50 H V C CNN
+F1 "Conn_01x02" 0 -200 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ Connector*:*_??x*mm*
+ Connector*:*1x??x*mm*
+ Pin?Header?Straight?1X*
+ Pin?Header?Angled?1X*
+ Socket?Strip?Straight?1X*
+ Socket?Strip?Angled?1X*
+$ENDFPLIST
+DRAW
+S -50 -95 0 -105 1 1 6 N
+S -50 5 0 -5 1 1 6 N
+S -50 50 50 -150 1 1 10 f
+X Pin_1 1 -200 0 150 R 50 50 1 1 P
+X Pin_2 2 -200 -100 150 R 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# Conn_01x07
+#
+DEF Conn_01x07 J 0 40 Y N 1 F N
+F0 "J" 0 400 50 H V C CNN
+F1 "Conn_01x07" 0 -400 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ Connector*:*_??x*mm*
+ Connector*:*1x??x*mm*
+ Pin?Header?Straight?1X*
+ Pin?Header?Angled?1X*
+ Socket?Strip?Straight?1X*
+ Socket?Strip?Angled?1X*
+$ENDFPLIST
+DRAW
+S -50 -295 0 -305 1 1 6 N
+S -50 -195 0 -205 1 1 6 N
+S -50 -95 0 -105 1 1 6 N
+S -50 5 0 -5 1 1 6 N
+S -50 105 0 95 1 1 6 N
+S -50 205 0 195 1 1 6 N
+S -50 305 0 295 1 1 6 N
+S -50 350 50 -350 1 1 10 f
+X Pin_1 1 -200 300 150 R 50 50 1 1 P
+X Pin_2 2 -200 200 150 R 50 50 1 1 P
+X Pin_3 3 -200 100 150 R 50 50 1 1 P
+X Pin_4 4 -200 0 150 R 50 50 1 1 P
+X Pin_5 5 -200 -100 150 R 50 50 1 1 P
+X Pin_6 6 -200 -200 150 R 50 50 1 1 P
+X Pin_7 7 -200 -300 150 R 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# DB9_Female
+#
+DEF DB9_Female J 0 40 Y N 1 F N
+F0 "J" 0 550 50 H V C CNN
+F1 "DB9_Female" 0 -575 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ DB*F*
+$ENDFPLIST
+DRAW
+C -70 -400 30 0 1 0 N
+C -70 -200 30 0 1 0 N
+C -70 0 30 0 1 0 N
+C -70 200 30 0 1 0 N
+C -70 400 30 0 1 0 N
+C 50 -300 30 0 1 0 N
+C 50 -100 30 0 1 0 N
+C 50 100 30 0 1 0 N
+C 50 300 30 0 1 0 N
+P 2 0 1 0 -150 -400 -100 -400 N
+P 2 0 1 0 -150 -300 20 -300 N
+P 2 0 1 0 -150 -200 -100 -200 N
+P 2 0 1 0 -150 -100 20 -100 N
+P 2 0 1 0 -150 0 -100 0 N
+P 2 0 1 0 -150 100 20 100 N
+P 2 0 1 0 -150 200 -100 200 N
+P 2 0 1 0 -150 300 20 300 N
+P 2 0 1 0 -150 400 -100 400 N
+P 5 0 1 10 -150 525 -150 -525 150 -375 150 375 -150 525 f
+X 1 1 -300 400 150 R 50 50 1 1 P
+X 2 2 -300 200 150 R 50 50 1 1 P
+X 3 3 -300 0 150 R 50 50 1 1 P
+X 4 4 -300 -200 150 R 50 50 1 1 P
+X 5 5 -300 -400 150 R 50 50 1 1 P
+X 6 6 -300 300 150 R 50 50 1 1 P
+X 7 7 -300 100 150 R 50 50 1 1 P
+X 8 8 -300 -100 150 R 50 50 1 1 P
+X 9 9 -300 -300 150 R 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# DB9_Male
+#
+DEF DB9_Male J 0 40 Y N 1 F N
+F0 "J" 0 550 50 H V C CNN
+F1 "DB9_Male" 0 -575 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ DB*M*
+$ENDFPLIST
+DRAW
+C -70 -400 30 0 1 0 F
+C -70 -200 30 0 1 0 F
+C -70 0 30 0 1 0 F
+C -70 200 30 0 1 0 F
+C -70 400 30 0 1 0 F
+C 50 -300 30 0 1 0 F
+C 50 -100 30 0 1 0 F
+C 50 100 30 0 1 0 F
+C 50 300 30 0 1 0 F
+P 2 0 1 0 -150 -400 -100 -400 N
+P 2 0 1 0 -150 -300 20 -300 N
+P 2 0 1 0 -150 -200 -100 -200 N
+P 2 0 1 0 -150 -100 20 -100 N
+P 2 0 1 0 -150 0 -100 0 N
+P 2 0 1 0 -150 100 20 100 N
+P 2 0 1 0 -150 200 -100 200 N
+P 2 0 1 0 -150 300 20 300 N
+P 2 0 1 0 -150 400 -100 400 N
+P 5 0 1 10 -150 -525 -150 525 150 375 150 -375 -150 -525 f
+X 1 1 -300 -400 150 R 50 50 1 1 P
+X 2 2 -300 -200 150 R 50 50 1 1 P
+X 3 3 -300 0 150 R 50 50 1 1 P
+X 4 4 -300 200 150 R 50 50 1 1 P
+X 5 5 -300 400 150 R 50 50 1 1 P
+X 6 6 -300 -300 150 R 50 50 1 1 P
+X 7 7 -300 -100 150 R 50 50 1 1 P
+X 8 8 -300 100 150 R 50 50 1 1 P
+X 9 9 -300 300 150 R 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# D_Schottky
+#
+DEF D_Schottky D 0 40 N N 1 F N
+F0 "D" 0 100 50 H V C CNN
+F1 "D_Schottky" 0 -100 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ TO-???*
+ *SingleDiode
+ *_Diode_*
+ *SingleDiode*
+ D_*
+$ENDFPLIST
+DRAW
+P 2 0 1 0 50 0 -50 0 N
+P 4 0 1 8 50 50 50 -50 -50 0 50 50 N
+P 6 0 1 8 -75 25 -75 50 -50 50 -50 -50 -25 -50 -25 -25 N
+X K 1 -150 0 100 R 50 50 1 1 P
+X A 2 150 0 100 L 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# D_Zener
+#
+DEF D_Zener D 0 40 N N 1 F N
+F0 "D" 0 100 50 H V C CNN
+F1 "D_Zener" 0 -100 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ TO-???*
+ *SingleDiode
+ *_Diode_*
+ *SingleDiode*
+ D_*
+$ENDFPLIST
+DRAW
+P 2 0 1 0 50 0 -50 0 N
+P 3 0 1 8 -50 -50 -50 50 -30 50 N
+P 4 0 1 8 50 -50 50 50 -50 0 50 -50 N
+X K 1 -150 0 100 R 50 50 1 1 P
+X A 2 150 0 100 L 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# GND
+#
+DEF GND #PWR 0 0 Y Y 1 F P
+F0 "#PWR" 0 -250 50 H I C CNN
+F1 "GND" 0 -150 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+P 6 0 1 0 0 0 0 -50 50 -50 0 -100 -50 -50 0 -50 N
+X GND 1 0 0 0 D 50 50 1 1 W N
+ENDDRAW
+ENDDEF
+#
+# Jumper_NO_Small
+#
+DEF Jumper_NO_Small JP 0 30 N N 1 F N
+F0 "JP" 0 80 50 H V C CNN
+F1 "Jumper_NO_Small" 10 -60 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+C -40 0 20 0 1 0 N
+C 40 0 20 0 1 0 N
+X 1 1 -100 0 40 R 50 50 0 1 P
+X 2 2 100 0 40 L 50 50 0 1 P
+ENDDRAW
+ENDDEF
+#
+# LED-RESCUE-stm32
+#
+DEF LED-RESCUE-stm32 D 0 40 Y N 1 F N
+F0 "D" 0 100 50 H V C CNN
+F1 "LED-RESCUE-stm32" 0 -100 50 H V C CNN
+F2 "" 0 0 50 H V C CNN
+F3 "" 0 0 50 H V C CNN
+$FPLIST
+ LED*
+$ENDFPLIST
+DRAW
+P 2 0 1 8 -50 -50 -50 50 N
+P 2 0 1 0 -50 0 50 0 N
+P 4 0 1 8 50 -50 50 50 -50 0 50 -50 N
+P 5 0 1 0 -120 -30 -180 -90 -150 -90 -180 -90 -180 -60 N
+P 5 0 1 0 -70 -30 -130 -90 -100 -90 -130 -90 -130 -60 N
+X K 1 -150 0 100 R 50 50 1 1 P
+X A 2 150 0 100 L 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# LM1117-3.3-RESCUE-stm32
+#
+DEF LM1117-3.3-RESCUE-stm32 U 0 30 Y Y 1 F N
+F0 "U" 100 -250 50 H V C CNN
+F1 "LM1117-3.3-RESCUE-stm32" 0 250 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ SOT-223*
+ TO-263*
+ TO-252*
+$ENDFPLIST
+DRAW
+S -200 -200 200 200 0 1 10 f
+X GND/ADJ 1 0 -300 100 U 50 50 1 1 W
+X VO 2 300 50 100 L 50 50 1 1 P
+X VI 3 -300 0 100 R 50 50 1 1 W
+X VO 4 300 -50 100 L 50 50 1 1 w
+ENDDRAW
+ENDDEF
+#
+# MAX471-RESCUE-stm32
+#
+DEF MAX471-RESCUE-stm32 U 0 40 Y Y 1 F N
+F0 "U" -300 350 50 H V L CNN
+F1 "MAX471-RESCUE-stm32" -300 -350 50 H V L CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+S -300 300 300 -300 0 1 10 f
+X SHDN 1 -400 -100 100 R 50 50 1 1 I
+X RS+ 2 -400 200 100 R 50 50 1 1 W
+X RS+ 3 -400 100 100 R 50 50 1 1 P
+X GND 4 -400 -200 100 R 50 50 1 1 W
+X SIGN 5 400 -100 100 L 50 50 1 1 C
+X RS- 6 400 200 100 L 50 50 1 1 w
+X RS- 7 400 100 100 L 50 50 1 1 P
+X OUT 8 400 -200 100 L 50 50 1 1 O
+ENDDRAW
+ENDDEF
+#
+# MCP2551-I_SN
+#
+DEF MCP2551-I_SN U 0 40 Y Y 1 F N
+F0 "U" -400 350 50 H V L CNN
+F1 "MCP2551-I_SN" 100 350 50 H V L CNN
+F2 "Housings_SOIC:SOIC-8_3.9x4.9mm_Pitch1.27mm" 0 -500 50 H I C CIN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ SOIC*Pitch1.27mm*
+$ENDFPLIST
+DRAW
+S -400 300 400 -300 0 1 10 f
+X TXD 1 -500 200 100 R 50 50 1 1 I
+X VSS 2 0 -400 100 U 50 50 1 1 W
+X VDD 3 0 400 100 D 50 50 1 1 W
+X RXD 4 -500 100 100 R 50 50 1 1 O
+X Vref 5 -500 -100 100 R 50 50 1 1 w
+X CANL 6 500 -100 100 L 50 50 1 1 B
+X CANH 7 500 100 100 L 50 50 1 1 B
+X Rs 8 -500 -200 100 R 50 50 1 1 I
+ENDDRAW
+ENDDEF
+#
+# PESD1CAN-elements
+#
+DEF PESD1CAN-elements D 0 30 Y N 1 F N
+F0 "D" 0 -350 50 H V C CNN
+F1 "PESD1CAN-elements" 50 150 50 H V C CNN
+F2 "" 0 0 50 H V C CNN
+F3 "" 0 0 50 H V C CNN
+$FPLIST
+ SOT23
+$ENDFPLIST
+DRAW
+S -200 100 300 -300 0 1 0 N
+P 2 0 1 0 -140 -200 150 -200 N
+P 2 0 1 0 -140 0 150 0 N
+P 3 0 1 8 -150 -150 -150 -250 -150 -250 N
+P 3 0 1 8 -150 50 -150 -50 -150 -50 N
+P 3 0 1 8 150 -150 150 -250 150 -250 N
+P 3 0 1 8 150 50 150 -50 150 -50 N
+P 4 0 1 8 -150 -150 -170 -150 -170 -160 -170 -160 N
+P 4 0 1 8 -150 50 -170 50 -170 40 -170 40 N
+P 4 0 1 8 150 -250 170 -250 170 -240 170 -240 N
+P 4 0 1 8 150 -150 130 -150 130 -160 130 -160 N
+P 4 0 1 8 150 -50 170 -50 170 -40 170 -40 N
+P 4 0 1 0 150 0 250 0 250 -200 150 -200 N
+P 4 0 1 8 150 50 130 50 130 40 130 40 N
+P 5 0 1 8 -130 -240 -130 -250 -150 -250 -150 -250 -150 -250 N
+P 5 0 1 8 -130 -40 -130 -50 -150 -50 -150 -50 -150 -50 N
+P 6 0 1 8 -50 -250 -150 -200 -50 -150 -50 -250 -50 -250 -50 -250 N
+P 6 0 1 8 -50 -50 -150 0 -50 50 -50 -50 -50 -50 -50 -50 N
+P 6 0 1 8 50 -150 150 -200 50 -250 50 -150 50 -150 50 -150 N
+P 6 0 1 8 50 50 150 0 50 -50 50 50 50 50 50 50 N
+X K 1 -300 0 150 R 50 50 0 1 P
+X K 2 -300 -200 150 R 50 50 0 1 P
+X O 3 400 -100 150 L 50 50 0 1 P
+ENDDRAW
+ENDDEF
+#
+# PWR_FLAG
+#
+DEF PWR_FLAG #FLG 0 0 N N 1 F P
+F0 "#FLG" 0 75 50 H I C CNN
+F1 "PWR_FLAG" 0 150 50 H V C CNN
+F2 "" 0 0 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+P 6 0 1 0 0 0 0 50 -40 75 0 100 40 75 0 50 N
+X pwr 1 0 0 0 U 50 50 0 0 w
+ENDDRAW
+ENDDEF
+#
+# Q_NMOS_GSD
+#
+DEF Q_NMOS_GSD Q 0 0 Y N 1 F N
+F0 "Q" 200 50 50 H V L CNN
+F1 "Q_NMOS_GSD" 200 -50 50 H V L CNN
+F2 "" 200 100 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+C 65 0 111 0 1 10 N
+C 100 -70 11 0 1 0 F
+C 100 70 11 0 1 0 F
+P 2 0 1 0 2 0 10 0 N
+P 2 0 1 0 30 -70 100 -70 N
+P 2 0 1 10 30 -50 30 -90 N
+P 2 0 1 0 30 0 100 0 N
+P 2 0 1 10 30 20 30 -20 N
+P 2 0 1 0 30 70 100 70 N
+P 2 0 1 10 30 90 30 50 N
+P 2 0 1 0 100 -70 100 -100 N
+P 2 0 1 0 100 -70 100 0 N
+P 2 0 1 0 100 100 100 70 N
+P 3 0 1 10 10 75 10 -75 10 -75 N
+P 4 0 1 0 40 0 80 15 80 -15 40 0 F
+P 4 0 1 0 100 -70 130 -70 130 70 100 70 N
+P 4 0 1 0 110 20 115 15 145 15 150 10 N
+P 4 0 1 0 130 15 115 -10 145 -10 130 15 N
+X G 1 -200 0 200 R 50 50 1 1 I
+X S 2 100 -200 100 U 50 50 1 1 P
+X D 3 100 200 100 D 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# Q_PMOS_GSD
+#
+DEF Q_PMOS_GSD Q 0 0 Y N 1 F N
+F0 "Q" 200 50 50 H V L CNN
+F1 "Q_PMOS_GSD" 200 -50 50 H V L CNN
+F2 "" 200 100 50 H I C CNN
+F3 "" 0 0 50 H I C CNN
+DRAW
+C 65 0 111 0 1 10 N
+C 100 -70 11 0 1 0 F
+C 100 70 11 0 1 0 F
+P 2 0 1 0 2 0 10 0 N
+P 2 0 1 0 30 -70 100 -70 N
+P 2 0 1 10 30 -50 30 -90 N
+P 2 0 1 0 30 0 100 0 N
+P 2 0 1 10 30 20 30 -20 N
+P 2 0 1 0 30 70 100 70 N
+P 2 0 1 10 30 90 30 50 N
+P 2 0 1 0 100 -70 100 -100 N
+P 2 0 1 0 100 -70 100 0 N
+P 2 0 1 0 100 100 100 70 N
+P 3 0 1 10 10 75 10 -75 10 -75 N
+P 4 0 1 0 90 0 50 -15 50 15 90 0 F
+P 4 0 1 0 100 -70 130 -70 130 70 100 70 N
+P 4 0 1 0 110 -20 115 -15 145 -15 150 -10 N
+P 4 0 1 0 130 -15 115 10 145 10 130 -15 N
+X G 1 -200 0 200 R 50 50 1 1 I
+X S 2 100 -200 100 U 50 50 1 1 P
+X D 3 100 200 100 D 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# R
+#
+DEF R R 0 0 N Y 1 F N
+F0 "R" 80 0 50 V V C CNN
+F1 "R" 0 0 50 V V C CNN
+F2 "" -70 0 50 V I C CNN
+F3 "" 0 0 50 H I C CNN
+$FPLIST
+ R_*
+ R_*
+$ENDFPLIST
+DRAW
+S -40 -100 40 100 0 1 10 N
+X ~ 1 0 150 50 D 50 50 1 1 P
+X ~ 2 0 -150 50 U 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# SP0502BAHT
+#
+DEF SP0502BAHT D 0 40 Y N 1 F N
+F0 "D" 225 100 50 H V L CNN
+F1 "SP0502BAHT" 225 25 50 H V L CNN
+F2 "TO_SOT_Packages_SMD:SOT-23" 225 -50 50 H I L CNN
+F3 "" 125 125 50 H I C CNN
+$FPLIST
+ SOT?23*
+$ENDFPLIST
+DRAW
+S -175 100 175 -100 0 1 10 f
+P 2 0 1 0 -100 100 -100 50 N
+P 2 0 1 0 0 -50 0 -100 N
+P 2 0 1 0 100 100 100 50 N
+P 4 0 1 0 -150 75 -125 50 -75 50 -50 25 N
+P 4 0 1 0 -100 0 -100 -50 100 -50 100 0 N
+P 4 0 1 0 -100 50 -75 0 -125 0 -100 50 F
+P 4 0 1 0 50 75 75 50 125 50 150 25 N
+P 4 0 1 0 100 50 75 0 125 0 100 50 F
+X A 3 0 -200 100 U 50 50 0 0 I
+X K 1 -100 200 100 D 50 50 1 1 I
+X K 2 100 200 100 D 50 50 1 1 I
+ENDDRAW
+ENDDEF
+#
+# STM32F042C6Tx
+#
+DEF STM32F042C6Tx U 0 40 Y Y 1 L N
+F0 "U" -3000 1725 50 H V L BNN
+F1 "STM32F042C6Tx" 3000 1725 50 H V R BNN
+F2 "LQFP48" 3000 1675 50 H V R TNN
+F3 "" 0 0 50 H V C CNN
+DRAW
+S -3000 -1700 3000 1700 0 1 10 f
+X VBAT 1 -3100 1100 100 R 50 50 1 1 W
+X ADC_IN0/RTC_TAMP2/SYS_WKUP1/TIM2_CH1/TIM2_ETR/TSC_G1_IO1/USART2_CTS/PA0 10 3100 100 100 L 50 50 1 1 B
+X ADC_IN1/TIM2_CH2/TSC_G1_IO2/USART2_DE/USART2_RTS/PA1 11 3100 0 100 L 50 50 1 1 B
+X ADC_IN2/SYS_WKUP4/TIM2_CH3/TSC_G1_IO3/USART2_TX/PA2 12 3100 -100 100 L 50 50 1 1 B
+X ADC_IN3/TIM2_CH4/TSC_G1_IO4/USART2_RX/PA3 13 3100 -200 100 L 50 50 1 1 B
+X ADC_IN4/I2S1_WS/SPI1_NSS/TIM14_CH1/TSC_G2_IO1/USART2_CK/USB_OE/PA4 14 3100 -300 100 L 50 50 1 1 B
+X ADC_IN5/CEC/I2S1_CK/SPI1_SCK/TIM2_CH1/TIM2_ETR/TSC_G2_IO2/PA5 15 3100 -400 100 L 50 50 1 1 B
+X ADC_IN6/I2S1_MCK/SPI1_MISO/TIM16_CH1/TIM1_BKIN/TIM3_CH1/TSC_G2_IO3/PA6 16 3100 -500 100 L 50 50 1 1 B
+X ADC_IN7/I2S1_SD/SPI1_MOSI/TIM14_CH1/TIM17_CH1/TIM1_CH1N/TIM3_CH2/TSC_G2_IO4/PA7 17 3100 -600 100 L 50 50 1 1 B
+X PB0/ADC_IN8/TIM1_CH2N/TIM3_CH3/TSC_G3_IO2 18 -3100 100 100 R 50 50 1 1 B
+X PB1/ADC_IN9/TIM14_CH1/TIM1_CH3N/TIM3_CH4/TSC_G3_IO3 19 -3100 0 100 R 50 50 1 1 B
+X PC13/RTC_OUT_ALARM/RTC_OUT_CALIB/RTC_TAMP1/RTC_TS/SYS_WKUP2 2 -3100 500 100 R 50 50 1 1 B
+X PB2/TSC_G3_IO4 20 -3100 -100 100 R 50 50 1 1 B
+X PB10/CEC/I2C1_SCL/SPI2_SCK/TIM2_CH3/TSC_SYNC 21 -3100 -900 100 R 50 50 1 1 B
+X PB11/I2C1_SDA/TIM2_CH4 22 -3100 -1000 100 R 50 50 1 1 B
+X VSS 23 -200 -1800 100 U 50 50 1 1 W
+X VDD 24 -200 1800 100 D 50 50 1 1 W
+X PB12/SPI2_NSS/TIM1_BKIN 25 -3100 -1100 100 R 50 50 1 1 B
+X PB13/I2C1_SCL/SPI2_SCK/TIM1_CH1N 26 -3100 -1200 100 R 50 50 1 1 B
+X PB14/I2C1_SDA/SPI2_MISO/TIM1_CH2N 27 -3100 -1300 100 R 50 50 1 1 B
+X PB15/RTC_REFIN/SPI2_MOSI/SYS_WKUP7/TIM1_CH3N 28 -3100 -1400 100 R 50 50 1 1 B
+X CRS_SYNC/RCC_MCO/TIM1_CH1/USART1_CK/PA8 29 3100 -700 100 L 50 50 1 1 B
+X PC14/RCC_OSC32_IN 3 -3100 400 100 R 50 50 1 1 B
+X I2C1_SCL/TIM1_CH2/TSC_G4_IO1/USART1_TX/PA9 30 3100 -800 100 L 50 50 1 1 B
+X I2C1_SDA/TIM17_BKIN/TIM1_CH3/TSC_G4_IO2/USART1_RX/PA10 31 3100 -900 100 L 50 50 1 1 B
+X CAN_RX/I2C1_SCL/TIM1_CH4/TSC_G4_IO3/USART1_CTS/USB_DM/PA11 32 3100 -1000 100 L 50 50 1 1 B
+X CAN_TX/I2C1_SDA/TIM1_ETR/TSC_G4_IO4/USART1_DE/USART1_RTS/USB_DP/PA12 33 3100 -1100 100 L 50 50 1 1 B
+X IR_OUT/SYS_SWDIO/USB_OE/PA13 34 3100 -1200 100 L 50 50 1 1 B
+X VSS 35 -100 -1800 100 U 50 50 1 1 W
+X VDDIO2 36 100 1800 100 D 50 50 1 1 W
+X SYS_SWCLK/USART2_TX/PA14 37 3100 -1300 100 L 50 50 1 1 B
+X I2S1_WS/SPI1_NSS/TIM2_CH1/TIM2_ETR/USART2_RX/USB_OE/PA15 38 3100 -1400 100 L 50 50 1 1 B
+X PB3/I2S1_CK/SPI1_SCK/TIM2_CH2/TSC_G5_IO1 39 -3100 -200 100 R 50 50 1 1 B
+X PC15/RCC_OSC32_OUT 4 -3100 300 100 R 50 50 1 1 B
+X PB4/I2S1_MCK/SPI1_MISO/TIM17_BKIN/TIM3_CH1/TSC_G5_IO2 40 -3100 -300 100 R 50 50 1 1 B
+X PB5/I2C1_SMBA/I2S1_SD/SPI1_MOSI/SYS_WKUP6/TIM16_BKIN/TIM3_CH2 41 -3100 -400 100 R 50 50 1 1 B
+X PB6/I2C1_SCL/TIM16_CH1N/TSC_G5_IO3/USART1_TX 42 -3100 -500 100 R 50 50 1 1 B
+X PB7/I2C1_SDA/TIM17_CH1N/TSC_G5_IO4/USART1_RX 43 -3100 -600 100 R 50 50 1 1 B
+X PF11 44 -3100 700 100 R 50 50 1 1 B
+X PB8/CAN_RX/CEC/I2C1_SCL/TIM16_CH1/TSC_SYNC 45 -3100 -700 100 R 50 50 1 1 B
+X PB9/CAN_TX/I2C1_SDA/IR_OUT/SPI2_NSS/TIM17_CH1 46 -3100 -800 100 R 50 50 1 1 B
+X VSS 47 0 -1800 100 U 50 50 1 1 W
+X VDD 48 -100 1800 100 D 50 50 1 1 W
+X PF0/CRS_SYNC/I2C1_SDA/RCC_OSC_IN 5 -3100 900 100 R 50 50 1 1 I
+X PF1/I2C1_SCL/RCC_OSC_OUT 6 -3100 800 100 R 50 50 1 1 I
+X NRST 7 -3100 1300 100 R 50 50 1 1 I
+X VSSA 8 100 -1800 100 U 50 50 1 1 W
+X VDDA 9 0 1800 100 D 50 50 1 1 W
+ENDDRAW
+ENDDEF
+#
+# SW_Push
+#
+DEF SW_Push SW 0 40 N N 1 F N
+F0 "SW" 50 100 50 H V L CNN
+F1 "SW_Push" 0 -60 50 H V C CNN
+F2 "" 0 200 50 H I C CNN
+F3 "" 0 200 50 H I C CNN
+DRAW
+C -80 0 20 0 1 0 N
+C 80 0 20 0 1 0 N
+P 2 0 1 0 0 50 0 120 N
+P 2 0 1 0 100 50 -100 50 N
+X 1 1 -200 0 100 R 50 50 0 1 P
+X 2 2 200 0 100 L 50 50 0 1 P
+ENDDRAW
+ENDDEF
+#
+# USB6B1-elements
+#
+DEF USB6B1-elements D 0 30 Y N 1 F N
+F0 "D" 0 -450 50 H V C CNN
+F1 "USB6B1-elements" 0 400 50 H V C CNN
+F2 "" 200 -100 50 V V C CNN
+F3 "" 200 -100 50 V V C CNN
+$FPLIST
+ SO8
+$ENDFPLIST
+DRAW
+C -150 -300 7 0 1 0 N
+C -150 100 7 0 1 0 N
+C -150 300 7 0 1 0 N
+C 0 -300 7 0 1 0 N
+C 0 -100 7 0 1 0 N
+C 0 300 7 0 1 0 N
+C 200 -300 7 0 1 0 N
+C 200 300 7 0 1 0 N
+S -300 -100 300 -100 0 1 0 N
+S -300 300 300 300 0 1 0 N
+S -200 -150 -100 -150 0 1 0 N
+S -200 250 -100 250 0 1 0 N
+S -150 300 -150 -300 0 1 0 N
+S -50 -150 50 -150 0 1 0 N
+S -50 250 50 250 0 1 0 N
+S 0 300 0 -300 0 1 0 N
+S 200 300 200 -300 0 1 0 N
+S 300 -300 -300 -300 0 1 0 N
+S 300 100 -300 100 0 1 0 N
+P 3 0 1 8 150 50 250 50 250 50 N
+P 4 0 1 8 150 50 150 30 160 30 160 30 N
+P 4 0 1 8 250 50 250 70 240 70 240 70 N
+P 5 0 1 0 -250 350 300 350 300 -350 -250 -350 -250 350 N
+P 6 0 1 8 -200 -250 -150 -150 -100 -250 -200 -250 -200 -250 -200 -250 N
+P 6 0 1 8 -200 150 -150 250 -100 150 -200 150 -200 150 -200 150 N
+P 6 0 1 8 -50 -250 0 -150 50 -250 -50 -250 -50 -250 -50 -250 N
+P 6 0 1 8 -50 150 0 250 50 150 -50 150 -50 150 -50 150 N
+P 6 0 1 8 150 -50 200 50 250 -50 150 -50 150 -50 150 -50 N
+X VCC 1 -500 300 200 R 50 50 1 1 P
+X I/O1 2 -500 100 200 R 50 50 1 1 P
+X I/O2 3 -500 -100 200 R 50 50 1 1 P
+X GND 4 -500 -300 200 R 50 50 1 1 P
+X GND 5 500 -300 200 L 50 50 1 1 P
+X I/O2 6 500 -100 200 L 50 50 1 1 P
+X I/O1 7 500 100 200 L 50 50 1 1 P
+X VCC 8 500 300 200 L 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+# USB_A-RESCUE-stm32
+#
+DEF USB_A-RESCUE-stm32 P 0 40 Y Y 1 F N
+F0 "P" 200 -200 50 H V C CNN
+F1 "USB_A-RESCUE-stm32" -50 200 50 H V C CNN
+F2 "" -50 -100 50 V V C CNN
+F3 "" -50 -100 50 V V C CNN
+$FPLIST
+ USB*
+$ENDFPLIST
+DRAW
+S -250 -150 150 150 0 1 0 N
+S -205 -150 -195 -120 0 1 0 N
+S -105 -150 -95 -120 0 1 0 N
+S -5 -150 5 -120 0 1 0 N
+S 95 -150 105 -120 0 1 0 N
+X VBUS 1 -200 -300 150 U 50 50 1 1 W
+X D- 2 -100 -300 150 U 50 50 1 1 P
+X D+ 3 0 -300 150 U 50 50 1 1 P
+X GND 4 100 -300 150 U 50 50 1 1 W
+X shield 5 300 100 150 L 50 50 1 1 P
+ENDDRAW
+ENDDEF
+#
+#End Library

F0:F030,F042,F072/usbcan_relay/kicad/stm32.csv

@@ -0,0 +1,160 @@
+"Source:","/home/eddy/Yandex.Disk/Projects/stm32samples/F0-nolib/usbcan_relay/kicad/stm32.sch"
+"Date:","÷Ô 20 ÉÀÌ 2021 17:37:47"
+"Tool:","Eeschema 5.1.10"
+"Generator:","/usr/local/share/kicad/plugins/bom_csv_grouped_by_value.py"
+"Component Count:","96"
+
+"Individual Components:"
+
+"Item","Qty","Reference(s)","Value","LibPart","Footprint","Datasheet","Manufacturer"
+"","","C1","1","stm32-rescue:C","Capacitor_SMD:C_0805_2012Metric_Pad1.15x1.40mm_HandSolder","",""
+"","","C2","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C3","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C4","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C5","1","stm32-rescue:C","Capacitor_SMD:C_0805_2012Metric_Pad1.15x1.40mm_HandSolder","",""
+"","","C6","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C7","0.1","Device:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","C8","0.1","Device:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","C9","0.1","Device:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","C10","100u 16V","Device:CP","Capacitor_THT:CP_Radial_D8.0mm_P3.50mm","~",""
+"","","C11","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","C12","47u 6V","stm32-rescue:CP","Capacitor_Tantalum_SMD:CP_EIA-3216-18_Kemet-A_Pad1.58x1.35mm_HandSolder","",""
+"","","C13","47u 10V","Device:CP","Capacitor_Tantalum_SMD:CP_EIA-6032-28_Kemet-C_Pad2.25x2.35mm_HandSolder","~",""
+"","","C14","100u 16V","Device:CP","Capacitor_THT:CP_Radial_D8.0mm_P3.50mm","~",""
+"","","C15","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","D1","PESD1CAN","elements:PESD1CAN","TO_SOT_Packages_SMD:SOT-23","",""
+"","","D2","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D3","USB6B1","elements:USB6B1","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"","","D4","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D5","MM3Z7V5","Device:D_Zener","Diode_SMD:D_0805_2012Metric_Pad1.15x1.40mm_HandSolder","~",""
+"","","D6","CESD3v3","Device:D","Diode_SMD:D_SOD-523","~",""
+"","","D7","CESD3v3","Device:D","Diode_SMD:D_SOD-523","~",""
+"","","D8","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D9","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D10","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"","","D11","1N5822","Device:D","Diode_THT:D_DO-201_P3.81mm_Vertical_AnodeUp","~",""
+"","","J1","+3.3V","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J2","NRST","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J3","BOOT0","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J4","SWDIO","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J5","SWCLK","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J6","GND","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"","","J7","01x05","Connector:Conn_01x05_Male","Connector_PinHeader_2.54mm:PinHeader_1x05_P2.54mm_Vertical","~",""
+"","","J8","Connector_Generic:Conn_02x04_Odd_Even","Connector_Generic:Conn_02x04_Odd_Even","Connector_PinHeader_2.54mm:PinHeader_2x04_P2.54mm_Vertical","~",""
+"","","J9","Conn_01x02_Female","Connector:Conn_01x02_Female","Connector_PinSocket_2.54mm:PinSocket_1x02_P2.54mm_Vertical","~",""
+"","","J10","Screw_Terminal_01x02","Connector:Screw_Terminal_01x02","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-2_1x02_P5.00mm_Horizontal","~",""
+"","","J11","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"","","J12","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"","","J13","USB_B","Connector:USB_B","Connectors_USB:USB_B_OST_USB-B1HSxx_Horizontal"," ~",""
+"","","J15","01x03","Connector:Conn_01x03_Male","Connector_PinSocket_2.54mm:PinSocket_1x03_P2.54mm_Vertical","~",""
+"","","J16","Conn_01x02_Female","Connector:Conn_01x02_Female","Connector_PinSocket_2.54mm:PinSocket_1x02_P2.54mm_Vertical","~",""
+"","","J17","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"","","J18","01x05","Connector:Conn_01x05_Male","Connector_PinSocket_2.54mm:PinSocket_1x05_P2.54mm_Vertical","~",""
+"","","JP1","NON-ISOL","Device:Jumper","Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P5.08mm_Vertical","~",""
+"","","K1","G5LE-1","Relay:G5LE-1","Relay_THT:Relay_SPDT_SANYOU_SRD_Series_Form_C","http://www.omron.com/ecb/products/pdf/en-g5le.pdf",""
+"","","K2","G5LE-1","Relay:G5LE-1","Relay_THT:Relay_SPDT_SANYOU_SRD_Series_Form_C","http://www.omron.com/ecb/products/pdf/en-g5le.pdf",""
+"","","L1","100u","Device:L","Inductor_SMD:L_12x12mm_H4.5mm","~",""
+"","","P1","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P2","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P3","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P4","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P5","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P6","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","P7","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"","","Q1","B0505S","elements:B0505S","my_footprints:B0x0xS","",""
+"","","Q2","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q3","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q4","AO3407","Device:Q_PMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q5","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q6","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","Q7","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"","","R1","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R2","4k7","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","R3","22","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R4","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R5","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R6","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R7","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R8","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R9","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R10","22","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","R11","22","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"","","R12","2k2","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R13","120","stm32-rescue:R","Resistor_SMD:R_1210_3225Metric_Pad1.42x2.65mm_HandSolder","",""
+"","","R14","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R15","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R16","2k2","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R17","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R18","47k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R19","15k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R20","15k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R21","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R22","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R23","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R24","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R25","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R26","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","R27","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"","","SW1","SW_DIP_x08","Switch:SW_DIP_x08","Button_Switch_THT:SW_DIP_SPSTx08_Slide_9.78x22.5mm_W7.62mm_P2.54mm","~",""
+"","","SW2","SW_DIP_x01","Switch:SW_DIP_x01","Button_Switch_THT:SW_DIP_SPSTx01_Slide_6.7x4.1mm_W7.62mm_P2.54mm_LowProfile","~",""
+"","","U1","MCP2551-I/SN","stm32-rescue:MCP2551-I_SN","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"","","U2","ISO1050DUB","Interface_CAN_LIN:ISO1050DUB","Package_SO:SOP-8_6.62x9.15mm_P2.54mm","http://www.ti.com/lit/ds/symlink/iso1050.pdf",""
+"","","U3","STM32F072C8Tx","MCU_ST_STM32F0:STM32F072C8Tx","Package_QFP:LQFP-48_7x7mm_P0.5mm","http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00090510.pdf",""
+"","","U4","LM2576","vreg:LM2576","TO_SOT_Packages_THT:TO-220-5_P3.4x3.7mm_StaggerEven_Lead3.8mm_Vertical","","Texas Instruments"
+"","","U5","LM1117-3.3","Regulator_Linear:LM1117-3.3","TO_SOT_Packages_SMD:SOT-223-3_TabPin2","http://www.ti.com/lit/ds/symlink/lm1117.pdf",""
+"","","U6","IP4220CZ6","Power_Protection:NUP4202","Package_SO:TSOP-6_1.65x3.05mm_P0.95mm","http://www.onsemi.com/pub_link/Collateral/NUP4202W1-D.PDF",""
+
+
+
+"Collated Components:"
+
+"Item","Qty","Reference(s)","Value","LibPart","Footprint","Datasheet","Manufacturer"
+"1","2","C1, C5","1","stm32-rescue:C","Capacitor_SMD:C_0805_2012Metric_Pad1.15x1.40mm_HandSolder","",""
+"2","9","C2, C3, C4, C6, C7, C8, C9, C11, C15","0.1","stm32-rescue:C","Capacitor_SMD:C_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"3","2","C10, C14","100u 16V","Device:CP","Capacitor_THT:CP_Radial_D8.0mm_P3.50mm","~",""
+"4","1","C12","47u 6V","stm32-rescue:CP","Capacitor_Tantalum_SMD:CP_EIA-3216-18_Kemet-A_Pad1.58x1.35mm_HandSolder","",""
+"5","1","C13","47u 10V","Device:CP","Capacitor_Tantalum_SMD:CP_EIA-6032-28_Kemet-C_Pad2.25x2.35mm_HandSolder","~",""
+"6","1","D1","PESD1CAN","elements:PESD1CAN","TO_SOT_Packages_SMD:SOT-23","",""
+"7","5","D2, D4, D8, D9, D10","SS14","Device:D_Schottky","Diode_SMD:D_SMA-SMB_Universal_Handsoldering","~",""
+"8","1","D3","USB6B1","elements:USB6B1","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"9","1","D5","MM3Z7V5","Device:D_Zener","Diode_SMD:D_0805_2012Metric_Pad1.15x1.40mm_HandSolder","~",""
+"10","2","D6, D7","CESD3v3","Device:D","Diode_SMD:D_SOD-523","~",""
+"11","1","D11","1N5822","Device:D","Diode_THT:D_DO-201_P3.81mm_Vertical_AnodeUp","~",""
+"12","1","J1","+3.3V","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"13","1","J2","NRST","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"14","1","J3","BOOT0","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"15","1","J4","SWDIO","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"16","1","J5","SWCLK","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"17","1","J6","GND","Connector:Conn_01x01_Female","Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_Vertical","~",""
+"18","1","J7","01x05","Connector:Conn_01x05_Male","Connector_PinHeader_2.54mm:PinHeader_1x05_P2.54mm_Vertical","~",""
+"19","1","J8","Connector_Generic:Conn_02x04_Odd_Even","Connector_Generic:Conn_02x04_Odd_Even","Connector_PinHeader_2.54mm:PinHeader_2x04_P2.54mm_Vertical","~",""
+"20","2","J9, J16","Conn_01x02_Female","Connector:Conn_01x02_Female","Connector_PinSocket_2.54mm:PinSocket_1x02_P2.54mm_Vertical","~",""
+"21","1","J10","Screw_Terminal_01x02","Connector:Screw_Terminal_01x02","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-2_1x02_P5.00mm_Horizontal","~",""
+"22","3","J11, J12, J17","Screw_Terminal_01x03","Connector:Screw_Terminal_01x03","TerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-3_1x03_P5.00mm_Horizontal","~",""
+"23","1","J13","USB_B","Connector:USB_B","Connectors_USB:USB_B_OST_USB-B1HSxx_Horizontal"," ~",""
+"24","1","J15","01x03","Connector:Conn_01x03_Male","Connector_PinSocket_2.54mm:PinSocket_1x03_P2.54mm_Vertical","~",""
+"25","1","J18","01x05","Connector:Conn_01x05_Male","Connector_PinSocket_2.54mm:PinSocket_1x05_P2.54mm_Vertical","~",""
+"26","1","JP1","NON-ISOL","Device:Jumper","Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P5.08mm_Vertical","~",""
+"27","2","K1, K2","G5LE-1","Relay:G5LE-1","Relay_THT:Relay_SPDT_SANYOU_SRD_Series_Form_C","http://www.omron.com/ecb/products/pdf/en-g5le.pdf",""
+"28","1","L1","100u","Device:L","Inductor_SMD:L_12x12mm_H4.5mm","~",""
+"29","7","P1, P2, P3, P4, P5, P6, P7","Hole","stm32-rescue:CONN_01X01","my_footprints:Hole_3mm","",""
+"30","1","Q1","B0505S","elements:B0505S","my_footprints:B0x0xS","",""
+"31","5","Q2, Q3, Q5, Q6, Q7","SI2300","Device:Q_NMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"32","1","Q4","AO3407","Device:Q_PMOS_GSD","TO_SOT_Packages_SMD:SOT-23_Handsoldering","~",""
+"33","8","R1, R8, R14, R17, R21, R25, R26, R27","10k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"34","1","R2","4k7","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","",""
+"35","3","R3, R10, R11","22","stm32-rescue:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"36","4","R4, R5, R6, R7","680","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"37","5","R9, R15, R22, R23, R24","330","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"38","2","R12, R16","2k2","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"39","1","R13","120","stm32-rescue:R","Resistor_SMD:R_1210_3225Metric_Pad1.42x2.65mm_HandSolder","",""
+"40","1","R18","47k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"41","2","R19, R20","15k","Device:R","Resistor_SMD:R_0603_1608Metric_Pad1.05x0.95mm_HandSolder","~",""
+"42","1","SW1","SW_DIP_x08","Switch:SW_DIP_x08","Button_Switch_THT:SW_DIP_SPSTx08_Slide_9.78x22.5mm_W7.62mm_P2.54mm","~",""
+"43","1","SW2","SW_DIP_x01","Switch:SW_DIP_x01","Button_Switch_THT:SW_DIP_SPSTx01_Slide_6.7x4.1mm_W7.62mm_P2.54mm_LowProfile","~",""
+"44","1","U1","MCP2551-I/SN","stm32-rescue:MCP2551-I_SN","Package_SO:SOIC-8_3.9x4.9mm_P1.27mm","",""
+"45","1","U2","ISO1050DUB","Interface_CAN_LIN:ISO1050DUB","Package_SO:SOP-8_6.62x9.15mm_P2.54mm","http://www.ti.com/lit/ds/symlink/iso1050.pdf",""
+"46","1","U3","STM32F072C8Tx","MCU_ST_STM32F0:STM32F072C8Tx","Package_QFP:LQFP-48_7x7mm_P0.5mm","http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/DM00090510.pdf",""
+"47","1","U4","LM2576","vreg:LM2576","TO_SOT_Packages_THT:TO-220-5_P3.4x3.7mm_StaggerEven_Lead3.8mm_Vertical","","Texas Instruments"
+"48","1","U5","LM1117-3.3","Regulator_Linear:LM1117-3.3","TO_SOT_Packages_SMD:SOT-223-3_TabPin2","http://www.ti.com/lit/ds/symlink/lm1117.pdf",""
+"49","1","U6","IP4220CZ6","Power_Protection:NUP4202","Package_SO:TSOP-6_1.65x3.05mm_P0.95mm","http://www.onsemi.com/pub_link/Collateral/NUP4202W1-D.PDF",""

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

@@ -0,0 +1,76 @@
+{
+  "board": {
+    "active_layer": 0,
+    "active_layer_preset": "All Layers",
+    "auto_track_width": true,
+    "hidden_nets": [],
+    "high_contrast_mode": 0,
+    "net_color_mode": 1,
+    "opacity": {
+      "pads": 1.0,
+      "tracks": 1.0,
+      "vias": 1.0,
+      "zones": 0.6
+    },
+    "ratsnest_display_mode": 0,
+    "selection_filter": {
+      "dimensions": true,
+      "footprints": true,
+      "graphics": true,
+      "keepouts": true,
+      "lockedItems": true,
+      "otherItems": true,
+      "pads": true,
+      "text": true,
+      "tracks": true,
+      "vias": true,
+      "zones": true
+    },
+    "visible_items": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      32,
+      33,
+      34,
+      35,
+      36
+    ],
+    "visible_layers": "fffffff_ffffffff",
+    "zone_display_mode": 0
+  },
+  "meta": {
+    "filename": "stm32.kicad_prl",
+    "version": 3
+  },
+  "project": {
+    "files": []
+  }
+}

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

@@ -0,0 +1,462 @@
+{
+  "board": {
+    "design_settings": {
+      "defaults": {
+        "board_outline_line_width": 0.15,
+        "copper_line_width": 0.19999999999999998,
+        "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,
+        "dimension_precision": 4,
+        "dimension_units": 3,
+        "dimensions": {
+          "arrow_length": 1270000,
+          "extension_offset": 500000,
+          "keep_text_aligned": true,
+          "suppress_zeroes": false,
+          "text_position": 0,
+          "units_format": 1
+        },
+        "fab_line_width": 0.09999999999999999,
+        "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_text_italic": false,
+        "other_text_size_h": 1.0,
+        "other_text_size_v": 1.0,
+        "other_text_thickness": 0.15,
+        "other_text_upright": false,
+        "pads": {
+          "drill": 0.8,
+          "height": 1.5,
+          "width": 1.5
+        },
+        "silk_line_width": 0.15,
+        "silk_text_italic": false,
+        "silk_text_size_h": 1.0,
+        "silk_text_size_v": 1.0,
+        "silk_text_thickness": 0.15,
+        "silk_text_upright": false,
+        "zones": {
+          "45_degree_only": true,
+          "min_clearance": 0.5
+        }
+      },
+      "diff_pair_dimensions": [],
+      "drc_exclusions": [],
+      "meta": {
+        "filename": "board_design_settings.json",
+        "version": 2
+      },
+      "rule_severities": {
+        "annular_width": "error",
+        "clearance": "error",
+        "copper_edge_clearance": "error",
+        "courtyards_overlap": "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",
+        "hole_clearance": "error",
+        "hole_near_hole": "error",
+        "invalid_outline": "error",
+        "item_on_disabled_layer": "error",
+        "items_not_allowed": "error",
+        "length_out_of_range": "error",
+        "malformed_courtyard": "error",
+        "microvia_drill_out_of_range": "error",
+        "missing_courtyard": "ignore",
+        "missing_footprint": "warning",
+        "net_conflict": "warning",
+        "npth_inside_courtyard": "ignore",
+        "padstack": "error",
+        "pth_inside_courtyard": "ignore",
+        "shorting_items": "error",
+        "silk_over_copper": "error",
+        "silk_overlap": "error",
+        "skew_out_of_range": "error",
+        "too_many_vias": "error",
+        "track_dangling": "warning",
+        "track_width": "error",
+        "tracks_crossing": "error",
+        "unconnected_items": "error",
+        "unresolved_variable": "error",
+        "via_dangling": "warning",
+        "zone_has_empty_net": "error",
+        "zones_intersect": "error"
+      },
+      "rule_severitieslegacy_courtyards_overlap": true,
+      "rule_severitieslegacy_no_courtyard_defined": false,
+      "rules": {
+        "allow_blind_buried_vias": false,
+        "allow_microvias": false,
+        "max_error": 0.005,
+        "min_clearance": 0.0,
+        "min_copper_edge_clearance": 0.075,
+        "min_hole_clearance": 0.0,
+        "min_hole_to_hole": 0.25,
+        "min_microvia_diameter": 0.19999999999999998,
+        "min_microvia_drill": 0.09999999999999999,
+        "min_silk_clearance": 0.0,
+        "min_through_hole_diameter": 0.6,
+        "min_track_width": 0.19999999999999998,
+        "min_via_annular_width": 0.049999999999999996,
+        "min_via_diameter": 0.7999999999999999
+      },
+      "track_widths": [
+        0.0,
+        0.2,
+        0.3,
+        0.5,
+        1.0,
+        2.0
+      ],
+      "via_dimensions": [
+        {
+          "diameter": 0.0,
+          "drill": 0.0
+        },
+        {
+          "diameter": 1.5,
+          "drill": 0.8
+        }
+      ],
+      "zones_allow_external_fillets": false,
+      "zones_use_no_outline": true
+    },
+    "layer_presets": []
+  },
+  "boards": [],
+  "cvpcb": {
+    "equivalence_files": []
+  },
+  "erc": {
+    "erc_exclusions": [],
+    "meta": {
+      "version": 0
+    },
+    "pin_map": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        2,
+        2,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        1,
+        0,
+        1,
+        2
+      ],
+      [
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        1,
+        2,
+        1,
+        1,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        1,
+        2,
+        0,
+        0,
+        1,
+        0,
+        2,
+        2,
+        2,
+        2
+      ],
+      [
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        1,
+        1,
+        0,
+        0,
+        1,
+        0,
+        2,
+        0,
+        0,
+        2
+      ],
+      [
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2,
+        2
+      ]
+    ],
+    "rule_severities": {
+      "bus_definition_conflict": "error",
+      "bus_label_syntax": "error",
+      "bus_to_bus_conflict": "error",
+      "bus_to_net_conflict": "error",
+      "different_unit_footprint": "error",
+      "different_unit_net": "error",
+      "duplicate_reference": "error",
+      "duplicate_sheet_names": "error",
+      "extra_units": "error",
+      "global_label_dangling": "warning",
+      "hier_label_mismatch": "error",
+      "label_dangling": "error",
+      "lib_symbol_issues": "warning",
+      "multiple_net_names": "warning",
+      "net_not_bus_member": "warning",
+      "no_connect_connected": "warning",
+      "no_connect_dangling": "warning",
+      "pin_not_connected": "error",
+      "pin_not_driven": "error",
+      "pin_to_pin": "warning",
+      "power_pin_not_driven": "error",
+      "similar_labels": "warning",
+      "unannotated": "error",
+      "unit_value_mismatch": "error",
+      "unresolved_variable": "error",
+      "wire_dangling": "error"
+    }
+  },
+  "libraries": {
+    "pinned_footprint_libs": [],
+    "pinned_symbol_libs": []
+  },
+  "meta": {
+    "filename": "stm32.kicad_pro",
+    "version": 1
+  },
+  "net_settings": {
+    "classes": [
+      {
+        "bus_width": 12.0,
+        "clearance": 0.2,
+        "diff_pair_gap": 0.25,
+        "diff_pair_via_gap": 0.25,
+        "diff_pair_width": 0.2,
+        "line_style": 0,
+        "microvia_diameter": 0.3,
+        "microvia_drill": 0.1,
+        "name": "Default",
+        "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "schematic_color": "rgba(0, 0, 0, 0.000)",
+        "track_width": 0.2,
+        "via_diameter": 1.0,
+        "via_drill": 0.6,
+        "wire_width": 6.0
+      },
+      {
+        "bus_width": 12.0,
+        "clearance": 0.3,
+        "diff_pair_gap": 0.25,
+        "diff_pair_via_gap": 0.25,
+        "diff_pair_width": 0.2,
+        "line_style": 0,
+        "microvia_diameter": 0.3,
+        "microvia_drill": 0.1,
+        "name": "0.5",
+        "nets": [],
+        "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "schematic_color": "rgba(0, 0, 0, 0.000)",
+        "track_width": 0.5,
+        "via_diameter": 1.5,
+        "via_drill": 0.8,
+        "wire_width": 6.0
+      },
+      {
+        "bus_width": 12.0,
+        "clearance": 0.5,
+        "diff_pair_gap": 0.25,
+        "diff_pair_via_gap": 0.25,
+        "diff_pair_width": 0.2,
+        "line_style": 0,
+        "microvia_diameter": 0.3,
+        "microvia_drill": 0.1,
+        "name": "1",
+        "nets": [],
+        "pcb_color": "rgba(0, 0, 0, 0.000)",
+        "schematic_color": "rgba(0, 0, 0, 0.000)",
+        "track_width": 1.0,
+        "via_diameter": 1.5,
+        "via_drill": 0.8,
+        "wire_width": 6.0
+      }
+    ],
+    "meta": {
+      "version": 0
+    },
+    "net_colors": null
+  },
+  "pcbnew": {
+    "last_paths": {
+      "gencad": "",
+      "idf": "",
+      "netlist": "stm32.net",
+      "specctra_dsn": "",
+      "step": "",
+      "vrml": ""
+    },
+    "page_layout_descr_file": ""
+  },
+  "schematic": {
+    "drawing": {
+      "default_bus_thickness": 12.0,
+      "default_junction_size": 40.0,
+      "default_line_thickness": 6.0,
+      "default_text_size": 50.0,
+      "default_wire_thickness": 6.0,
+      "field_names": [],
+      "intersheets_ref_own_page": false,
+      "intersheets_ref_prefix": "",
+      "intersheets_ref_short": false,
+      "intersheets_ref_show": false,
+      "intersheets_ref_suffix": "",
+      "junction_size_choice": 3,
+      "pin_symbol_size": 25.0,
+      "text_offset_ratio": 0.3
+    },
+    "legacy_lib_dir": "",
+    "legacy_lib_list": [],
+    "meta": {
+      "version": 0
+    },
+    "net_format_name": "Pcbnew",
+    "ngspice": {
+      "meta": {
+        "version": 0
+      },
+      "model_mode": 0
+    },
+    "page_layout_descr_file": "",
+    "plot_directory": "",
+    "spice_adjust_passive_values": false,
+    "spice_external_command": "spice \"%I\"",
+    "subpart_first_id": 65,
+    "subpart_id_separator": 0
+  },
+  "sheets": [],
+  "text_variables": {}
+}

F0:F030,F042,F072/usbcan_relay/kicad/stm32.pro

@@ -0,0 +1,276 @@
+update=Ср 16 июн 2021 12:32:18
+version=1
+last_client=kicad
+[cvpcb]
+version=1
+NetIExt=net
+[general]
+version=1
+[eeschema]
+version=1
+LibDir=
+[schematic_editor]
+version=1
+PageLayoutDescrFile=
+PlotDirectoryName=
+SubpartIdSeparator=0
+SubpartFirstId=65
+NetFmtName=Pcbnew
+SpiceAjustPassiveValues=0
+LabSize=50
+ERC_TestSimilarLabels=1
+[pcbnew]
+version=1
+PageLayoutDescrFile=
+LastNetListRead=stm32.net
+CopperLayerCount=2
+BoardThickness=2.5
+AllowMicroVias=0
+AllowBlindVias=0
+RequireCourtyardDefinitions=0
+ProhibitOverlappingCourtyards=1
+MinTrackWidth=0.2
+MinViaDiameter=0.7999999999999999
+MinViaDrill=0.4
+MinMicroViaDiameter=0.2
+MinMicroViaDrill=0.09999999999999999
+MinHoleToHole=0.25
+TrackWidth1=0.2
+TrackWidth2=0.2
+TrackWidth3=0.3
+TrackWidth4=0.5
+TrackWidth5=1
+TrackWidth6=2
+ViaDiameter1=0.8
+ViaDrill1=0.4
+ViaDiameter2=0.8
+ViaDrill2=0.4
+ViaDiameter3=1.2
+ViaDrill3=0.6
+dPairWidth1=0.2
+dPairGap1=0.25
+dPairViaGap1=0.25
+SilkLineWidth=0.15
+SilkTextSizeV=1
+SilkTextSizeH=1
+SilkTextSizeThickness=0.15
+SilkTextItalic=0
+SilkTextUpright=1
+CopperLineWidth=0.2
+CopperTextSizeV=1.5
+CopperTextSizeH=1.5
+CopperTextThickness=0.3
+CopperTextItalic=0
+CopperTextUpright=1
+EdgeCutLineWidth=0.15
+CourtyardLineWidth=0.05
+OthersLineWidth=0.15
+OthersTextSizeV=1
+OthersTextSizeH=1
+OthersTextSizeThickness=0.15
+OthersTextItalic=0
+OthersTextUpright=1
+SolderMaskClearance=0.2
+SolderMaskMinWidth=0
+SolderPasteClearance=0
+SolderPasteRatio=-0
+[pcbnew/Layer.F.Cu]
+Name=F.Cu
+Type=0
+Enabled=1
+[pcbnew/Layer.In1.Cu]
+Name=In1.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In2.Cu]
+Name=In2.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In3.Cu]
+Name=In3.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In4.Cu]
+Name=In4.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In5.Cu]
+Name=In5.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In6.Cu]
+Name=In6.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In7.Cu]
+Name=In7.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In8.Cu]
+Name=In8.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In9.Cu]
+Name=In9.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In10.Cu]
+Name=In10.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In11.Cu]
+Name=In11.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In12.Cu]
+Name=In12.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In13.Cu]
+Name=In13.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In14.Cu]
+Name=In14.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In15.Cu]
+Name=In15.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In16.Cu]
+Name=In16.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In17.Cu]
+Name=In17.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In18.Cu]
+Name=In18.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In19.Cu]
+Name=In19.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In20.Cu]
+Name=In20.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In21.Cu]
+Name=In21.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In22.Cu]
+Name=In22.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In23.Cu]
+Name=In23.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In24.Cu]
+Name=In24.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In25.Cu]
+Name=In25.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In26.Cu]
+Name=In26.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In27.Cu]
+Name=In27.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In28.Cu]
+Name=In28.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In29.Cu]
+Name=In29.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.In30.Cu]
+Name=In30.Cu
+Type=0
+Enabled=0
+[pcbnew/Layer.B.Cu]
+Name=B.Cu
+Type=0
+Enabled=1
+[pcbnew/Layer.B.Adhes]
+Enabled=1
+[pcbnew/Layer.F.Adhes]
+Enabled=1
+[pcbnew/Layer.B.Paste]
+Enabled=1
+[pcbnew/Layer.F.Paste]
+Enabled=1
+[pcbnew/Layer.B.SilkS]
+Enabled=1
+[pcbnew/Layer.F.SilkS]
+Enabled=1
+[pcbnew/Layer.B.Mask]
+Enabled=1
+[pcbnew/Layer.F.Mask]
+Enabled=1
+[pcbnew/Layer.Dwgs.User]
+Enabled=1
+[pcbnew/Layer.Cmts.User]
+Enabled=1
+[pcbnew/Layer.Eco1.User]
+Enabled=1
+[pcbnew/Layer.Eco2.User]
+Enabled=1
+[pcbnew/Layer.Edge.Cuts]
+Enabled=1
+[pcbnew/Layer.Margin]
+Enabled=1
+[pcbnew/Layer.B.CrtYd]
+Enabled=1
+[pcbnew/Layer.F.CrtYd]
+Enabled=1
+[pcbnew/Layer.B.Fab]
+Enabled=1
+[pcbnew/Layer.F.Fab]
+Enabled=1
+[pcbnew/Layer.Rescue]
+Enabled=0
+[pcbnew/Netclasses]
+[pcbnew/Netclasses/Default]
+Name=Default
+Clearance=0.2
+TrackWidth=0.2
+ViaDiameter=0.8
+ViaDrill=0.4
+uViaDiameter=0.3
+uViaDrill=0.1
+dPairWidth=0.2
+dPairGap=0.25
+dPairViaGap=0.25
+[pcbnew/Netclasses/1]
+Name=0.5
+Clearance=0.3
+TrackWidth=0.5
+ViaDiameter=1.2
+ViaDrill=0.6
+uViaDiameter=0.3
+uViaDrill=0.1
+dPairWidth=0.2
+dPairGap=0.25
+dPairViaGap=0.25
+[pcbnew/Netclasses/2]
+Name=1
+Clearance=0.5
+TrackWidth=1
+ViaDiameter=1.2
+ViaDrill=0.6
+uViaDiameter=0.3
+uViaDrill=0.1
+dPairWidth=0.2
+dPairGap=0.25
+dPairViaGap=0.25

F0:F030,F042,F072/usbcan_relay/kicad/sym-lib-table

@@ -0,0 +1,8 @@
+(sym_lib_table
+  (lib (name stm32-rescue)(type Legacy)(uri ${KIPRJMOD}/stm32-rescue.lib)(options "")(descr ""))
+  (lib (name stm32)(type Legacy)(uri /home/eddy/kicad/Kicad-Libraries/library/stm32.lib)(options "")(descr ""))
+  (lib (name vreg)(type Legacy)(uri /home/eddy/kicad/Kicad-Libraries/library/vreg.lib)(options "")(descr ""))
+  (lib (name elements)(type Legacy)(uri ${KIPRJMOD}/elements.lib)(options "")(descr ""))
+  (lib (name switches)(type Legacy)(uri /home/eddy/kicad/Kicad-Libraries/library/switches.lib)(options "")(descr ""))
+  (lib (name acs712)(type Legacy)(uri ${KIPRJMOD}/acs712.lib)(options "")(descr ""))
+)

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

@@ -0,0 +1,115 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 "adc.h"
+#include "buttons.h"
+#include "can.h"
+#include "custom_buttons.h"
+#include "hardware.h"
+#include "proto.h"
+#include "usb.h"
+#include "usb_lib.h"
+
+volatile uint32_t Tms = 0;
+
+/* Called when systick fires */
+void sys_tick_handler(void){
+    ++Tms;
+}
+
+#define USBBUF 63
+// usb getline
+static char *get_USB(){
+    static char tmpbuf[USBBUF+1], *curptr = tmpbuf;
+    static int rest = USBBUF;
+    uint8_t x = USB_receive((uint8_t*)curptr);
+    if(!x) return NULL;
+    curptr[x] = 0;
+    if(x == 1 && *curptr == 0x7f){ // backspace
+        if(curptr > tmpbuf){
+            --curptr;
+            USND("\b \b");
+        }
+        return NULL;
+    }
+    USB_sendstr(curptr); // echo
+    if(curptr[x-1] == '\n'){ // || curptr[x-1] == '\r'){
+        curptr = tmpbuf;
+        rest = USBBUF;
+        // omit empty lines
+        if(tmpbuf[0] == '\n') return NULL;
+        // and wrong empty lines
+        if(tmpbuf[0] == '\r' && tmpbuf[1] == '\n') return NULL;
+        return tmpbuf;
+    }
+    curptr += x; rest -= x;
+    if(rest <= 0){ // buffer overflow
+        curptr = tmpbuf;
+        rest = USBBUF;
+    }
+    return NULL;
+}
+
+int main(void){
+    uint8_t ctr, len;
+    CAN_message *can_mesg;
+    char *txt;
+    sysreset();
+    SysTick_Config(6000, 1);
+    gpio_setup();
+    adc_setup();
+    tim1_setup();
+    USB_setup();
+    CAN_setup(DEFAULT_CAN_SPEED);
+    RCC->CSR |= RCC_CSR_RMVF; // remove reset flags
+    iwdg_setup();
+
+    while (1){
+        IWDG->KR = IWDG_REFRESH; // refresh watchdog
+        process_keys();
+        custom_buttons_process();
+        can_proc();
+        usb_proc();
+        if(CAN_get_status() == CAN_FIFO_OVERRUN){
+            SEND("CAN bus fifo overrun occured!\n");
+            sendbuf();
+        }
+        while((can_mesg = CAN_messagebuf_pop())){
+            if(can_mesg && isgood(can_mesg->ID)){
+                if(ShowMsgs){ // new data in buff
+                    IWDG->KR = IWDG_REFRESH;
+                    len = can_mesg->length;
+                    printu(Tms);
+                    SEND(" #");
+                    printuhex(can_mesg->ID);
+                    for(ctr = 0; ctr < len; ++ctr){
+                        SEND(" ");
+                        printuhex(can_mesg->data[ctr]);
+                    }
+                    newline(); sendbuf();
+                }
+            }
+        }
+        if((txt = get_USB())){
+            IWDG->KR = IWDG_REFRESH;
+            cmd_parser(txt);
+        }
+    }
+    return 0;
+}
+

F0:F030,F042,F072/usbcan_relay/proto.c

@@ -0,0 +1,664 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 "adc.h"
+#include "buttons.h"
+#include "can.h"
+#include "hardware.h"
+#include "proto.h"
+#include "usb.h"
+
+#include <string.h> // strlen
+
+extern volatile uint8_t canerror;
+
+uint8_t ShowMsgs = 0;
+uint16_t Ignore_IDs[IGN_SIZE];
+uint8_t IgnSz = 0;
+static char buff[BUFSZ+1], *bptr = buff;
+static uint8_t blen = 0;
+
+void sendbuf(){
+    IWDG->KR = IWDG_REFRESH;
+    if(blen == 0) return;
+    *bptr = 0;
+    USB_sendstr(buff);
+    bptr = buff;
+    blen = 0;
+}
+
+void bufputchar(char ch){
+    if(blen > BUFSZ-1){
+        sendbuf();
+    }
+    *bptr++ = ch;
+    ++blen;
+}
+
+void addtobuf(const char *txt){
+    IWDG->KR = IWDG_REFRESH;
+    while(*txt) bufputchar(*txt++);
+}
+
+char *omit_spaces(const char *buf){
+    while(*buf){
+        if(*buf > ' ') break;
+        ++buf;
+    }
+    return (char*) buf;
+}
+
+// THERE'S NO OVERFLOW PROTECTION IN NUMBER READ PROCEDURES!
+// read decimal number
+static char *getdec(const char *buf, uint32_t *N){
+    uint32_t num = 0;
+    while(*buf){
+        char c = *buf;
+        if(c < '0' || c > '9'){
+            break;
+        }
+        num *= 10;
+        num += c - '0';
+        ++buf;
+    }
+    *N = num;
+    return (char *)buf;
+}
+// read hexadecimal number (without 0x prefix!)
+static char *gethex(const char *buf, uint32_t *N){
+    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){
+            num <<= 4;
+            num += c - M;
+        }else{
+            break;
+        }
+        ++buf;
+    }
+    *N = num;
+    return (char *)buf;
+}
+// read binary number (without 0b prefix!)
+static char *getbin(const char *buf, uint32_t *N){
+    uint32_t num = 0;
+    while(*buf){
+        char c = *buf;
+        if(c < '0' || c > '1'){
+            break;
+        }
+        num <<= 1;
+        if(c == '1') num |= 1;
+        ++buf;
+    }
+    *N = num;
+    return (char *)buf;
+}
+
+/**
+ * @brief getnum - read uint32_t from string (dec, hex or bin: 127, 0x7f, 0b1111111)
+ * @param buf - buffer with number and so on
+ * @param N   - the number read
+ * @return pointer to first non-number symbol in buf (if it is == buf, there's no number)
+ */
+char *getnum(const char *txt, uint32_t *N){
+    if(*txt == '0'){
+        if(txt[1] == 'x' || txt[1] == 'X') return gethex(txt+2, N);
+        if(txt[1] == 'b' || txt[1] == 'B') return getbin(txt+2, N);
+    }
+    return getdec(txt, N);
+}
+
+// parse `txt` to CAN_message
+static CAN_message *parseCANmsg(char *txt){
+    static CAN_message canmsg;
+    //SEND("CAN command with arguments:\n");
+    uint32_t N;
+    char *n;
+    int ctr = -1;
+    canmsg.ID = 0xffff;
+    do{
+        txt = omit_spaces(txt);
+        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);
+            //SEND("ID="); printuhex(canmsg.ID); newline();
+            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");
+    sendbuf();
+    canmsg.length = (uint8_t) ctr;
+    return &canmsg;
+}
+
+// send command, format: ID (hex/bin/dec) data bytes (up to 8 bytes, space-delimeted)
+TRUE_INLINE void sendCANcommand(char *txt){
+    CAN_message *msg = parseCANmsg(txt);
+    if(!msg) return;
+    uint32_t N = 1000;
+    while(CAN_BUSY == can_send(msg->data, msg->length, msg->ID)){
+        if(--N == 0) break;
+    }
+}
+
+TRUE_INLINE void CANini(char *txt){
+    txt = omit_spaces(txt);
+    uint32_t N;
+    char *n = getnum(txt, &N);
+    if(txt == n){
+        SEND("No speed given");
+        return;
+    }
+    if(N < 50){
+        SEND("Lowest speed is 50kbps");
+        return;
+    }else if(N > 3000){
+        SEND("Highest speed is 3000kbps");
+        return;
+    }
+    CAN_reinit((uint16_t)N);
+    SEND("Reinit CAN bus with speed ");
+    printu(N); SEND("kbps");
+}
+
+TRUE_INLINE void addIGN(char *txt){
+    if(IgnSz == IGN_SIZE){
+        MSG("Ignore buffer is full");
+        return;
+    }
+    txt = omit_spaces(txt);
+    uint32_t N;
+    char *n = getnum(txt, &N);
+    if(txt == n){
+        SEND("No ID given");
+        return;
+    }
+    if(N == CANID){
+        SEND("You can't ignore self ID!");
+        return;
+    }
+    if(N > 0x7ff){
+        SEND("ID should be 11-bit number!");
+        return;
+    }
+    Ignore_IDs[IgnSz++] = (uint16_t)(N & 0x7ff);
+    SEND("Added ID "); printu(N);
+    SEND("\nIgn buffer size: "); printu(IgnSz);
+}
+
+TRUE_INLINE void print_ign_buf(){
+    if(IgnSz == 0){
+        SEND("Ignore buffer is empty");
+        return;
+    }
+    SEND("Ignored IDs:\n");
+    for(int i = 0; i < IgnSz; ++i){
+        printu(i);
+        SEND(": ");
+        printuhex(Ignore_IDs[i]);
+        newline();
+    }
+}
+
+// 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);
+                }
+            }
+            newline();
+        }
+        fa >>= 1;
+        ++ctr;
+        mask <<= 1;
+    }
+    sendbuf();
+}
+
+/**
+ * @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");
+        return;
+    }
+    if(N == 0 || N > STM32F0FBANKNO-1){
+        SEND("0 (reserved for self) < bank# < 28 (max bank# is 27)!!!");
+        return;
+    }
+    uint8_t bankno = (uint8_t)N;
+    str = omit_spaces(n);
+    if(!*str){ // deactivate filter
+        SEND("Deactivate filters in bank ");
+        printu(bankno);
+        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");
+        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");
+        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!");
+        return;
+    }
+    if(mode && (nfilt&1)){
+        SEND("In MASK mode you should point pairs of ID/MASK");
+        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");
+}
+
+/**
+ * @brief ledsOp - turn on/off LEDs
+ * @param str - LED number (0..3)
+ * @param state = 1 to turn on, 0 to turn off (toggling only available for CAN bus commands)
+ */
+static void ledsOp(const char *str, uint8_t state){
+    uint32_t N;
+    char *x = getnum(str, &N);
+    if(!x || x == str || N > LEDSNO - 1){
+        SEND("Wrong LED number\n");
+        return;
+    }
+    if(state) LED_on(N);
+    else LED_off(N);
+    SEND("LED"); printu(N); SEND(" is ");
+    if(state) SEND("on"); else SEND("off");
+}
+
+// print current buttons state
+TRUE_INLINE void getBtnState(){
+    const char *states[] = {[EVT_NONE] = NULL, [EVT_PRESS] = "pressed", [EVT_HOLD] = "holded", [EVT_RELEASE] = "released"};
+    for(int i = 0; i < BTNSNO; ++i){
+        uint32_t T;
+        keyevent e = keystate(i, &T);
+        if(e != EVT_NONE){
+            SEND("The key "); printu(i);
+            SEND(" is "); addtobuf(states[e]); SEND(" at ");
+            printu(T); NL();
+        }
+    }
+}
+
+TRUE_INLINE void getPWM(){
+    volatile uint32_t *reg = &TIM1->CCR1;
+    for(int n = 0; n < 3; ++n){
+        SEND("PWM");
+        bufputchar('0' + n);
+        bufputchar('=');
+        printu(*reg++);
+        bufputchar('\n');
+    }
+    sendbuf();
+}
+
+TRUE_INLINE void changePWM(char *str){
+    str = omit_spaces(str);
+    uint32_t N, pwm;
+    char *nxt = getnum(str, &N);
+    if(nxt == str || N > 2){
+        SEND("Nch = 0..2");
+        return;
+    }
+    str = omit_spaces(nxt);
+    nxt = getnum(str, &pwm);
+    if(nxt == str || pwm > 255){
+        SEND("PWM should be from 0 to 255");
+        return;
+    }
+    volatile uint32_t *reg = &TIM1->CCR1;
+    reg[N] = pwm;
+    SEND("OK, changed");
+}
+
+TRUE_INLINE void printADC(){ // show all 4 channels ADC
+    for(int i = 0; i < NUMBER_OF_ADC_CHANNELS; ++i){
+        SEND("ADC"); bufputchar('0' + i); bufputchar('=');
+        printu(getADCval(i)); bufputchar('\n');
+    }
+    sendbuf();
+}
+
+TRUE_INLINE void printVT(){ // show T and Vdd
+    int32_t t = getMCUtemp();
+    SEND("T=");
+    if(t < 0){ bufputchar('-'); t = -t; }
+    printu(t); SEND("/10degC\nVDD=");
+    printu(getVdd()); SEND("/100V");
+}
+
+// set or check relay(N) state
+TRUE_INLINE void relayX(uint8_t N, const char *txt){
+    if(N >= RelaysNO) return;
+    txt = omit_spaces(txt);
+    uint32_t sr;
+    char *b = getnum(txt, &sr);
+    if(b && b != txt && sr < 2){
+        if(sr) Relay_ON(N); else Relay_OFF(N);
+    }
+    SEND("Relay"); bufputchar('0'+N); bufputchar('=');
+    bufputchar('0' + Relay_chk(N));
+}
+
+/**
+ * @brief cmd_parser - command parsing
+ * @param txt   - buffer with commands & data
+ * @param isUSB - == 1 if data got from USB
+ */
+void cmd_parser(char *txt){
+    char _1st = txt[0];
+    /*
+     * parse long commands here
+     */
+    switch(_1st){
+        case '0':
+            relayX(0, txt + 1);
+            goto eof;
+        break;
+        case '1':
+            relayX(1, txt + 1);
+            goto eof;
+        break;
+        case 'a':
+            addIGN(txt + 1);
+            goto eof;
+        break;
+        case 'C':
+            CANini(txt + 1);
+            goto eof;
+        break;
+        case 'f':
+            add_filter(txt + 1);
+            goto eof;
+        break;
+        case 'F':
+            set_flood(parseCANmsg(txt + 1));
+            goto eof;
+        break;
+        case 'o':
+            ledsOp(txt + 1, 0);
+            goto eof;
+        break;
+        case 'O':
+            ledsOp(txt + 1, 1);
+            goto eof;
+        break;
+        case 's':
+        case 'S':
+            sendCANcommand(txt + 1);
+            goto eof;
+        break;
+        case 'W':
+            changePWM(txt + 1);
+            goto eof;
+        break;
+    }
+    if(txt[1] != '\n') *txt = '?'; // help for wrong message length
+    switch(_1st){
+        case 'A':
+            printADC();
+            return;
+        break;
+        case 'b':
+            getBtnState();
+        break;
+        case 'd':
+            IgnSz = 0;
+        break;
+#ifdef EBUG
+        case 'D':
+            SEND("Go into DFU mode\n");
+            sendbuf();
+            Jump2Boot();
+        break;
+#endif
+        case 'I':
+            SEND("CAN ID: "); printuhex(CANID);
+        break;
+        case 'l':
+            list_filters();
+        break;
+        case 'm':
+            printVT();
+        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");
+            sendbuf();
+            pause_ms(5); // a little pause to transmit data
+            NVIC_SystemReset();
+        break;
+        case 'T':
+            SEND("Time (ms): ");
+            printu(Tms);
+        break;
+        case 'w':
+            getPWM();
+            return;
+        break;
+        default: // help
+            SEND(
+            "'0' - turn relay0 on(1) or off(0)\n"
+            "'1' - turn relay1 on(1) or off(0)\n"
+            "'a' - add ID to ignore list (max 10 IDs)\n"
+            "'A' - get ADC values @ all 4 channels\n"
+            "'b' - get buttons' state\n"
+            "'C' - reinit CAN with given baudrate\n"
+            "'d' - delete ignore list\n"
+            #ifdef EBUG
+            "'D' - activate DFU mode\n"
+            #endif
+            "'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' - read CAN ID\n"
+            "'l' - list all active filters\n"
+            "'m' - get MCU temp & Vdd\n"
+            "'o' - turn nth LED OFF\n"
+            "'O' - turn nth LED 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' - get time from start (ms)\n"
+            "'w' - get PWM settings\n"
+            "'W' - set PWM @nth channel (ch: 0..2, PWM: 0..255)\n"
+            );
+        break;
+    }
+eof:
+    newline();
+    sendbuf();
+}
+
+// print 32bit unsigned int
+void printu(uint32_t val){
+    char buf[11], *bufptr = &buf[10];
+    *bufptr = 0;
+    if(!val){
+        *(--bufptr) = '0';
+    }else{
+        while(val){
+            *(--bufptr) = val % 10 + '0';
+            val /= 10;
+        }
+    }
+    addtobuf(bufptr);
+}
+
+// print 32bit unsigned int as hex
+void printuhex(uint32_t val){
+    addtobuf("0x");
+    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) bufputchar(half + '0');
+            else bufputchar(half - 10 + 'a');
+        }
+    }
+}
+
+// check Ignore_IDs & return 1 if ID isn't in list
+uint8_t isgood(uint16_t ID){
+    for(int i = 0; i < IgnSz; ++i)
+        if(Ignore_IDs[i] == ID) return 0;
+    return 1;
+}

F0:F030,F042,F072/usbcan_relay/proto.h

@@ -0,0 +1,57 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 __PROTO_H__
+#define __PROTO_H__
+
+#include "stm32f0.h"
+#include "hardware.h"
+
+#define BUFSZ   (64)
+
+// macro for static strings
+#define SEND(str) do{addtobuf(str);}while(0)
+
+#ifdef EBUG
+#define MSG(str)  do{addtobuf(__FILE__ " (L" STR(__LINE__) "): " str);}while(0)
+#else
+#define MSG(str)
+#endif
+
+#define newline() do{bufputchar('\n');}while(0)
+// newline with buffer sending over USART
+#define NL() do{bufputchar('\n'); sendbuf();}while(0)
+
+#define IGN_SIZE 10
+extern uint16_t Ignore_IDs[IGN_SIZE];
+extern uint8_t IgnSz;
+extern uint8_t ShowMsgs;
+
+void cmd_parser(char *buf);
+void addtobuf(const char *txt);
+void bufputchar(char ch);
+void printu(uint32_t val);
+void printuhex(uint32_t val);
+void sendbuf();
+
+char *omit_spaces(const char *buf);
+char *getnum(const char *buf, uint32_t *N);
+
+uint8_t isgood(uint16_t ID);
+
+#endif // __PROTO_H__

F0:F030,F042,F072/usbcan_relay/usb.c

@@ -0,0 +1,175 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 "usb.h"
+#include "usb_lib.h"
+
+static volatile uint8_t tx_succesfull = 1;
+static volatile uint8_t rxNE = 0;
+
+// interrupt IN handler (never used?)
+static void EP1_Handler(){
+    uint16_t epstatus = KEEP_DTOG(USB->EPnR[1]);
+    if(RX_FLAG(epstatus)) epstatus = (epstatus & ~USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_RX; // set valid RX
+    else epstatus = epstatus & ~(USB_EPnR_STAT_TX|USB_EPnR_STAT_RX);
+    // clear CTR
+    epstatus = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX));
+    USB->EPnR[1] = epstatus;
+}
+
+// data IN/OUT handlers
+static void transmit_Handler(){ // EP3IN
+    tx_succesfull = 1;
+    uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[3]);
+    // clear CTR keep DTOGs & STATs
+    USB->EPnR[3] = (epstatus & ~(USB_EPnR_CTR_TX)); // clear TX ctr
+}
+
+static void receive_Handler(){ // EP2OUT
+    rxNE = 1;
+    uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[2]);
+    USB->EPnR[2] = (epstatus & ~(USB_EPnR_CTR_RX)); // clear RX ctr
+}
+
+void USB_setup(){
+    RCC->APB1ENR |= RCC_APB1ENR_CRSEN | RCC_APB1ENR_USBEN; // enable CRS (hsi48 sync) & USB
+    RCC->CFGR3 &= ~RCC_CFGR3_USBSW; // reset USB
+    RCC->CR2 |= RCC_CR2_HSI48ON; // turn ON HSI48
+    uint32_t tmout = 16000000;
+    while(!(RCC->CR2 & RCC_CR2_HSI48RDY)){if(--tmout == 0) break;}
+    FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY;
+    CRS->CFGR &= ~CRS_CFGR_SYNCSRC;
+    CRS->CFGR |= CRS_CFGR_SYNCSRC_1; // USB SOF selected as sync source
+    CRS->CR |= CRS_CR_AUTOTRIMEN; // enable auto trim
+    CRS->CR |= CRS_CR_CEN; // enable freq counter & block CRS->CFGR as read-only
+    RCC->CFGR |= RCC_CFGR_SW;
+    // allow RESET and CTRM interrupts
+    USB->CNTR = USB_CNTR_RESETM | USB_CNTR_WKUPM;
+    // clear flags
+    USB->ISTR = 0;
+    // and activate pullup
+    USB->BCDR |= USB_BCDR_DPPU;
+    NVIC_EnableIRQ(USB_IRQn);
+}
+
+
+static int usbwr(const uint8_t *buf, uint16_t l){
+    uint32_t ctra = 1000000;
+    while(--ctra && tx_succesfull == 0){
+        IWDG->KR = IWDG_REFRESH;
+    }
+    tx_succesfull = 0;
+    EP_Write(3, buf, l);
+    ctra = 1000000;
+    while(--ctra && tx_succesfull == 0){
+        IWDG->KR = IWDG_REFRESH;
+    }
+    if(tx_succesfull == 0){usbON = 0; return 1;} // usb is OFF?
+    return 0;
+}
+
+static uint8_t usbbuff[USB_TXBUFSZ-1]; // temporary buffer (63 - to prevent need of ZLP)
+static uint8_t buflen = 0; // amount of symbols in usbbuff
+
+// send next up to 63 bytes of data in usbbuff
+static void send_next(){
+    if(!buflen || !tx_succesfull) return;
+    tx_succesfull = 0;
+    EP_Write(3, usbbuff, buflen);
+    buflen = 0;
+}
+
+// unblocking sending - just fill a buffer
+void USB_send(const uint8_t *buf, uint16_t len){
+    if(!usbON || !len) return;
+    if(len > USB_TXBUFSZ-1 - buflen){
+        usbwr(usbbuff, buflen);
+        buflen = 0;
+    }
+    if(len > USB_TXBUFSZ-1){
+        USB_send_blk(buf, len);
+        return;
+    }
+    while(len--) usbbuff[buflen++] = *buf++;
+}
+
+// send zero-terminated string
+void USB_sendstr(const char *str){
+    uint16_t l = 0;
+    const char *ptr = str;
+    while(*ptr++) ++l;
+    USB_send((uint8_t*)str, l);
+}
+
+// blocking sending
+void USB_send_blk(const uint8_t *buf, uint16_t len){
+    if(!usbON || !len) return; // USB disconnected
+    if(buflen){
+        usbwr(usbbuff, buflen);
+        buflen = 0;
+    }
+    int needzlp = 0;
+    while(len){
+        if(len == USB_TXBUFSZ) needzlp = 1;
+        uint16_t s = (len > USB_TXBUFSZ) ? USB_TXBUFSZ : len;
+        if(usbwr(buf, s)) return;
+        len -= s;
+        buf += s;
+    }
+    if(needzlp){
+        usbwr(NULL, 0);
+    }
+}
+
+void usb_proc(){
+    switch(USB_Dev.USB_Status){
+        case USB_STATE_CONFIGURED:
+            // make new BULK endpoint
+            // Buffer have 1024 bytes, but last 256 we use for CAN bus (30.2 of RM: USB main features)
+            EP_Init(1, EP_TYPE_INTERRUPT, USB_EP1BUFSZ, 0, EP1_Handler); // IN1 - transmit
+            EP_Init(2, EP_TYPE_BULK, 0, USB_RXBUFSZ, receive_Handler); // OUT2 - receive data
+            EP_Init(3, EP_TYPE_BULK, USB_TXBUFSZ, 0, transmit_Handler); // IN3 - transmit data
+            USB_Dev.USB_Status = USB_STATE_CONNECTED;
+        break;
+        case USB_STATE_DEFAULT:
+        case USB_STATE_ADDRESSED:
+            if(usbON){
+                usbON = 0;
+            }
+        break;
+        default: // USB_STATE_CONNECTED - send next data portion
+            if(!usbON) return;
+            send_next();
+    }
+}
+
+/**
+ * @brief USB_receive
+ * @param buf (i) - buffer[64] for received data
+ * @return amount of received bytes
+ */
+uint8_t USB_receive(uint8_t *buf){
+    if(!usbON || !rxNE) return 0;
+    uint8_t sz = EP_Read(2, buf);
+    uint16_t epstatus = KEEP_DTOG(USB->EPnR[2]);
+    // keep stat_tx & set ACK rx
+    USB->EPnR[2] = (epstatus & ~(USB_EPnR_STAT_TX)) ^ USB_EPnR_STAT_RX;
+    rxNE = 0;
+    return sz;
+}
+

F0:F030,F042,F072/usbcan_relay/usb.h

@@ -0,0 +1,37 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 __USB_H__
+#define __USB_H__
+
+#include "hardware.h"
+
+#define BUFFSIZE   (64)
+
+// send string with constant length
+#define USND(str)  do{USB_send((uint8_t*)str, sizeof(str)-1);}while(0)
+
+void USB_setup();
+void usb_proc();
+void USB_send(const uint8_t *buf, uint16_t len);
+void USB_sendstr(const char *str);
+void USB_send_blk(const uint8_t *buf, uint16_t len);
+uint8_t USB_receive(uint8_t *buf);
+
+#endif // __USB_H__

F0:F030,F042,F072/usbcan_relay/usb_defs.h

@@ -0,0 +1,99 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 __USB_DEFS_H__
+#define __USB_DEFS_H__
+
+#include <stm32f0.h>
+
+// max endpoints number
+#define STM32ENDPOINTS          8
+/**
+ *                 Buffers size definition
+ **/
+// !!! when working with CAN bus change USB_BTABLE_SIZE to 768 !!!
+#define USB_BTABLE_SIZE         768
+// for USB FS EP0 buffers are from 8 to 64 bytes long (64 for PL2303)
+#define USB_EP0_BUFSZ           64
+// USB transmit buffer size (64 for PL2303)
+#define USB_TXBUFSZ             64
+// USB receive buffer size (64 for PL2303)
+#define USB_RXBUFSZ             64
+// EP1 - interrupt - buffer size
+#define USB_EP1BUFSZ            8
+
+#define USB_BTABLE_BASE         0x40006000
+
+#ifdef USB_BTABLE
+#undef USB_BTABLE
+#endif
+#define USB_BTABLE              ((USB_BtableDef *)(USB_BTABLE_BASE))
+#define USB_ISTR_EPID           0x0000000F
+#define USB_FNR_LSOF_0          0x00000800
+#define USB_FNR_lSOF_1          0x00001000
+#define USB_LPMCSR_BESL_0       0x00000010
+#define USB_LPMCSR_BESL_1       0x00000020
+#define USB_LPMCSR_BESL_2       0x00000040
+#define USB_LPMCSR_BESL_3       0x00000080
+#define USB_EPnR_CTR_RX         0x00008000
+#define USB_EPnR_DTOG_RX        0x00004000
+#define USB_EPnR_STAT_RX        0x00003000
+#define USB_EPnR_STAT_RX_0      0x00001000
+#define USB_EPnR_STAT_RX_1      0x00002000
+#define USB_EPnR_SETUP          0x00000800
+#define USB_EPnR_EP_TYPE        0x00000600
+#define USB_EPnR_EP_TYPE_0      0x00000200
+#define USB_EPnR_EP_TYPE_1      0x00000400
+#define USB_EPnR_EP_KIND        0x00000100
+#define USB_EPnR_CTR_TX         0x00000080
+#define USB_EPnR_DTOG_TX        0x00000040
+#define USB_EPnR_STAT_TX        0x00000030
+#define USB_EPnR_STAT_TX_0      0x00000010
+#define USB_EPnR_STAT_TX_1      0x00000020
+#define USB_EPnR_EA             0x0000000F
+#define USB_COUNTn_RX_BLSIZE    0x00008000
+#define USB_COUNTn_NUM_BLOCK    0x00007C00
+#define USB_COUNTn_RX           0x0000003F
+
+#define USB_TypeDef USB_TypeDef_custom
+
+typedef struct{
+    __IO uint32_t EPnR[STM32ENDPOINTS];
+    __IO uint32_t RESERVED[STM32ENDPOINTS];
+    __IO uint32_t CNTR;
+    __IO uint32_t ISTR;
+    __IO uint32_t FNR;
+    __IO uint32_t DADDR;
+    __IO uint32_t BTABLE;
+    __IO uint32_t LPMCSR;
+    __IO uint32_t BCDR;
+} USB_TypeDef;
+
+typedef struct{
+    __IO uint16_t USB_ADDR_TX;
+    __IO uint16_t USB_COUNT_TX;
+    __IO uint16_t USB_ADDR_RX;
+    __IO uint16_t USB_COUNT_RX;
+} USB_EPDATA_TypeDef;
+
+typedef struct{
+    __IO USB_EPDATA_TypeDef EP[STM32ENDPOINTS];
+} USB_BtableDef;
+
+#endif // __USB_DEFS_H__

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

@@ -0,0 +1,468 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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"
+
+ep_t endpoints[STM32ENDPOINTS];
+
+usb_dev_t USB_Dev;
+uint8_t usbON = 0;
+static usb_LineCoding lineCoding = {115200, 0, 0, 8};
+static config_pack_t setup_packet;
+static uint8_t ep0databuf[EP0DATABUF_SIZE];
+static uint8_t ep0dbuflen = 0;
+
+usb_LineCoding getLineCoding(){return lineCoding;}
+
+// definition of parts common for USB_DeviceDescriptor & USB_DeviceQualifierDescriptor
+#define bcdUSB_L        0x10
+#define bcdUSB_H        0x01
+#define bDeviceClass    0
+#define bDeviceSubClass 0
+#define bDeviceProtocol 0
+#define bNumConfigurations 1
+
+static const uint8_t USB_DeviceDescriptor[] = {
+        18,     // bLength
+        0x01,   // bDescriptorType - Device descriptor
+        bcdUSB_L,   // bcdUSB_L - 1.10
+        bcdUSB_H,   // bcdUSB_H
+        bDeviceClass,   // bDeviceClass - USB_COMM
+        bDeviceSubClass,   // bDeviceSubClass
+        bDeviceProtocol,   // bDeviceProtocol
+        USB_EP0_BUFSZ,   // bMaxPacketSize
+        0x7b,   // idVendor_L PL2303: VID=0x067b, PID=0x2303
+        0x06,   // idVendor_H
+        0x03,   // idProduct_L
+        0x23,   // idProduct_H
+        0x00,   // bcdDevice_Ver_L
+        0x03,   // bcdDevice_Ver_H
+        0x01,   // iManufacturer
+        0x02,   // iProduct
+        0x00,   // iSerialNumber
+        bNumConfigurations    // bNumConfigurations
+};
+
+static const uint8_t USB_DeviceQualifierDescriptor[] = {
+        10,     //bLength
+        0x06,   // bDescriptorType - Device qualifier
+        bcdUSB_L,   // bcdUSB_L
+        bcdUSB_H,   // bcdUSB_H
+        bDeviceClass,   // bDeviceClass
+        bDeviceSubClass,   // bDeviceSubClass
+        bDeviceProtocol,   // bDeviceProtocol
+        USB_EP0_BUFSZ,   // bMaxPacketSize0
+        bNumConfigurations,   // bNumConfigurations
+        0x00    // Reserved
+};
+
+static const uint8_t USB_ConfigDescriptor[] = {
+        /*Configuration Descriptor*/
+        0x09, /* bLength: Configuration Descriptor size */
+        0x02, /* bDescriptorType: Configuration */
+        39,   /* wTotalLength:no of returned bytes */
+        0x00,
+        0x01, /* bNumInterfaces: 1 interface */
+        0x01, /* bConfigurationValue: Configuration value */
+        0x00, /* iConfiguration: Index of string descriptor describing the configuration */
+        0xa0, /* bmAttributes - Bus powered, Remote wakeup */
+        0x32, /* MaxPower 100 mA */
+
+        /*---------------------------------------------------------------------------*/
+
+        /*Interface Descriptor */
+        0x09, /* bLength: Interface Descriptor size */
+        0x04, /* bDescriptorType: Interface */
+        0x00, /* bInterfaceNumber: Number of Interface */
+        0x00, /* bAlternateSetting: Alternate setting */
+        0x03, /* bNumEndpoints: 3 endpoints used */
+        0xff, /* bInterfaceClass */
+        0x00, /* bInterfaceSubClass */
+        0x00, /* bInterfaceProtocol */
+        0x00, /* iInterface: */
+///////////////////////////////////////////////////
+        /*Endpoint 1 Descriptor*/
+        0x07, /* bLength: Endpoint Descriptor size */
+        0x05, /* bDescriptorType: Endpoint */
+        0x81, /* bEndpointAddress IN1 */
+        0x03, /* bmAttributes: Interrupt */
+        0x0a, /* wMaxPacketSize LO: */
+        0x00, /* wMaxPacketSize HI: */
+        0x01, /* bInterval: */
+
+        /*Endpoint OUT2 Descriptor*/
+        0x07, /* bLength: Endpoint Descriptor size */
+        0x05, /* bDescriptorType: Endpoint */
+        0x02, /* bEndpointAddress: OUT2 */
+        0x02, /* bmAttributes: Bulk */
+        (USB_RXBUFSZ & 0xff), /* wMaxPacketSize: 64 */
+        (USB_RXBUFSZ >> 8),
+        0x00, /* bInterval: ignore for Bulk transfer */
+
+        /*Endpoint IN3 Descriptor*/
+        0x07, /* bLength: Endpoint Descriptor size */
+        0x05, /* bDescriptorType: Endpoint */
+        0x83, /* bEndpointAddress IN3 */
+        0x02, /* bmAttributes: Bulk */
+        (USB_TXBUFSZ & 0xff), /* wMaxPacketSize: 64 */
+        (USB_TXBUFSZ >> 8),
+        0x00, /* bInterval: ignore for Bulk transfer */
+};
+
+_USB_LANG_ID_(USB_StringLangDescriptor, LANG_US);
+// these descriptors are not used in PL2303 emulator!
+_USB_STRING_(USB_StringSerialDescriptor, u"0");
+_USB_STRING_(USB_StringManufacturingDescriptor, u"Prolific Technology Inc.");
+_USB_STRING_(USB_StringProdDescriptor, u"USB-Serial Controller");
+
+/*
+ * default handlers
+ */
+// SET_LINE_CODING
+void WEAK linecoding_handler(usb_LineCoding __attribute__((unused)) *lc){
+}
+
+// SET_CONTROL_LINE_STATE
+void WEAK clstate_handler(uint16_t __attribute__((unused)) val){
+}
+
+// SEND_BREAK
+void WEAK break_handler(){
+}
+
+// handler of vendor requests
+void WEAK vendor_handler(config_pack_t *packet){
+    if(packet->bmRequestType & 0x80){ // read
+        uint8_t c;
+        switch(packet->wValue){
+            case 0x8484:
+                c = 2;
+            break;
+            case 0x0080:
+                c = 1;
+            break;
+            case 0x8686:
+                c = 0xaa;
+            break;
+            default:
+                c = 0;
+        }
+        EP_WriteIRQ(0, &c, 1);
+    }else{ // write ZLP
+        EP_WriteIRQ(0, (uint8_t *)0, 0);
+    }
+}
+
+static void wr0(const uint8_t *buf, uint16_t size){
+    if(setup_packet.wLength < size) size = setup_packet.wLength; // shortened request
+    if(size < endpoints[0].txbufsz){
+        EP_WriteIRQ(0, buf, size);
+        return;
+    }
+    while(size){
+        uint16_t l = size;
+        if(l > endpoints[0].txbufsz) l = endpoints[0].txbufsz;
+        EP_WriteIRQ(0, buf, l);
+        buf += l;
+        size -= l;
+        uint8_t needzlp = (l == endpoints[0].txbufsz) ? 1 : 0;
+        if(size || needzlp){ // send last data buffer
+            uint16_t status = KEEP_DTOG(USB->EPnR[0]);
+            // keep DTOGs, clear CTR_RX,TX, set TX VALID, leave stat_Rx
+            USB->EPnR[0] = (status & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX|USB_EPnR_STAT_RX))
+                            ^ USB_EPnR_STAT_TX;
+            uint32_t ctr = 1000000;
+            while(--ctr && (USB->ISTR & USB_ISTR_CTR) == 0){IWDG->KR = IWDG_REFRESH;};
+            if((USB->ISTR & USB_ISTR_CTR) == 0){
+                return;
+            }
+            if(needzlp) EP_WriteIRQ(0, (uint8_t*)0, 0);
+        }
+    }
+}
+
+static inline void get_descriptor(){
+    switch(setup_packet.wValue){
+        case DEVICE_DESCRIPTOR:
+            wr0(USB_DeviceDescriptor, sizeof(USB_DeviceDescriptor));
+        break;
+        case CONFIGURATION_DESCRIPTOR:
+            wr0(USB_ConfigDescriptor, sizeof(USB_ConfigDescriptor));
+        break;
+        case STRING_LANG_DESCRIPTOR:
+            wr0((const uint8_t *)&USB_StringLangDescriptor, STRING_LANG_DESCRIPTOR_SIZE_BYTE);
+        break;
+        case STRING_MAN_DESCRIPTOR:
+            wr0((const uint8_t *)&USB_StringManufacturingDescriptor, USB_StringManufacturingDescriptor.bLength);
+        break;
+        case STRING_PROD_DESCRIPTOR:
+            wr0((const uint8_t *)&USB_StringProdDescriptor, USB_StringProdDescriptor.bLength);
+        break;
+        case STRING_SN_DESCRIPTOR:
+            wr0((const uint8_t *)&USB_StringSerialDescriptor, USB_StringSerialDescriptor.bLength);
+        break;
+        case DEVICE_QUALIFIER_DESCRIPTOR:
+            wr0(USB_DeviceQualifierDescriptor, USB_DeviceQualifierDescriptor[0]);
+        break;
+        default:
+        break;
+    }
+}
+
+static uint8_t configuration = 0; // reply for GET_CONFIGURATION (==1 if configured)
+static inline void std_d2h_req(){
+    uint16_t status = 0; // bus powered
+    switch(setup_packet.bRequest){
+        case GET_DESCRIPTOR:
+            get_descriptor();
+        break;
+        case GET_STATUS:
+            EP_WriteIRQ(0, (uint8_t *)&status, 2); // send status: Bus Powered
+        break;
+        case GET_CONFIGURATION:
+            EP_WriteIRQ(0, &configuration, 1);
+        break;
+        default:
+        break;
+    }
+}
+
+static inline void std_h2d_req(){
+    switch(setup_packet.bRequest){
+        case SET_ADDRESS:
+            // new address will be assigned later - after  acknowlegement or request to host
+            USB_Dev.USB_Addr = setup_packet.wValue;
+        break;
+        case SET_CONFIGURATION:
+            // Now device configured
+            USB_Dev.USB_Status = USB_STATE_CONFIGURED;
+            configuration = setup_packet.wValue;
+        break;
+        default:
+        break;
+    }
+}
+
+/*
+bmRequestType: 76543210
+7    direction: 0 - host->device, 1 - device->host
+65   type: 0 - standard, 1 - class, 2 - vendor
+4..0 getter: 0 - device, 1 - interface, 2 - endpoint, 3 - other
+*/
+/**
+ * Endpoint0 (control) handler
+ */
+static void EP0_Handler(){
+    uint16_t epstatus = USB->EPnR[0]; // EP0R on input -> return this value after modifications
+    uint8_t reqtype = setup_packet.bmRequestType & 0x7f;
+    uint8_t dev2host = (setup_packet.bmRequestType & 0x80) ? 1 : 0;
+    int rxflag = RX_FLAG(epstatus);
+    if(rxflag && SETUP_FLAG(epstatus)){
+        switch(reqtype){
+            case STANDARD_DEVICE_REQUEST_TYPE: // standard device request
+                if(dev2host){
+                    std_d2h_req();
+                }else{
+                    std_h2d_req();
+                    EP_WriteIRQ(0, (uint8_t *)0, 0);
+                }
+            break;
+            case STANDARD_ENDPOINT_REQUEST_TYPE: // standard endpoint request
+                if(setup_packet.bRequest == CLEAR_FEATURE){
+                    EP_WriteIRQ(0, (uint8_t *)0, 0);
+                }
+            break;
+            case VENDOR_REQUEST_TYPE:
+                vendor_handler(&setup_packet);
+            break;
+            case CONTROL_REQUEST_TYPE:
+                switch(setup_packet.bRequest){
+                    case GET_LINE_CODING:
+                        EP_WriteIRQ(0, (uint8_t*)&lineCoding, sizeof(lineCoding));
+                    break;
+                    case SET_LINE_CODING: // omit this for next stage, when data will come
+                    break;
+                    case SET_CONTROL_LINE_STATE:
+                        usbON = 1;
+                        clstate_handler(setup_packet.wValue);
+                    break;
+                    case SEND_BREAK:
+                        usbON = 0;
+                        break_handler();
+                    break;
+                    default:
+                    break;
+                }
+                if(setup_packet.bRequest != GET_LINE_CODING) EP_WriteIRQ(0, (uint8_t *)0, 0); // write acknowledgement
+            break;
+            default:
+                EP_WriteIRQ(0, (uint8_t *)0, 0);
+        }
+    }else if(rxflag){ // got data over EP0 or host acknowlegement
+        if(endpoints[0].rx_cnt){
+            if(setup_packet.bRequest == SET_LINE_CODING){
+                linecoding_handler((usb_LineCoding*)ep0databuf);
+            }
+        }
+    } else if(TX_FLAG(epstatus)){ // package transmitted
+        // now we can change address after enumeration
+        if ((USB->DADDR & USB_DADDR_ADD) != USB_Dev.USB_Addr){
+            USB->DADDR = USB_DADDR_EF | USB_Dev.USB_Addr;
+            // change state to ADRESSED
+            USB_Dev.USB_Status = USB_STATE_ADDRESSED;
+        }
+    }
+    epstatus = KEEP_DTOG(USB->EPnR[0]);
+    if(rxflag) epstatus ^= USB_EPnR_STAT_TX; // start ZLP/data transmission
+    else epstatus &= ~USB_EPnR_STAT_TX; // or leave unchanged
+    // keep DTOGs, clear CTR_RX,TX, set RX VALID
+    USB->EPnR[0] = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_RX;
+}
+
+static uint16_t lastaddr = LASTADDR_DEFAULT;
+/**
+ * Endpoint initialisation
+ * !!! when working with CAN bus change USB_BTABLE_SIZE to 768 !!!
+ * @param number - EP num (0...7)
+ * @param type - EP type (EP_TYPE_BULK, EP_TYPE_CONTROL, EP_TYPE_ISO, EP_TYPE_INTERRUPT)
+ * @param txsz - transmission buffer size @ USB/CAN buffer
+ * @param rxsz - reception buffer size @ USB/CAN buffer
+ * @param uint16_t (*func)(ep_t *ep) - EP handler function
+ * @return 0 if all OK
+ */
+int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)()){
+    if(number >= STM32ENDPOINTS) return 4; // out of configured amount
+    if(txsz > USB_BTABLE_SIZE || rxsz > USB_BTABLE_SIZE) return 1; // buffer too large
+    if(lastaddr + txsz + rxsz >= USB_BTABLE_SIZE) return 2; // out of btable
+    USB->EPnR[number] = (type << 9) | (number & USB_EPnR_EA);
+    USB->EPnR[number] ^= USB_EPnR_STAT_RX | USB_EPnR_STAT_TX_1;
+    if(rxsz & 1 || rxsz > 512) return 3; // wrong rx buffer size
+    uint16_t countrx = 0;
+    if(rxsz < 64) countrx = rxsz / 2;
+    else{
+        if(rxsz & 0x1f) return 3; // should be multiple of 32
+        countrx = 31 + rxsz / 32;
+    }
+    USB_BTABLE->EP[number].USB_ADDR_TX = lastaddr;
+    endpoints[number].tx_buf = (uint16_t *)(USB_BTABLE_BASE + lastaddr);
+    endpoints[number].txbufsz = txsz;
+    lastaddr += txsz;
+    USB_BTABLE->EP[number].USB_COUNT_TX = 0;
+    USB_BTABLE->EP[number].USB_ADDR_RX = lastaddr;
+    endpoints[number].rx_buf = (uint8_t *)(USB_BTABLE_BASE + lastaddr);
+    lastaddr += rxsz;
+    // buffer size: Table127 of RM
+    USB_BTABLE->EP[number].USB_COUNT_RX = countrx << 10;
+    endpoints[number].func = func;
+    return 0;
+}
+
+// standard IRQ handler
+void usb_isr(){
+    if (USB->ISTR & USB_ISTR_RESET){
+        // Reinit registers
+        USB->CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM | USB_CNTR_SUSPM | USB_CNTR_WKUPM;
+        USB->ISTR = 0;
+        // Endpoint 0 - CONTROL
+        // ON USB LS size of EP0 may be 8 bytes, but on FS it should be 64 bytes!
+        lastaddr = LASTADDR_DEFAULT; // roll back to beginning of buffer
+        EP_Init(0, EP_TYPE_CONTROL, USB_EP0_BUFSZ, USB_EP0_BUFSZ, EP0_Handler);
+        // clear address, leave only enable bit
+        USB->DADDR = USB_DADDR_EF;
+        // state is default - wait for enumeration
+        USB_Dev.USB_Status = USB_STATE_DEFAULT;
+    }
+    if(USB->ISTR & USB_ISTR_CTR){
+        // EP number
+        uint8_t n = USB->ISTR & USB_ISTR_EPID;
+        // copy status register
+        uint16_t epstatus = USB->EPnR[n];
+        // copy received bytes amount
+        endpoints[n].rx_cnt = USB_BTABLE->EP[n].USB_COUNT_RX & 0x3FF; // low 10 bits is counter
+        // check direction
+        if(USB->ISTR & USB_ISTR_DIR){ // OUT interrupt - receive data, CTR_RX==1 (if CTR_TX == 1 - two pending transactions: receive following by transmit)
+            if(n == 0){ // control endpoint
+                if(epstatus & USB_EPnR_SETUP){ // setup packet -> copy data to conf_pack
+                    EP_Read(0, (uint8_t*)&setup_packet);
+                    ep0dbuflen = 0;
+                    // interrupt handler will be called later
+                }else if(epstatus & USB_EPnR_CTR_RX){ // data packet -> push received data to ep0databuf
+                    ep0dbuflen = endpoints[0].rx_cnt;
+                    EP_Read(0, (uint8_t*)&ep0databuf);
+                }
+            }
+        }
+        // call EP handler
+        if(endpoints[n].func) endpoints[n].func(endpoints[n]);
+    }
+    if(USB->ISTR & USB_ISTR_SUSP){ // suspend -> still no connection, may sleep
+        usbON = 0;
+        USB->CNTR |= USB_CNTR_FSUSP | USB_CNTR_LPMODE;
+        USB->ISTR = ~USB_ISTR_SUSP;
+    }
+    if(USB->ISTR & USB_ISTR_WKUP){ // wakeup
+        USB->CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LPMODE); // clear suspend flags
+        USB->ISTR = ~USB_ISTR_WKUP;
+    }
+}
+
+/**
+ * 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){
+    uint8_t i;
+    if(size > USB_TXBUFSZ) size = USB_TXBUFSZ;
+    uint16_t N2 = (size + 1) >> 1;
+    // the buffer is 16-bit, so we should copy data as it would be uint16_t
+    uint16_t *buf16 = (uint16_t *)buf;
+    for (i = 0; i < N2; i++){
+        endpoints[number].tx_buf[i] = buf16[i];
+    }
+    USB_BTABLE->EP[number].USB_COUNT_TX = size;
+}
+
+/**
+ * Write data to EP buffer (called outside IRQ handler)
+ * @param number - EP number
+ * @param *buf - array with data
+ * @param size - its size
+ */
+void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size){
+    EP_WriteIRQ(number, buf, size);
+    uint16_t status = KEEP_DTOG(USB->EPnR[number]);
+    // keep DTOGs, clear CTR_TX & set TX VALID to start transmission
+    USB->EPnR[number] = (status & ~(USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_TX;
+}
+
+/*
+ * Copy data from EP buffer into user buffer area
+ * @param *buf - user array for data
+ * @return amount of data read
+ */
+int EP_Read(uint8_t number, uint8_t *buf){
+    int n = endpoints[number].rx_cnt;
+    if(n){
+        for(int i = 0; i < n; ++i)
+            buf[i] = endpoints[number].rx_buf[i];
+    }
+    return n;
+}

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

@@ -0,0 +1,184 @@
+/*
+ * This file is part of the canrelay project.
+ * Copyright 2021 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 __USB_LIB_H__
+#define __USB_LIB_H__
+
+#include <wchar.h>
+#include "usb_defs.h"
+
+#define EP0DATABUF_SIZE                 (64)
+#define LASTADDR_DEFAULT                (STM32ENDPOINTS * 8)
+
+// bmRequestType & 0x7f
+#define STANDARD_DEVICE_REQUEST_TYPE    0
+#define STANDARD_ENDPOINT_REQUEST_TYPE  2
+#define VENDOR_REQUEST_TYPE             0x40
+#define CONTROL_REQUEST_TYPE            0x21
+// bRequest, standard; for bmRequestType == 0x80
+#define GET_STATUS                      0x00
+#define GET_DESCRIPTOR                  0x06
+#define GET_CONFIGURATION               0x08
+// for bmRequestType == 0
+#define CLEAR_FEATURE                   0x01
+#define SET_FEATURE                     0x03    // unused
+#define SET_ADDRESS                     0x05
+#define SET_DESCRIPTOR                  0x07    // unused
+#define SET_CONFIGURATION               0x09
+// for bmRequestType == 0x81, 1 or 0xB2
+#define GET_INTERFACE                   0x0A    // unused
+#define SET_INTERFACE                   0x0B    // unused
+#define SYNC_FRAME                      0x0C    // unused
+#define VENDOR_REQUEST                  0x01    // unused
+
+// Class-Specific Control Requests
+#define SEND_ENCAPSULATED_COMMAND       0x00    // unused
+#define GET_ENCAPSULATED_RESPONSE       0x01    // unused
+#define SET_COMM_FEATURE                0x02    // unused
+#define GET_COMM_FEATURE                0x03    // unused
+#define CLEAR_COMM_FEATURE              0x04    // unused
+#define SET_LINE_CODING                 0x20
+#define GET_LINE_CODING                 0x21
+#define SET_CONTROL_LINE_STATE          0x22
+#define SEND_BREAK                      0x23
+
+// control line states
+#define CONTROL_DTR                     0x01
+#define CONTROL_RTS                     0x02
+
+// wValue
+#define DEVICE_DESCRIPTOR               0x100
+#define CONFIGURATION_DESCRIPTOR        0x200
+#define STRING_LANG_DESCRIPTOR          0x300
+#define STRING_MAN_DESCRIPTOR           0x301
+#define STRING_PROD_DESCRIPTOR          0x302
+#define STRING_SN_DESCRIPTOR            0x303
+#define DEVICE_QUALIFIER_DESCRIPTOR     0x600
+
+#define RX_FLAG(epstat)                 (epstat & USB_EPnR_CTR_RX)
+#define TX_FLAG(epstat)                 (epstat & USB_EPnR_CTR_TX)
+#define SETUP_FLAG(epstat)              (epstat & USB_EPnR_SETUP)
+
+// EPnR bits manipulation
+#define KEEP_DTOG_STAT(EPnR)            (EPnR & ~(USB_EPnR_STAT_RX|USB_EPnR_STAT_TX|USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX))
+#define KEEP_DTOG(EPnR)                 (EPnR & ~(USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX))
+
+// USB state: uninitialized, addressed, ready for use, client connected
+typedef enum{
+    USB_STATE_DEFAULT,
+    USB_STATE_ADDRESSED,
+    USB_STATE_CONFIGURED,
+    USB_STATE_CONNECTED
+} USB_state;
+
+// EP types
+#define EP_TYPE_BULK                    0x00
+#define EP_TYPE_CONTROL                 0x01
+#define EP_TYPE_ISO                     0x02
+#define EP_TYPE_INTERRUPT               0x03
+
+#define LANG_US (uint16_t)0x0409
+
+#define _USB_STRING_(name, str)                  \
+static const struct name \
+{                          \
+        uint8_t  bLength;                       \
+        uint8_t  bDescriptorType;               \
+        uint16_t bString[(sizeof(str) - 2) / 2]; \
+    \
+} \
+name = {sizeof(name), 0x03, str}
+
+#define _USB_LANG_ID_(name, lng_id)     \
+    \
+static const struct name \
+{         \
+        uint8_t  bLength;         \
+        uint8_t  bDescriptorType; \
+        uint16_t bString;         \
+    \
+} \
+name = {0x04, 0x03, lng_id}
+#define STRING_LANG_DESCRIPTOR_SIZE_BYTE    (4)
+
+// EP0 configuration packet
+typedef struct {
+    uint8_t bmRequestType;
+    uint8_t bRequest;
+    uint16_t wValue;
+    uint16_t wIndex;
+    uint16_t wLength;
+} config_pack_t;
+
+// endpoints state
+typedef struct __ep_t{
+    uint16_t *tx_buf;           // transmission buffer address
+    uint16_t txbufsz;           // transmission buffer size
+    uint8_t *rx_buf;            // reception buffer address
+    void (*func)();             // endpoint action function
+    uint16_t rx_cnt;            // received data counter
+} ep_t;
+
+// USB status & its address
+typedef struct {
+    uint8_t  USB_Status;
+    uint16_t USB_Addr;
+}usb_dev_t;
+
+typedef struct {
+    uint32_t dwDTERate;
+    uint8_t bCharFormat;
+    #define USB_CDC_1_STOP_BITS   0
+    #define USB_CDC_1_5_STOP_BITS 1
+    #define USB_CDC_2_STOP_BITS   2
+    uint8_t bParityType;
+    #define USB_CDC_NO_PARITY     0
+    #define USB_CDC_ODD_PARITY    1
+    #define USB_CDC_EVEN_PARITY   2
+    #define USB_CDC_MARK_PARITY   3
+    #define USB_CDC_SPACE_PARITY  4
+    uint8_t bDataBits;
+} __attribute__ ((packed)) usb_LineCoding;
+
+typedef struct {
+    uint8_t   bmRequestType;
+    uint8_t   bNotificationType;
+    uint16_t  wValue;
+    uint16_t  wIndex;
+    uint16_t  wLength;
+} __attribute__ ((packed)) usb_cdc_notification;
+
+extern ep_t endpoints[];
+extern usb_dev_t USB_Dev;
+extern uint8_t usbON;
+
+void USB_Init();
+uint8_t USB_GetState();
+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);
+usb_LineCoding getLineCoding();
+
+void linecoding_handler(usb_LineCoding *lc);
+void clstate_handler(uint16_t val);
+void break_handler();
+void vendor_handler(config_pack_t *packet);
+
+#endif // __USB_LIB_H__