diff --git a/F1:F103/I2Cscan/I2Cscan.bin b/F1:F103/I2Cscan/I2Cscan.bin
index 5a343cd..ed46439 100755
Binary files a/F1:F103/I2Cscan/I2Cscan.bin and b/F1:F103/I2Cscan/I2Cscan.bin differ
diff --git a/F1:F103/I2Cscan/Makefile b/F1:F103/I2Cscan/Makefile
index 48f0ae7..90c6002 100644
--- a/F1:F103/I2Cscan/Makefile
+++ b/F1:F103/I2Cscan/Makefile
@@ -1,139 +1,9 @@
-BINARY		= I2Cscan
-BOOTPORT	?= /dev/ttyUSB0
-BOOTSPEED	?= 115200
-# MCU FAMILY
-FAMILY		?= F1
+BINARY      := I2Cscan
 # MCU code
-MCU			?= F103x8
-# density (stm32f10x.h, lines 70-84)
-DENSITY 	?= MD
+MCU         ?= F103x6
 # change this linking script depending on particular MCU model,
-LDSCRIPT	?= stm32f103x8.ld
-# debug
-#DEFS		= -DEBUG
+LDSCRIPT    ?= stm32f103x6.ld
+DEFINES := -DSTM32F10X_LD 
 
-INDEPENDENT_HEADERS=
-
-FP_FLAGS	?= -msoft-float -mfloat-abi=soft
-ASM_FLAGS	?= -mthumb -mcpu=cortex-m3 -mfix-cortex-m3-ldrd
-ARCH_FLAGS	= $(ASM_FLAGS) $(FP_FLAGS)
-
-###############################################################################
-# Executables
-#PREFIX		?= arm-none-eabi
-# gcc from arm web site 
-PREFIX		?= /opt/bin/arm-none-eabi
-TOOLCHLIB	?= /opt/arm-none-eabi/lib
-RM			:= rm -f
-RMDIR		:= rmdir
-CC			:= $(PREFIX)-gcc
-# don't replace ld with gcc: the binary size would be much greater!!
-LD			:= $(PREFIX)-ld
-AR			:= $(PREFIX)-ar
-AS			:= $(PREFIX)-as
-SIZE 		:= $(PREFIX)-size
-OBJCOPY		:= $(PREFIX)-objcopy
-OBJDUMP		:= $(PREFIX)-objdump
-GDB			:= $(PREFIX)-gdb
-STFLASH		:= $(shell which st-flash)
-STBOOT		:= $(shell which stm32flash)
-DFUUTIL		:= $(shell which dfu-util)
-
-###############################################################################
-# Source files
-OBJDIR 		= mk
-SRC			:= $(wildcard *.c)
-OBJS		:= $(addprefix $(OBJDIR)/, $(SRC:%.c=%.o))
-STARTUP		= $(OBJDIR)/startup.o
-OBJS 		+= $(STARTUP)
-# dependencies: we need them to recompile files if their headers-dependencies changed
-DEPS		:= $(OBJS:.o=.d)
-
-INC_DIR ?= ../inc
-
-INCLUDE 	:= -I$(INC_DIR)/Fx -I$(INC_DIR)/cm
-LIB_DIR		:= $(INC_DIR)/ld
-
-###############################################################################
-# C flags
-CFLAGS		+= -O2 -g -D__thumb2__=1 -MD
-CFLAGS		+= -Wall -Werror -Wextra -Wshadow 
-CFLAGS		+= -fno-common -ffunction-sections -fdata-sections -fno-stack-protector
-CFLAGS		+=  $(ARCH_FLAGS)
-
-###############################################################################
-# Linker flags
-LDFLAGS		+= -nostartfiles --static -nostdlibs 
-LDFLAGS		+= -L$(LIB_DIR) -L$(TOOLCHLIB)
-LDFLAGS		+= -T$(LDSCRIPT)
-
-###############################################################################
-# Used libraries
-LDLIBS		+=  -lc $(shell $(CC) $(CFLAGS) -print-libgcc-file-name)
-
-DEFS		+= -DSTM32$(FAMILY) -DSTM32$(MCU) -DSTM32F10X_$(DENSITY)
-
-ELF		:= $(OBJDIR)/$(BINARY).elf
-LIST	:= $(OBJDIR)/$(BINARY).list
-BIN		:= $(BINARY).bin
-HEX		:= $(BINARY).hex
-
-all: bin list size
-
-elf: $(ELF)
-bin: $(BIN)
-hex: $(HEX)
-list: $(LIST)
-
-ifneq ($(MAKECMDGOALS),clean)
--include $(DEPS)
-endif
-
-$(OBJDIR):
-	mkdir $(OBJDIR)
-
-$(STARTUP): $(INC_DIR)/startup/vector.c
-	$(CC) $(CFLAGS) $(DEFS) $(INCLUDE) -o $@ -c $<
-
-$(OBJDIR)/%.o: %.c
-	@echo "  CC      $<"
-	$(CC) $(CFLAGS) $(DEFS) $(INCLUDE) -o $@ -c $<
-
-$(BIN): $(ELF)
-	@echo "  OBJCOPY $(BIN)"
-	$(OBJCOPY) -Obinary $(ELF) $(BIN)
-
-$(HEX): $(ELF)
-	@echo "  OBJCOPY $(HEX)"
-	$(OBJCOPY) -Oihex $(ELF) $(HEX)
-
-$(LIST): $(ELF)
-	@echo "  OBJDUMP $(LIST)"
-	$(OBJDUMP) -S $(ELF) > $(LIST)
-
-$(ELF): $(OBJDIR) $(OBJS)
-	@echo "  LD      $(ELF)"
-	$(LD) $(LDFLAGS) $(OBJS) $(LDLIBS) -o $(ELF)
-
-size: $(ELF)
-	$(SIZE) $(ELF)    
-
-clean:
-	@echo "  CLEAN"
-	$(RM) $(OBJS) $(DEPS) $(ELF) $(HEX) $(LIST)
-	@rmdir $(OBJDIR) 2>/dev/null || true
-
-
-flash: $(BIN)
-	@echo "  FLASH  $(BIN)"
-	$(STFLASH) write $(BIN) 0x8000000
-
-boot: $(BIN)
-	@echo "  LOAD $(BIN) through bootloader"
-	$(STBOOT) -b$(BOOTSPEED) $(BOOTPORT) -w $(BIN)
-
-dfuboot: $(BIN)
-	@echo "  LOAD  $(BIN) THROUGH DFU"
-	$(DFUUTIL) -a0 -D $(BIN) -s 0x08000000
-
-.PHONY: clean flash boot
+include ../makefile.f1
+include ../../makefile.stm32
diff --git a/F1:F103/I2Cscan/main.c b/F1:F103/I2Cscan/main.c
index b57a7ba..70e6949 100644
--- a/F1:F103/I2Cscan/main.c
+++ b/F1:F103/I2Cscan/main.c
@@ -32,28 +32,8 @@ void sys_tick_handler(void){
     ++Tms;
 }
 
-// usb getline
-static char *get_USB(){
-    static char tmpbuf[USBBUFSZ+1], *curptr = tmpbuf;
-    static int rest = USBBUFSZ;
-    int x = USB_receive(curptr);
-    curptr[x] = 0;
-    if(!x) return NULL;
-    if(curptr[x-1] == '\n'){
-        curptr = tmpbuf;
-        rest = USBBUFSZ;
-        return tmpbuf;
-    }
-    curptr += x; rest -= x;
-    if(rest <= 0){ // buffer overflow
-        curptr = tmpbuf;
-        rest = USBBUFSZ;
-        USB_send("USB buffer overflow\n");
-    }
-    return NULL;
-}
-
 int main(void){
+	char buf[256];
     uint32_t lastT = 0;
     sysreset();
     StartHSE();
@@ -74,25 +54,23 @@ int main(void){
             LED_blink(LED0);
             lastT = Tms;
         }
-        usb_proc();
         if(scanmode){ // get next address & print it
             uint8_t addr;
-            int ok = scan_next_addr(&addr);
-            if(addr == I2C_ADDREND) USB_send("Scan ends\n");
+            int ok = i2c_scan_next_addr(&addr);
+            if(addr == I2C_ADDREND) USB_sendstr("Scan ends\n");
             else if(ok){
-                USB_send(u2hexstr(addr));
-                USB_send(" ("); USB_send(u2str(addr));
-                USB_send(") - found device\n");
+                USB_sendstr(u2hexstr(addr));
+                USB_sendstr(" ("); USB_sendstr(u2str(addr));
+                USB_sendstr(") - found device\n");
             }
         }
-        char *txt, *ans;
-        if((txt = get_USB())){
+        if(USB_receivestr(buf, 255)){
             IWDG->KR = IWDG_REFRESH;
-            ans = (char*)parse_cmd(txt);
+            char *ans = (char*)parse_cmd(buf);
             if(ans){
                 uint16_t l = 0; char *p = ans;
                 while(*p++) l++;
-                USB_send(ans);
+                USB_sendstr(ans);
             }
         }
     }
diff --git a/F1:F103/I2Cscan/proto.c b/F1:F103/I2Cscan/proto.c
index 4d261d6..c6e8b7f 100644
--- a/F1:F103/I2Cscan/proto.c
+++ b/F1:F103/I2Cscan/proto.c
@@ -1,281 +1,283 @@
-/*
- * This file is part of the I2Cscan project.
- * Copyright 2020 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 "i2cscan.h"
-#include "i2c.h"
-#include "proto.h"
-#include "usb.h"
-
-extern volatile uint32_t Tms;
-
-char *omit_spaces(const char *buf){
-    while(*buf){
-        if(*buf > ' ') break;
-        ++buf;
-    }
-    return (char*)buf;
-}
-
-// In case of overflow return `buf` and N==0xffffffff
-// read decimal number & return pointer to next non-number symbol
-static char *getdec(const char *buf, uint32_t *N){
-    char *start = (char*)buf;
-    uint32_t num = 0;
-    while(*buf){
-        char c = *buf;
-        if(c < '0' || c > '9'){
-            break;
-        }
-        if(num > 429496729 || (num == 429496729 && c > '5')){ // overflow
-            *N = 0xffffff;
-            return start;
-        }
-        num *= 10;
-        num += c - '0';
-        ++buf;
-    }
-    *N = num;
-    return (char*)buf;
-}
-// read hexadecimal number (without 0x prefix!)
-static char *gethex(const char *buf, uint32_t *N){
-    char *start = (char*)buf;
-    uint32_t num = 0;
-    while(*buf){
-        char c = *buf;
-        uint8_t M = 0;
-        if(c >= '0' && c <= '9'){
-            M = '0';
-        }else if(c >= 'A' && c <= 'F'){
-            M = 'A' - 10;
-        }else if(c >= 'a' && c <= 'f'){
-            M = 'a' - 10;
-        }
-        if(M){
-            if(num & 0xf0000000){ // overflow
-                *N = 0xffffff;
-                return start;
-            }
-            num <<= 4;
-            num += c - M;
-        }else{
-            break;
-        }
-        ++buf;
-    }
-    *N = num;
-    return (char*)buf;
-}
-// read octal number (without 0 prefix!)
-static char *getoct(const char *buf, uint32_t *N){
-    char *start = (char*)buf;
-    uint32_t num = 0;
-    while(*buf){
-        char c = *buf;
-        if(c < '0' || c > '7'){
-            break;
-        }
-        if(num & 0xe0000000){ // overflow
-            *N = 0xffffff;
-            return start;
-        }
-        num <<= 3;
-        num += c - '0';
-        ++buf;
-    }
-    *N = num;
-    return (char*)buf;
-}
-// read binary number (without b prefix!)
-static char *getbin(const char *buf, uint32_t *N){
-    char *start = (char*)buf;
-    uint32_t num = 0;
-    while(*buf){
-        char c = *buf;
-        if(c < '0' || c > '1'){
-            break;
-        }
-        if(num & 0x80000000){ // overflow
-            *N = 0xffffff;
-            return start;
-        }
-        num <<= 1;
-        if(c == '1') num |= 1;
-        ++buf;
-    }
-    *N = num;
-    return (char*)buf;
-}
-
-/**
- * @brief getnum - read uint32_t from string (dec, hex or bin: 127, 0x7f, 0b1111111)
- * @param buf - buffer with number and so on
- * @param N   - the number read
- * @return pointer to first non-number symbol in buf
- *      (if it is == buf, there's no number or if *N==0xffffffff there was overflow)
- */
-char *getnum(const char *txt, uint32_t *N){
-    char *nxt = NULL;
-    char *s = omit_spaces(txt);
-    if(*s == '0'){ // hex, oct or 0
-        if(s[1] == 'x' || s[1] == 'X'){ // hex
-            nxt = gethex(s+2, N);
-            if(nxt == s+2) nxt = (char*)txt;
-        }else if(s[1] > '0'-1 && s[1] < '8'){ // oct
-            nxt = getoct(s+1, N);
-            if(nxt == s+1) nxt = (char*)txt;
-        }else{ // 0
-            nxt = s+1;
-            *N = 0;
-        }
-    }else if(*s == 'b' || *s == 'B'){
-        nxt = getbin(s+1, N);
-        if(nxt == s+1) nxt = (char*)txt;
-    }else{
-        nxt = getdec(s, N);
-        if(nxt == s) nxt = (char*)txt;
-    }
-    return nxt;
-}
-
-static void displaydata(uint8_t *data, int start, int N){
-    if(N == 0){
-        USB_send("Done\n");
-        return;
-    }
-    USB_send("Got:\naddr\tval(x)\tval(d)\n");
-    for(int i = 0; i < N; ++i){
-        USB_send(u2hexstr(i+start)); USB_send("\t");
-        USB_send(u2hexstr(data[i])); USB_send("\t");
-        USB_send(u2str(data[i])); USB_send("\n");
-    }
-}
-
-const char* helpmsg =
-    "'Aa'- set I2C 7bit address a\n"
-    "'I' - reinit i2c\n"
-    "'Rrn'- read Nnbytes (<256) from register r\n"
-    "'S' - scan I2C bus\n"
-    "'Wrb'- write b to register r\n"
-;
-
-const char *parse_cmd(const char *buf){
-    if(buf[1] == '\n'){ // one symbol commands
-        switch(*buf){
-            case 'I':
-                i2c_setup();
-                return "Reinit\n";
-            break;
-            case 'S':
-                init_scan_mode();
-                return "Scan mode\n";
-            break;
-            default:
-                return helpmsg;
-        }
-        return NULL;
-    }
-    uint32_t Num = 0;
-    uint8_t n, data[128];
-    char *bufori = (char*)buf, *ptr;
-    switch(*buf){ // long messages
-        case 'A':
-            ++buf;
-            if(buf != getnum(buf, &Num)){
-                if(Num & 0x80) return "Enter 7bit address\n";
-                i2c_set_addr7(Num);
-                return "Changed\n";
-            }else return "Wrong filter number";
-        break;
-        case 'R':
-            ++buf;
-            if(buf != (ptr = getnum(buf, &Num))){
-                n = Num;
-                if(ptr != getnum(ptr, &Num)){
-                    if(Num > 128) return "Not more than 128 bytes\n";
-                    if(read_reg(n, data, Num)) displaydata(data, n, Num);
-                    else return "Error\n";
-                }else return "Need data amount to read\n";
-            }else return "Need register address\n";
-        break;
-        case 'W':
-            ++buf;
-            if(buf != (ptr = getnum(buf, &Num))){
-                n = Num;
-                if(ptr != getnum(ptr, &Num)){
-                    if(write_reg(n, Num)) return "Sent\n";
-                    else return "Error\n";
-                }else return "Need data to write\n";
-            }else return "Need register address\n";
-        break;
-        default:
-            return bufori;
-    }
-    return NULL;
-}
-
-static char *_2str(uint32_t  val, uint8_t minus){
-    static char strbuf[12];
-    char *bufptr = &strbuf[11];
-    *bufptr = 0;
-    if(!val){
-        *(--bufptr) = '0';
-    }else{
-        while(val){
-            *(--bufptr) = val % 10 + '0';
-            val /= 10;
-        }
-    }
-    if(minus) *(--bufptr) = '-';
-    return bufptr;
-}
-
-// return string with number `val`
-char *u2str(uint32_t val){
-    return _2str(val, 0);
-}
-char *i2str(int32_t i){
-    uint8_t minus = 0;
-    uint32_t val;
-    if(i < 0){
-        minus = 1;
-        val = -i;
-    }else val = i;
-    return _2str(val, minus);
-}
-
-char *u2hexstr(uint32_t val){
-    static char strbuf[11] = "0x";
-    char *sptr = strbuf + 2;
-    uint8_t *ptr = (uint8_t*)&val + 3;
-    int8_t i, j, z=1;
-    for(i = 0; i < 4; ++i, --ptr){
-        if(*ptr == 0){ // omit leading zeros
-            if(i == 3) z = 0;
-            if(z) continue;
-        }
-        else z = 0;
-        for(j = 1; j > -1; --j){
-            uint8_t half = (*ptr >> (4*j)) & 0x0f;
-            if(half < 10) *sptr++ = half + '0';
-            else *sptr++ = half - 10 + 'a';
-        }
-    }
-    *sptr = 0;
-    return strbuf;
-}
+/*
+ * This file is part of the I2Cscan project.
+ * Copyright 2020 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 "i2cscan.h"
+#include "i2c.h"
+#include "proto.h"
+#include "usb.h"
+#include "version.inc"
+
+extern volatile uint32_t Tms;
+
+char *omit_spaces(const char *buf){
+    while(*buf){
+        if(*buf > ' ') break;
+        ++buf;
+    }
+    return (char*)buf;
+}
+
+// In case of overflow return `buf` and N==0xffffffff
+// read decimal number & return pointer to next non-number symbol
+static char *getdec(const char *buf, uint32_t *N){
+    char *start = (char*)buf;
+    uint32_t num = 0;
+    while(*buf){
+        char c = *buf;
+        if(c < '0' || c > '9'){
+            break;
+        }
+        if(num > 429496729 || (num == 429496729 && c > '5')){ // overflow
+            *N = 0xffffff;
+            return start;
+        }
+        num *= 10;
+        num += c - '0';
+        ++buf;
+    }
+    *N = num;
+    return (char*)buf;
+}
+// read hexadecimal number (without 0x prefix!)
+static char *gethex(const char *buf, uint32_t *N){
+    char *start = (char*)buf;
+    uint32_t num = 0;
+    while(*buf){
+        char c = *buf;
+        uint8_t M = 0;
+        if(c >= '0' && c <= '9'){
+            M = '0';
+        }else if(c >= 'A' && c <= 'F'){
+            M = 'A' - 10;
+        }else if(c >= 'a' && c <= 'f'){
+            M = 'a' - 10;
+        }
+        if(M){
+            if(num & 0xf0000000){ // overflow
+                *N = 0xffffff;
+                return start;
+            }
+            num <<= 4;
+            num += c - M;
+        }else{
+            break;
+        }
+        ++buf;
+    }
+    *N = num;
+    return (char*)buf;
+}
+// read octal number (without 0 prefix!)
+static char *getoct(const char *buf, uint32_t *N){
+    char *start = (char*)buf;
+    uint32_t num = 0;
+    while(*buf){
+        char c = *buf;
+        if(c < '0' || c > '7'){
+            break;
+        }
+        if(num & 0xe0000000){ // overflow
+            *N = 0xffffff;
+            return start;
+        }
+        num <<= 3;
+        num += c - '0';
+        ++buf;
+    }
+    *N = num;
+    return (char*)buf;
+}
+// read binary number (without b prefix!)
+static char *getbin(const char *buf, uint32_t *N){
+    char *start = (char*)buf;
+    uint32_t num = 0;
+    while(*buf){
+        char c = *buf;
+        if(c < '0' || c > '1'){
+            break;
+        }
+        if(num & 0x80000000){ // overflow
+            *N = 0xffffff;
+            return start;
+        }
+        num <<= 1;
+        if(c == '1') num |= 1;
+        ++buf;
+    }
+    *N = num;
+    return (char*)buf;
+}
+
+/**
+ * @brief getnum - read uint32_t from string (dec, hex or bin: 127, 0x7f, 0b1111111)
+ * @param buf - buffer with number and so on
+ * @param N   - the number read
+ * @return pointer to first non-number symbol in buf
+ *      (if it is == buf, there's no number or if *N==0xffffffff there was overflow)
+ */
+char *getnum(const char *txt, uint32_t *N){
+    char *nxt = NULL;
+    char *s = omit_spaces(txt);
+    if(*s == '0'){ // hex, oct or 0
+        if(s[1] == 'x' || s[1] == 'X'){ // hex
+            nxt = gethex(s+2, N);
+            if(nxt == s+2) nxt = (char*)txt;
+        }else if(s[1] > '0'-1 && s[1] < '8'){ // oct
+            nxt = getoct(s+1, N);
+            if(nxt == s+1) nxt = (char*)txt;
+        }else{ // 0
+            nxt = s+1;
+            *N = 0;
+        }
+    }else if(*s == 'b' || *s == 'B'){
+        nxt = getbin(s+1, N);
+        if(nxt == s+1) nxt = (char*)txt;
+    }else{
+        nxt = getdec(s, N);
+        if(nxt == s) nxt = (char*)txt;
+    }
+    return nxt;
+}
+
+static void displaydata(uint8_t *data, int start, int N){
+    if(N == 0){
+        USB_sendstr("Done\n");
+        return;
+    }
+    USB_sendstr("Got:\naddr\tval(x)\tval(d)\n");
+    for(int i = 0; i < N; ++i){
+        USB_sendstr(u2hexstr(i+start)); USB_sendstr("\t");
+        USB_sendstr(u2hexstr(data[i])); USB_sendstr("\t");
+        USB_sendstr(u2str(data[i])); USB_sendstr("\n");
+    }
+}
+
+const char* helpmsg =
+    "https://github.com/eddyem/stm32samples/tree/master/F1:F103/I2Cscan build #" BUILD_NUMBER " @ " BUILD_DATE "\n"
+    "'Aa'- set I2C 7bit address a\n"
+    "'I' - reinit i2c\n"
+    "'Rrn'- read Nnbytes (<256) from register r\n"
+    "'S' - scan I2C bus\n"
+    "'Wrb'- write b to register r\n"
+;
+
+const char *parse_cmd(const char *buf){
+    if(buf[1] == 0){ // one symbol commands
+        switch(*buf){
+            case 'I':
+                i2c_setup();
+                return "Reinit\n";
+            break;
+            case 'S':
+                i2c_init_scan_mode();
+                return "Scan mode\n";
+            break;
+            default:
+                return helpmsg;
+        }
+        return NULL;
+    }
+    uint32_t Num = 0;
+    uint8_t n, data[128];
+    char *bufori = (char*)buf, *ptr;
+    switch(*buf){ // long messages
+        case 'A':
+            ++buf;
+            if(buf != getnum(buf, &Num)){
+                if(Num & 0x80) return "Enter 7bit address\n";
+                i2c_set_addr7(Num);
+                return "Changed\n";
+            }else return "Wrong filter number";
+        break;
+        case 'R':
+            ++buf;
+            if(buf != (ptr = getnum(buf, &Num))){
+                n = Num;
+                if(ptr != getnum(ptr, &Num)){
+                    if(Num > 128) return "Not more than 128 bytes\n";
+                    if(read_reg(n, data, Num)) displaydata(data, n, Num);
+                    else return "Error\n";
+                }else return "Need data amount to read\n";
+            }else return "Need register address\n";
+        break;
+        case 'W':
+            ++buf;
+            if(buf != (ptr = getnum(buf, &Num))){
+                n = Num;
+                if(ptr != getnum(ptr, &Num)){
+                    if(write_reg(n, Num)) return "Sent\n";
+                    else return "Error\n";
+                }else return "Need data to write\n";
+            }else return "Need register address\n";
+        break;
+        default:
+            return bufori;
+    }
+    return NULL;
+}
+
+static char *_2str(uint32_t  val, uint8_t minus){
+    static char strbuf[12];
+    char *bufptr = &strbuf[11];
+    *bufptr = 0;
+    if(!val){
+        *(--bufptr) = '0';
+    }else{
+        while(val){
+            *(--bufptr) = val % 10 + '0';
+            val /= 10;
+        }
+    }
+    if(minus) *(--bufptr) = '-';
+    return bufptr;
+}
+
+// return string with number `val`
+char *u2str(uint32_t val){
+    return _2str(val, 0);
+}
+char *i2str(int32_t i){
+    uint8_t minus = 0;
+    uint32_t val;
+    if(i < 0){
+        minus = 1;
+        val = -i;
+    }else val = i;
+    return _2str(val, minus);
+}
+
+char *u2hexstr(uint32_t val){
+    static char strbuf[11] = "0x";
+    char *sptr = strbuf + 2;
+    uint8_t *ptr = (uint8_t*)&val + 3;
+    int8_t i, j, z=1;
+    for(i = 0; i < 4; ++i, --ptr){
+        if(*ptr == 0){ // omit leading zeros
+            if(i == 3) z = 0;
+            if(z) continue;
+        }
+        else z = 0;
+        for(j = 1; j > -1; --j){
+            uint8_t half = (*ptr >> (4*j)) & 0x0f;
+            if(half < 10) *sptr++ = half + '0';
+            else *sptr++ = half - 10 + 'a';
+        }
+    }
+    *sptr = 0;
+    return strbuf;
+}
diff --git a/F1:F103/I2Cscan/ringbuffer.c b/F1:F103/I2Cscan/ringbuffer.c
new file mode 100644
index 0000000..8d8d6ca
--- /dev/null
+++ b/F1:F103/I2Cscan/ringbuffer.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ringbuffer.h"
+
+static int datalen(ringbuffer *b){
+    if(b->tail >= b->head) return (b->tail - b->head);
+    else return (b->length - b->head + b->tail);
+}
+
+// stored data length
+int RB_datalen(ringbuffer *b){
+    if(b->busy) return -1;
+    b->busy = 1;
+    int l = datalen(b);
+    b->busy = 0;
+    return l;
+}
+
+static int hasbyte(ringbuffer *b, uint8_t byte){
+    if(b->head == b->tail) return -1; // no data in buffer
+    int startidx = b->head;
+    if(b->head > b->tail){ //
+        for(int found = b->head; found < b->length; ++found)
+            if(b->data[found] == byte) return found;
+        startidx = 0;
+    }
+    for(int found = startidx; found < b->tail; ++found)
+        if(b->data[found] == byte) return found;
+    return -1;
+}
+
+/**
+ * @brief RB_hasbyte - check if buffer has given byte stored
+ * @param b - buffer
+ * @param byte - byte to find
+ * @return index if found, -1 if none or busy
+ */
+int RB_hasbyte(ringbuffer *b, uint8_t byte){
+    if(b->busy) return -1;
+    b->busy = 1;
+    int ret = hasbyte(b, byte);
+    b->busy = 0;
+    return ret;
+}
+
+// poor memcpy
+static void mcpy(uint8_t *targ, const uint8_t *src, int l){
+    while(l--) *targ++ = *src++;
+}
+
+// increment head or tail
+TRUE_INLINE void incr(ringbuffer *b, volatile int *what, int n){
+    *what += n;
+    if(*what >= b->length) *what -= b->length;
+}
+
+static int read(ringbuffer *b, uint8_t *s, int len){
+    int l = datalen(b);
+    if(!l) return 0;
+    if(l > len) l = len;
+    int _1st = b->length - b->head;
+    if(_1st > l) _1st = l;
+    if(_1st > len) _1st = len;
+    mcpy(s, b->data + b->head, _1st);
+    if(_1st < len && l > _1st){
+        mcpy(s+_1st, b->data, l - _1st);
+        incr(b, &b->head, l);
+        return l;
+    }
+    incr(b, &b->head, _1st);
+    return _1st;
+}
+
+/**
+ * @brief RB_read - read data from ringbuffer
+ * @param b - buffer
+ * @param s - array to write data
+ * @param len - max len of `s`
+ * @return bytes read or -1 if busy
+ */
+int RB_read(ringbuffer *b, uint8_t *s, int len){
+    if(b->busy) return -1;
+    b->busy = 1;
+    int r = read(b, s, len);
+    b->busy = 0;
+    return r;
+}
+
+static int readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
+    int idx = hasbyte(b, byte);
+    if(idx < 0) return 0;
+    int partlen = idx + 1 - b->head;
+    // now calculate length of new data portion
+    if(idx < b->head) partlen += b->length;
+    if(partlen > len) return -read(b, s, len);
+    return read(b, s, partlen);
+}
+
+/**
+ * @brief RB_readto fill array `s` with data until byte `byte` (with it)
+ * @param b - ringbuffer
+ * @param byte - check byte
+ * @param s - buffer to write data
+ * @param len - length of `s`
+ * @return amount of bytes written (negative, if len<data in buffer or buffer is busy)
+ */
+int RB_readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
+    if(b->busy) return -1;
+    b->busy = 1;
+    int n = readto(b, byte, s, len);
+    b->busy = 0;
+    return n;
+}
+
+static int write(ringbuffer *b, const uint8_t *str, int l){
+    int r = b->length - 1 - datalen(b); // rest length
+    if(l > r) l = r;
+    if(!l) return 0;
+    int _1st = b->length - b->tail;
+    if(_1st > l) _1st = l;
+    mcpy(b->data + b->tail, str, _1st);
+    if(_1st < l){ // add another piece from start
+        mcpy(b->data, str+_1st, l-_1st);
+    }
+    incr(b, &b->tail, l);
+    return l;
+}
+
+/**
+ * @brief RB_write - write some data to ringbuffer
+ * @param b - buffer
+ * @param str - data
+ * @param l - length
+ * @return amount of bytes written or -1 if busy
+ */
+int RB_write(ringbuffer *b, const uint8_t *str, int l){
+    if(b->busy) return -1;
+    b->busy = 1;
+    int w = write(b, str, l);
+    b->busy = 0;
+    return w;
+}
+
+// just delete all information in buffer `b`
+int RB_clearbuf(ringbuffer *b){
+    if(b->busy) return -1;
+    b->busy = 1;
+    b->head = 0;
+    b->tail = 0;
+    b->busy = 0;
+    return 1;
+}
diff --git a/F1:F103/I2Cscan/ringbuffer.h b/F1:F103/I2Cscan/ringbuffer.h
new file mode 100644
index 0000000..ed2cf95
--- /dev/null
+++ b/F1:F103/I2Cscan/ringbuffer.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2023 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#if defined STM32F0
+#include <stm32f0.h>
+#elif defined STM32F1
+#include <stm32f1.h>
+#elif defined STM32F3
+#include <stm32f3.h>
+#endif
+
+typedef struct{
+    uint8_t *data;      // data buffer
+    const int length;   // its length
+    int head;           // head index
+    int tail;           // tail index
+    volatile int busy; // == TRUE if buffer is busy now
+} ringbuffer;
+
+int RB_read(ringbuffer *b, uint8_t *s, int len);
+int RB_readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len);
+int RB_hasbyte(ringbuffer *b, uint8_t byte);
+int RB_write(ringbuffer *b, const uint8_t *str, int l);
+int RB_datalen(ringbuffer *b);
+int RB_clearbuf(ringbuffer *b);
diff --git a/F1:F103/I2Cscan/usb.c b/F1:F103/I2Cscan/usb.c
index 5ae4f4a..a2ee479 100644
--- a/F1:F103/I2Cscan/usb.c
+++ b/F1:F103/I2Cscan/usb.c
@@ -1,6 +1,5 @@
 /*
- * This file is part of the I2Cscan project.
- * Copyright 2020 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,152 +15,121 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <string.h>
+
+#include "hardware.h"
 #include "usb.h"
 #include "usb_lib.h"
 
-static volatile uint8_t tx_succesfull = 1;
-static volatile uint8_t rxNE = 0;
+static volatile uint8_t usbbuff[USB_TXBUFSZ]; // temporary buffer for sending data
+// ring buffers for incoming and outgoing data
+static uint8_t obuf[RBOUTSZ], ibuf[RBINSZ];
+volatile ringbuffer rbout = {.data = obuf, .length = RBOUTSZ, .head = 0, .tail = 0};
+volatile ringbuffer rbin = {.data = ibuf, .length = RBINSZ, .head = 0, .tail = 0};
+// inbuf overflow when receiving
+volatile uint8_t bufovrfl = 0;
+// last send data size
+static volatile int lastdsz = 0;
 
-static int sstrlen(const char *s){
-    if(!s) return 0;
-    int l = 0;
-    while(*s++) ++l;
-    return l;
-}
-
-// interrupt IN handler (never used?)
-static void EP1_Handler(){
-    uint16_t epstatus = KEEP_DTOG(USB->EPnR[1]);
-    if(RX_FLAG(epstatus)) epstatus = (epstatus & ~USB_EPnR_STAT_TX) ^ USB_EPnR_STAT_RX; // set valid RX
-    else epstatus = epstatus & ~(USB_EPnR_STAT_TX|USB_EPnR_STAT_RX);
-    // clear CTR
-    epstatus = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX));
-    USB->EPnR[1] = epstatus;
-}
-
-// data IN/OUT handlers
-static void transmit_Handler(){ // EP3IN
-    tx_succesfull = 1;
-    uint16_t epstatus = KEEP_DTOG_STAT(USB->EPnR[3]);
-    // clear CTR keep DTOGs & STATs
-    USB->EPnR[3] = (epstatus & ~(USB_EPnR_CTR_TX)); // clear TX ctr
-}
-
-static void receive_Handler(){ // EP2OUT
-    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(){
-    NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
-    NVIC_DisableIRQ(USB_HP_CAN1_TX_IRQn);
-    RCC->APB1ENR |= RCC_APB1ENR_USBEN;
-    USB->CNTR   = USB_CNTR_FRES; // Force USB Reset
-    for(uint32_t ctr = 0; ctr < 72000; ++ctr) nop(); // wait >1ms
-    //uint32_t ctr = 0;
-    USB->CNTR   = 0;
-    USB->BTABLE = 0;
-    USB->DADDR  = 0;
-    USB->ISTR   = 0;
-    USB->CNTR   = USB_CNTR_RESETM | USB_CNTR_WKUPM; // allow only wakeup & reset interrupts
-    NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
-}
-
-static int usbwr(const char *buf, int l){
-    uint32_t ctra = 1000000;
-    while(--ctra && tx_succesfull == 0){
-        IWDG->KR = IWDG_REFRESH;
-    }
-    tx_succesfull = 0;
-    EP_Write(3, (uint8_t*)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 char usbbuff[USB_TXBUFSZ-1]; // temporary buffer (63 - to prevent need of ZLP)
-static int 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, (uint8_t*)usbbuff, buflen);
-    buflen = 0;
-}
-
-// unblocking sending - just fill a buffer
-void USB_send(const char *buf){
-    int len = sstrlen(buf);
-    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);
+// called from transmit EP
+void send_next(){
+    int buflen = RB_read((ringbuffer*)&rbout, (uint8_t*)usbbuff, USB_TXBUFSZ);
+    if(buflen == 0){
+        if(lastdsz == 64) EP_Write(3, NULL, 0); // send ZLP after 64 bits packet when nothing more to send
+        lastdsz = 0;
+        return;
+    }else if(buflen < 0){
+        lastdsz = 0;
+        // Uncomment next line if you want 4Mbit/s instead of 6Mbit/s
+        //EP_Write(3, NULL, 0); // send ZLP if buffer is in writting state now
         return;
     }
-    while(len--) usbbuff[buflen++] = *buf++;
+    EP_Write(3, (uint8_t*)usbbuff, buflen);
+    lastdsz = buflen;
 }
 
-// blocking sending
-void USB_send_blk(const char *buf, int len){
-    if(!usbON || !len) return; // USB disconnected
-    if(buflen){
-        usbwr(usbbuff, buflen);
-        buflen = 0;
+// blocking send full content of ring buffer
+int USB_sendall(){
+    while(lastdsz > 0){
+        if(!usbON) return FALSE;
     }
-    int needzlp = 0;
+    return TRUE;
+}
+
+// put `buf` into queue to send
+int USB_send(const uint8_t *buf, int len){
+    if(!buf || !usbON || !len) return FALSE;
     while(len){
-        if(len == USB_TXBUFSZ) needzlp = 1;
-        int s = (len > USB_TXBUFSZ) ? USB_TXBUFSZ : len;
-        if(usbwr(buf, s)) return;
-        len -= s;
-        buf += s;
-    }
-    if(needzlp){
-        usbwr(NULL, 0);
+        int a = RB_write((ringbuffer*)&rbout, buf, len);
+        if(a > 0){
+            len -= a;
+            buf += a;
+        } else if (a < 0) continue; // do nothing if buffer is in reading state
+        if(lastdsz == 0) send_next(); // need to run manually - all data sent, so no IRQ on IN
     }
+    return TRUE;
 }
 
-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();
+int USB_putbyte(uint8_t byte){
+    if(!usbON) return FALSE;
+    int l = 0;
+    while((l = RB_write((ringbuffer*)&rbout, &byte, 1)) != 1){
+        if(l < 0) continue;
     }
+    if(lastdsz == 0) send_next(); // need to run manually - all data sent, so no IRQ on IN
+    return TRUE;
+}
+
+int USB_sendstr(const char *string){
+    if(!string || !usbON) return FALSE;
+    int len = 0;
+    const char *b = string;
+    while(*b++) ++len;
+    if(!len) return FALSE;
+    return USB_send((const uint8_t*)string, len);
 }
 
 /**
- * @brief USB_receive
- * @param buf (i) - buffer[64] for received data
- * @return amount of received bytes
+ * @brief USB_receive - get binary data from receiving ring-buffer
+ * @param buf (i) - buffer for received data
+ * @param len - length of `buf`
+ * @return amount of received bytes (negative, if overfull happened)
  */
-int USB_receive(char *buf){
-    if(!usbON || !rxNE) return 0;
-    int sz = EP_Read(2, (uint16_t*)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;
+int USB_receive(uint8_t *buf, int len){
+    chkin();
+    if(bufovrfl){
+        while(1 != RB_clearbuf((ringbuffer*)&rbin));
+        bufovrfl = 0;
+        return -1;
+    }
+    int sz = RB_read((ringbuffer*)&rbin, buf, len);
+    if(sz < 0) return 0; // buffer in writting state
     return sz;
 }
+
+/**
+ * @brief USB_receivestr - get string up to '\n' and replace '\n' with 0
+ * @param buf - receiving buffer
+ * @param len - its length
+ * @return strlen or negative value indicating overflow (if so, string won't be ends with 0 and buffer should be cleared)
+ */
+int USB_receivestr(char *buf, int len){
+    chkin();
+    if(bufovrfl){
+        while(1 != RB_clearbuf((ringbuffer*)&rbin));
+        bufovrfl = 0;
+        return -1;
+    }
+    int l = RB_readto((ringbuffer*)&rbin, '\n', (uint8_t*)buf, len);
+    if(l < 1){
+        if(rbin.length == RB_datalen((ringbuffer*)&rbin)){ // buffer is full but no '\n' found
+            while(1 != RB_clearbuf((ringbuffer*)&rbin));
+            return -1;
+        }
+        return 0;
+    }
+    if(l == 0) return 0;
+    buf[l-1] = 0; // replace '\n' with strend
+    return l;
+}
+
diff --git a/F1:F103/I2Cscan/usb.h b/F1:F103/I2Cscan/usb.h
index 6cdc1b8..4583b9b 100644
--- a/F1:F103/I2Cscan/usb.h
+++ b/F1:F103/I2Cscan/usb.h
@@ -1,6 +1,5 @@
 /*
- * This file is part of the I2Cscan project.
- * Copyright 2020 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,17 +16,33 @@
  */
 
 #pragma once
-#ifndef __USB_H__
-#define __USB_H__
 
-#include "hardware.h"
+#include "ringbuffer.h"
+#include "usbhw.h"
 
-#define BUFFSIZE   (64)
+// sizes of ringbuffers for outgoing and incoming data
+#define RBOUTSZ     (512)
+#define RBINSZ      (256)
 
-void USB_setup();
-void usb_proc();
-void USB_send(const char *buf);
-void USB_send_blk(const char *buf, int len);
-int USB_receive(char *buf);
+#define newline()   USB_putbyte('\n')
+#define USND(s)     do{USB_sendstr(s); USB_putbyte('\n');}while(0)
 
-#endif // __USB_H__
+#define STR_HELPER(s)   #s
+#define STR(s)          STR_HELPER(s)
+
+#ifdef EBUG
+#define DBG(str)  do{USB_sendstr(__FILE__ " (L" STR(__LINE__) "): " str); newline();}while(0)
+#else
+#define DBG(str)
+#endif
+
+extern volatile ringbuffer rbout, rbin;
+extern volatile uint8_t bufisempty, bufovrfl;
+
+void send_next();
+int USB_sendall();
+int USB_send(const uint8_t *buf, int len);
+int USB_putbyte(uint8_t byte);
+int USB_sendstr(const char *string);
+int USB_receive(uint8_t *buf, int len);
+int USB_receivestr(char *buf, int len);
diff --git a/F1:F103/I2Cscan/usb_lib.c b/F1:F103/I2Cscan/usb_lib.c
index 33293ec..aea5344 100644
--- a/F1:F103/I2Cscan/usb_lib.c
+++ b/F1:F103/I2Cscan/usb_lib.c
@@ -1,6 +1,5 @@
 /*
- * This file is part of the I2Cscan project.
- * Copyright 2020 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,21 +14,21 @@
  * 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.h"
 #include "usb_lib.h"
+#include "usbhw.h"
 
 ep_t endpoints[STM32ENDPOINTS];
 
-usb_dev_t USB_Dev;
+static uint16_t USB_Addr = 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;
+uint8_t ep0databuf[EP0DATABUF_SIZE], setupdatabuf[EP0DATABUF_SIZE];
+config_pack_t *setup_packet = (config_pack_t*) setupdatabuf;
 
 usb_LineCoding getLineCoding(){return lineCoding;}
 
-uint8_t usbON = 0; // device disconnected from terminal
+volatile uint8_t usbON = 0; // device disconnected from terminal
 
 // definition of parts common for USB_DeviceDescriptor & USB_DeviceQualifierDescriptor
 #define bcdUSB_L        0x10
@@ -54,9 +53,9 @@ static const uint8_t USB_DeviceDescriptor[] = {
         0x23,   // idProduct_H
         0x00,   // bcdDevice_Ver_L
         0x03,   // bcdDevice_Ver_H
-        0x01,   // iManufacturer
-        0x02,   // iProduct
-        0x00,   // iSerialNumber
+        iMANUFACTURER_DESCR,   // iManufacturer
+        iPRODUCT_DESCR,   // iProduct
+        iSERIAL_DESCR,   // iSerialNumber
         bNumConfigurations    // bNumConfigurations
 };
 
@@ -96,7 +95,7 @@ static const uint8_t USB_ConfigDescriptor[] = {
         0xff, /* bInterfaceClass */
         0x00, /* bInterfaceSubClass */
         0x00, /* bInterfaceProtocol */
-        0x00, /* iInterface: */
+        iINTERFACE_DESCR, /* iInterface: */
 ///////////////////////////////////////////////////
         /*Endpoint 1 Descriptor*/
         0x07, /* bLength: Endpoint Descriptor size */
@@ -126,11 +125,19 @@ static const uint8_t USB_ConfigDescriptor[] = {
         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");
+_USB_LANG_ID_(LD, LANG_US);
+_USB_STRING_(SD, u"0.0.1");
+_USB_STRING_(MD, u"Prolific Technology Inc.");
+_USB_STRING_(PD, u"USB-Serial Controller");
+_USB_STRING_(ID, u"USB-STM32");
+static void const *StringDescriptor[iDESCR_AMOUNT] = {
+    [iLANGUAGE_DESCR] = &LD,
+    [iMANUFACTURER_DESCR] = &MD,
+    [iPRODUCT_DESCR] = &PD,
+    [iSERIAL_DESCR] = &SD,
+    [iINTERFACE_DESCR] = &ID
+};
+
 
 /*
  * default handlers
@@ -149,8 +156,8 @@ void WEAK break_handler(){
 
 // handler of vendor requests
 void WEAK vendor_handler(config_pack_t *packet){
+    uint16_t c;
     if(packet->bmRequestType & 0x80){ // read
-        uint8_t c;
         switch(packet->wValue){
             case 0x8484:
                 c = 2;
@@ -164,14 +171,15 @@ void WEAK vendor_handler(config_pack_t *packet){
             default:
                 c = 0;
         }
-        EP_WriteIRQ(0, &c, 1);
+        EP_WriteIRQ(0, (uint8_t*)&c, 1);
     }else{ // write ZLP
-        EP_WriteIRQ(0, (uint8_t *)0, 0);
+        c = 0;
+        EP_WriteIRQ(0, (uint8_t *)&c, 0);
     }
 }
 
 static void wr0(const uint8_t *buf, uint16_t size){
-    if(setup_packet.wLength < size) size = setup_packet.wLength; // shortened request
+    if(setup_packet->wLength < size) size = setup_packet->wLength; // shortened request
     if(size < endpoints[0].txbufsz){
         EP_WriteIRQ(0, buf, size);
         return;
@@ -199,24 +207,18 @@ static void wr0(const uint8_t *buf, uint16_t size){
 }
 
 static inline void get_descriptor(){
-    switch(setup_packet.wValue){
+    uint8_t descrtype = setup_packet->wValue >> 8,
+            descridx = setup_packet->wValue & 0xff;
+    switch(descrtype){
         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);
+        case STRING_DESCRIPTOR:
+            if(descridx < iDESCR_AMOUNT) wr0((const uint8_t *)StringDescriptor[descridx], *((uint8_t*)StringDescriptor[descridx]));
+            else EP_WriteIRQ(0, (uint8_t*)0, 0);
         break;
         case DEVICE_QUALIFIER_DESCRIPTOR:
             wr0(USB_DeviceQualifierDescriptor, USB_DeviceQualifierDescriptor[0]);
@@ -226,10 +228,10 @@ static inline void get_descriptor(){
     }
 }
 
-static uint8_t configuration = 0; // reply for GET_CONFIGURATION (==1 if configured)
+static uint16_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){
+    switch(setup_packet->bRequest){
         case GET_DESCRIPTOR:
             get_descriptor();
         break;
@@ -237,23 +239,68 @@ static inline void std_d2h_req(){
             EP_WriteIRQ(0, (uint8_t *)&status, 2); // send status: Bus Powered
         break;
         case GET_CONFIGURATION:
-            EP_WriteIRQ(0, &configuration, 1);
+            EP_WriteIRQ(0, (uint8_t*)&configuration, 1);
         break;
         default:
         break;
     }
 }
 
+// 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
+    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
+    send_next();
+}
+
+static uint8_t volatile rcvbuf[USB_RXBUFSZ];
+static uint8_t volatile rcvbuflen = 0;
+
+void chkin(){
+    if(bufovrfl) return;
+    if(!rcvbuflen) return;
+    int w = RB_write((ringbuffer*)&rbin, (uint8_t*)rcvbuf, rcvbuflen);
+    if(w < 0) return;
+    if(w != rcvbuflen) bufovrfl = 1;
+    rcvbuflen = 0;
+    uint16_t status = KEEP_DTOG(USB->EPnR[2]); // don't change DTOG
+    USB->EPnR[2] = status ^ USB_EPnR_STAT_RX;
+}
+
+// receiver reads data from local buffer and only then ACK'ed
+static void receive_Handler(){ // EP2OUT
+    uint16_t status = KEEP_DTOG_STAT(USB->EPnR[2]); // don't change DTOG and NACK
+    if(rcvbuflen){
+        bufovrfl = 1; // lost last data
+        rcvbuflen = 0;
+    }
+    rcvbuflen = EP_Read(2, (uint8_t*)rcvbuf);
+    USB->EPnR[2] = status & ~USB_EPnR_CTR_RX;
+}
+
 static inline void std_h2d_req(){
-    switch(setup_packet.bRequest){
+    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;
+            USB_Addr = setup_packet->wValue;
         break;
         case SET_CONFIGURATION:
             // Now device configured
-            USB_Dev.USB_Status = USB_STATE_CONFIGURED;
-            configuration = setup_packet.wValue;
+            configuration = setup_packet->wValue;
+            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
         break;
         default:
         break;
@@ -269,10 +316,10 @@ bmRequestType: 76543210
 /**
  * Endpoint0 (control) handler
  */
-static void EP0_Handler(){
+void EP0_Handler(){
     uint16_t epstatus = USB->EPnR[0]; // EP0R on input -> return this value after modifications
-    uint8_t reqtype = setup_packet.bmRequestType & 0x7f;
-    uint8_t dev2host = (setup_packet.bmRequestType & 0x80) ? 1 : 0;
+    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){
@@ -285,15 +332,15 @@ static void EP0_Handler(){
                 }
             break;
             case STANDARD_ENDPOINT_REQUEST_TYPE: // standard endpoint request
-                if(setup_packet.bRequest == CLEAR_FEATURE){
+                if(setup_packet->bRequest == CLEAR_FEATURE){
                     EP_WriteIRQ(0, (uint8_t *)0, 0);
                 }
             break;
             case VENDOR_REQUEST_TYPE:
-                vendor_handler(&setup_packet);
+                vendor_handler(setup_packet);
             break;
             case CONTROL_REQUEST_TYPE:
-                switch(setup_packet.bRequest){
+                switch(setup_packet->bRequest){
                     case GET_LINE_CODING:
                         EP_WriteIRQ(0, (uint8_t*)&lineCoding, sizeof(lineCoding));
                     break;
@@ -301,7 +348,7 @@ static void EP0_Handler(){
                     break;
                     case SET_CONTROL_LINE_STATE:
                         usbON = 1;
-                        clstate_handler(setup_packet.wValue);
+                        clstate_handler(setup_packet->wValue);
                     break;
                     case SEND_BREAK:
                         usbON = 0;
@@ -310,23 +357,22 @@ static void EP0_Handler(){
                     default:
                     break;
                 }
-                if(setup_packet.bRequest != GET_LINE_CODING) EP_WriteIRQ(0, (uint8_t *)0, 0); // write acknowledgement
+                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){
+            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;
+        if ((USB->DADDR & USB_DADDR_ADD) != USB_Addr){
+            USB->DADDR = USB_DADDR_EF | USB_Addr;
+            usbON = 0;
         }
     }
     epstatus = KEEP_DTOG(USB->EPnR[0]);
@@ -336,94 +382,6 @@ static void EP0_Handler(){
     USB->EPnR[0] = (epstatus & ~(USB_EPnR_CTR_RX|USB_EPnR_CTR_TX)) ^ USB_EPnR_STAT_RX;
 }
 
-static uint16_t lastaddr = LASTADDR_DEFAULT;
-/**
- * Endpoint initialisation
- * @param number - EP num (0...7)
- * @param type - EP type (EP_TYPE_BULK, EP_TYPE_CONTROL, EP_TYPE_ISO, EP_TYPE_INTERRUPT)
- * @param txsz - transmission buffer size @ USB/CAN buffer
- * @param rxsz - reception buffer size @ USB/CAN buffer
- * @param uint16_t (*func)(ep_t *ep) - EP handler function
- * @return 0 if all OK
- */
-int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)(ep_t ep)){
-    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*2);
-    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 = (uint16_t *)(USB_BTABLE_BASE + lastaddr*2);
-    lastaddr += rxsz;
-    USB_BTABLE->EP[number].USB_COUNT_RX = countrx << 10;
-    endpoints[number].func = func;
-    return 0;
-}
-
-// standard IRQ handler
-void usb_lp_can_rx0_isr(){
-    if(USB->ISTR & USB_ISTR_RESET){
-        usbON = 0;
-        // 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;
-        // clear address, leave only enable bit
-        USB->DADDR = USB_DADDR_EF;
-        USB_Dev.USB_Status = USB_STATE_DEFAULT;
-        USB->ISTR = ~USB_ISTR_RESET;
-        if(EP_Init(0, EP_TYPE_CONTROL, USB_EP0_BUFSZ, USB_EP0_BUFSZ, EP0_Handler)){
-            return;
-        }
-    }
-    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, (uint16_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, (uint16_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_LP_MODE;
-        USB->ISTR = ~USB_ISTR_SUSP;
-    }
-    if(USB->ISTR & USB_ISTR_WKUP){ // wakeup
-        USB->CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LP_MODE); // clear suspend flags
-        USB->ISTR = ~USB_ISTR_WKUP;
-    }
-}
-
 /**
  * Write data to EP buffer (called from IRQ handler)
  * @param number - EP number
@@ -431,15 +389,24 @@ void usb_lp_can_rx0_isr(){
  * @param size - its size
  */
 void EP_WriteIRQ(uint8_t number, const uint8_t *buf, uint16_t size){
-    uint8_t i;
     if(size > endpoints[number].txbufsz) size = endpoints[number].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;
+#if defined USB1_16
+    // very bad: what if `size` is odd?
     uint32_t *out = (uint32_t *)endpoints[number].tx_buf;
-    for(i = 0; i < N2; ++i, ++out){
+    for(int i = 0; i < N2; ++i, ++out){
         *out = buf16[i];
     }
+#elif defined USB2_16
+    // use memcpy instead?
+    for(int i = 0; i < N2; i++){
+        endpoints[number].tx_buf[i] = buf16[i];
+    }
+#else
+#error "Define USB1_16 or USB2_16"
+#endif
     USB_BTABLE->EP[number].USB_COUNT_TX = size;
 }
 
@@ -461,16 +428,123 @@ void EP_Write(uint8_t number, const uint8_t *buf, uint16_t size){
  * @param *buf - user array for data
  * @return amount of data read
  */
-int EP_Read(uint8_t number, uint16_t *buf){
+int EP_Read(uint8_t number, uint8_t *buf){
     int sz = endpoints[number].rx_cnt;
     if(!sz) return 0;
     endpoints[number].rx_cnt = 0;
+#if defined USB1_16
     int n = (sz + 1) >> 1;
-    uint32_t *in = (uint32_t *)endpoints[number].rx_buf;
-    if(n){
-        for(int i = 0; i < n; ++i, ++in)
-            buf[i] = *(uint16_t*)in;
-    }
+    uint32_t *in = (uint32_t*)endpoints[number].rx_buf;
+    uint16_t *out = (uint16_t*)buf;
+    for(int i = 0; i < n; ++i, ++in)
+        out[i] = *(uint16_t*)in;
+#elif defined USB2_16
+    // use memcpy instead?
+    for(int i = 0; i < sz; ++i)
+        buf[i] = endpoints[number].rx_buf[i];
+#else
+#error "Define USB1_16 or USB2_16"
+#endif
     return sz;
 }
 
+
+static uint16_t lastaddr = LASTADDR_DEFAULT;
+/**
+ * Endpoint initialisation
+ * @param number - EP num (0...7)
+ * @param type - EP type (EP_TYPE_BULK, EP_TYPE_CONTROL, EP_TYPE_ISO, EP_TYPE_INTERRUPT)
+ * @param txsz - transmission buffer size @ USB/CAN buffer
+ * @param rxsz - reception buffer size @ USB/CAN buffer
+ * @param uint16_t (*func)(ep_t *ep) - EP handler function
+ * @return 0 if all OK
+ */
+int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)(ep_t ep)){
+    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/ACCESSZ) return 2; // out of btable
+    USB->EPnR[number] = (type << 9) | (number & USB_EPnR_EA);
+    USB->EPnR[number] ^= USB_EPnR_STAT_RX | USB_EPnR_STAT_TX_1;
+    if(rxsz & 1 || rxsz > USB_BTABLE_SIZE) return 3; // wrong rx buffer size
+    uint16_t countrx = 0;
+    if(rxsz < 64) countrx = rxsz / 2;
+    else{
+        if(rxsz & 0x1f) return 3; // should be multiple of 32
+        countrx = 31 + rxsz / 32;
+    }
+    USB_BTABLE->EP[number].USB_ADDR_TX = lastaddr;
+    endpoints[number].tx_buf = (uint16_t *)(USB_BTABLE_BASE + lastaddr * ACCESSZ);
+    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 * ACCESSZ);
+    lastaddr += rxsz;
+    USB_BTABLE->EP[number].USB_COUNT_RX = countrx << 10;
+    endpoints[number].func = func;
+    return 0;
+}
+
+// standard IRQ handler
+void USB_IRQ(){
+    if(USB->ISTR & USB_ISTR_RESET){
+        usbON = 0;
+        // Reinit registers
+        USB->CNTR = USB_CNTR_RESETM | USB_CNTR_CTRM | USB_CNTR_SUSPM | USB_CNTR_WKUPM;
+        // Endpoint 0 - CONTROL
+        // ON USB LS size of EP0 may be 8 bytes, but on FS it should be 64 bytes!
+        lastaddr = LASTADDR_DEFAULT;
+        // clear address, leave only enable bit
+        USB->DADDR = USB_DADDR_EF;
+        if(EP_Init(0, EP_TYPE_CONTROL, USB_EP0_BUFSZ, USB_EP0_BUFSZ, EP0_Handler)){
+            return;
+        }
+        USB->ISTR = ~USB_ISTR_RESET;
+    }
+    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, setupdatabuf);
+                    // interrupt handler will be called later
+                }else if(epstatus & USB_EPnR_CTR_RX){ // data packet -> push received data to ep0databuf
+                    EP_Read(0, 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;
+#ifndef STM32F0
+        USB->CNTR |= USB_CNTR_FSUSP | USB_CNTR_LP_MODE;
+#else
+        USB->CNTR |= USB_CNTR_FSUSP | USB_CNTR_LPMODE;
+#endif
+        USB->ISTR = ~USB_ISTR_SUSP;
+    }
+    if(USB->ISTR & USB_ISTR_WKUP){ // wakeup
+#ifndef STM32F0
+        USB->CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LP_MODE); // clear suspend flags
+#else
+        USB->CNTR &= ~(USB_CNTR_FSUSP | USB_CNTR_LPMODE);
+#endif
+        USB->ISTR = ~USB_ISTR_WKUP;
+    }
+}
+
+#if defined STM32F3
+void usb_lp_isr() __attribute__ ((alias ("USB_IRQ")));
+#elif defined STM32F1
+void usb_lp_can_rx0_isr() __attribute__ ((alias ("USB_IRQ")));
+#elif defined STM32F0
+void usb_isr() __attribute__ ((alias ("USB_IRQ")));
+#endif
diff --git a/F1:F103/I2Cscan/usb_lib.h b/F1:F103/I2Cscan/usb_lib.h
index 3ed7863..ec26927 100644
--- a/F1:F103/I2Cscan/usb_lib.h
+++ b/F1:F103/I2Cscan/usb_lib.h
@@ -1,6 +1,5 @@
 /*
- * This file is part of the I2Cscan project.
- * Copyright 2020 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,13 +14,10 @@
  * 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"
+#include "usbhw.h"
 
 #define EP0DATABUF_SIZE                 (64)
 #define LASTADDR_DEFAULT                (STM32ENDPOINTS * 8)
@@ -62,14 +58,21 @@
 #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
+// string descriptors
+enum{
+    iLANGUAGE_DESCR,
+    iMANUFACTURER_DESCR,
+    iPRODUCT_DESCR,
+    iSERIAL_DESCR,
+    iINTERFACE_DESCR,
+    iDESCR_AMOUNT
+};
+
+// Types of descriptors
+#define DEVICE_DESCRIPTOR               0x01
+#define CONFIGURATION_DESCRIPTOR        0x02
+#define STRING_DESCRIPTOR               0x03
+#define DEVICE_QUALIFIER_DESCRIPTOR     0x06
 
 #define RX_FLAG(epstat)                 (epstat & USB_EPnR_CTR_RX)
 #define TX_FLAG(epstat)                 (epstat & USB_EPnR_CTR_TX)
@@ -79,14 +82,6 @@
 #define KEEP_DTOG_STAT(EPnR)            (EPnR & ~(USB_EPnR_STAT_RX|USB_EPnR_STAT_TX|USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX))
 #define KEEP_DTOG(EPnR)                 (EPnR & ~(USB_EPnR_DTOG_RX|USB_EPnR_DTOG_TX))
 
-// USB state: uninitialized, addressed, ready for use
-typedef enum{
-    USB_STATE_DEFAULT,
-    USB_STATE_ADDRESSED,
-    USB_STATE_CONFIGURED,
-    USB_STATE_CONNECTED
-} USB_state;
-
 // EP types
 #define EP_TYPE_BULK                    0x00
 #define EP_TYPE_CONTROL                 0x01
@@ -115,7 +110,6 @@ static const struct name \
     \
 } \
 name = {0x04, 0x03, lng_id}
-#define STRING_LANG_DESCRIPTOR_SIZE_BYTE    (4)
 
 // EP0 configuration packet
 typedef struct {
@@ -130,17 +124,11 @@ typedef struct {
 typedef struct{
     uint16_t *tx_buf;           // transmission buffer address
     uint16_t txbufsz;           // transmission buffer size
-    uint16_t *rx_buf;           // reception buffer address
+    uint8_t *rx_buf;            // reception buffer address
     void (*func)();             // endpoint action function
     unsigned rx_cnt  : 10;      // 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;
@@ -165,20 +153,20 @@ typedef struct {
 } __attribute__ ((packed)) usb_cdc_notification;
 
 extern ep_t endpoints[];
-extern usb_dev_t USB_Dev;
-extern uint8_t usbON;
+extern volatile uint8_t usbON;
+extern config_pack_t *setup_packet;
+extern uint8_t ep0databuf[], setupdatabuf[];
+
+void EP0_Handler();
 
-void USB_Init();
-void USB_ResetState();
-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, uint16_t *buf);
+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__
+void chkin();
+int EP_Init(uint8_t number, uint8_t type, uint16_t txsz, uint16_t rxsz, void (*func)());
diff --git a/F1:F103/I2Cscan/usbhw.c b/F1:F103/I2Cscan/usbhw.c
new file mode 100644
index 0000000..4f061b7
--- /dev/null
+++ b/F1:F103/I2Cscan/usbhw.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "usb.h"
+#include "usb_lib.h"
+
+// here we suppose that all PIN settings done in hw_setup earlier
+void USB_setup(){
+#if defined STM32F3
+    NVIC_DisableIRQ(USB_LP_IRQn);
+    // remap USB LP & Wakeup interrupts to 75 and 76 - works only on pure F303
+    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN; // enable tacting of SYSCFG
+    SYSCFG->CFGR1 |= SYSCFG_CFGR1_USB_IT_RMP;
+#elif defined STM32F1
+    NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
+    NVIC_DisableIRQ(USB_HP_CAN1_TX_IRQn);
+#elif defined STM32F0
+    NVIC_DisableIRQ(USB_IRQn);
+    RCC->APB1ENR |= RCC_APB1ENR_CRSEN;
+    RCC->CFGR3 &= ~RCC_CFGR3_USBSW; // reset USB
+    RCC->CR2 |= RCC_CR2_HSI48ON; // turn ON HSI48
+    uint32_t tmout = 16000000;
+    while(!(RCC->CR2 & RCC_CR2_HSI48RDY)){if(--tmout == 0) break;}
+    FLASH->ACR = FLASH_ACR_PRFTBE | FLASH_ACR_LATENCY;
+    CRS->CFGR &= ~CRS_CFGR_SYNCSRC;
+    CRS->CFGR |= CRS_CFGR_SYNCSRC_1; // USB SOF selected as sync source
+    CRS->CR |= CRS_CR_AUTOTRIMEN; // enable auto trim
+    CRS->CR |= CRS_CR_CEN; // enable freq counter & block CRS->CFGR as read-only
+    RCC->CFGR |= RCC_CFGR_SW;
+#endif
+    RCC->APB1ENR |= RCC_APB1ENR_USBEN;
+    //??
+    USB->CNTR   = USB_CNTR_FRES; // Force USB Reset
+    for(uint32_t ctr = 0; ctr < 72000; ++ctr) nop(); // wait >1ms
+    USB->CNTR   = 0;
+    USB->BTABLE = 0;
+    USB->DADDR  = 0;
+    USB->ISTR   = 0;
+    USB->CNTR   = USB_CNTR_RESETM | USB_CNTR_WKUPM; // allow only wakeup & reset interrupts
+#if defined STM32F3
+    NVIC_EnableIRQ(USB_LP_IRQn);
+#elif defined STM32F1
+    NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
+#elif defined STM32F0
+    USB->BCDR |= USB_BCDR_DPPU;
+    NVIC_EnableIRQ(USB_IRQn);
+#endif
+}
+
+
diff --git a/F1:F103/I2Cscan/usbhw.h b/F1:F103/I2Cscan/usbhw.h
new file mode 100644
index 0000000..1ca0482
--- /dev/null
+++ b/F1:F103/I2Cscan/usbhw.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2024 Edward V. Emelianov <edward.emelianoff@gmail.com>.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#if defined STM32F0
+#include <stm32f0.h>
+#elif defined STM32F1
+#include <stm32f1.h>
+// there's no this define in standard header
+#define USB_BASE                ((uint32_t)0x40005C00)
+#elif defined STM32F3
+#include <stm32f3.h>
+#endif
+
+// max endpoints number
+#define STM32ENDPOINTS          8
+/**
+ *                 Buffers size definition
+ **/
+
+//  F0 - USB2_16; F1 - USB1_16; F3 - 1/2 depending on series
+#if !defined USB1_16 && !defined USB2_16
+#if defined STM32F0
+#define USB2_16
+#elif defined STM32F1
+#define USB1_16
+#else
+#error "Can't determine USB1_16 or USB2_16, define by hands"
+#endif
+#endif
+
+// BTABLE_SIZE FOR STM32F3:
+// In STM32F303/302xB/C, 512 bytes SRAM is not shared with CAN.
+// In STM32F302x6/x8 and STM32F30xxD/E, 726 bytes dedicated SRAM and 256 bytes shared SRAM with CAN i.e.
+//     1Kbytes dedicated SRAM in case CAN is disabled.
+// remember, that USB_BTABLE_SIZE will be divided by ACCESSZ, so don't divide it twice for 32-bit addressing
+
+#ifdef NOCAN
+#if defined STM32F0
+#define USB_BTABLE_SIZE         1024
+#elif defined STM32F3
+#define USB_BTABLE_SIZE         512
+#warning "Please, check real buffer size due to docs"
+#else
+#error "define STM32F0 or STM32F3"
+#endif
+#else // !NOCAN: F0/F3 with CAN or F1 (can't simultaneously run CAN and USB)
+#if defined STM32F0
+#define USB_BTABLE_SIZE         768
+#elif defined STM32F3
+#define USB_BTABLE_SIZE         512
+#warning "Please, check real buffer size due to docs"
+#else // STM32F103: 1024 bytes but with 32-bit addressing
+#define USB_BTABLE_SIZE         1024
+#endif
+#endif // NOCAN
+
+// first 64 bytes of USB_BTABLE are registers!
+//#define USB_EP0_BASEADDR        64
+// 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
+#define USB                     ((USB_TypeDef *) USB_BASE)
+
+#ifdef USB_BTABLE
+#undef USB_BTABLE
+#endif
+#define USB_BTABLE              ((USB_BtableDef *)(USB_BTABLE_BASE))
+#define USB_ISTR_EPID           0x0000000F
+#define USB_FNR_LSOF_0          0x00000800
+#define USB_FNR_lSOF_1          0x00001000
+#define USB_LPMCSR_BESL_0       0x00000010
+#define USB_LPMCSR_BESL_1       0x00000020
+#define USB_LPMCSR_BESL_2       0x00000040
+#define USB_LPMCSR_BESL_3       0x00000080
+#define USB_EPnR_CTR_RX         0x00008000
+#define USB_EPnR_DTOG_RX        0x00004000
+#define USB_EPnR_STAT_RX        0x00003000
+#define USB_EPnR_STAT_RX_0      0x00001000
+#define USB_EPnR_STAT_RX_1      0x00002000
+#define USB_EPnR_SETUP          0x00000800
+#define USB_EPnR_EP_TYPE        0x00000600
+#define USB_EPnR_EP_TYPE_0      0x00000200
+#define USB_EPnR_EP_TYPE_1      0x00000400
+#define USB_EPnR_EP_KIND        0x00000100
+#define USB_EPnR_CTR_TX         0x00000080
+#define USB_EPnR_DTOG_TX        0x00000040
+#define USB_EPnR_STAT_TX        0x00000030
+#define USB_EPnR_STAT_TX_0      0x00000010
+#define USB_EPnR_STAT_TX_1      0x00000020
+#define USB_EPnR_EA             0x0000000F
+#define USB_COUNTn_RX_BLSIZE    0x00008000
+#define USB_COUNTn_NUM_BLOCK    0x00007C00
+#define USB_COUNTn_RX           0x0000003F
+
+#define USB_TypeDef USB_TypeDef_custom
+
+typedef struct {
+    __IO uint32_t EPnR[STM32ENDPOINTS];
+    __IO uint32_t RESERVED[STM32ENDPOINTS];
+    __IO uint32_t CNTR;
+    __IO uint32_t ISTR;
+    __IO uint32_t FNR;
+    __IO uint32_t DADDR;
+    __IO uint32_t BTABLE;
+#ifdef STM32F0
+    __IO uint32_t LPMCSR;
+    __IO uint32_t BCDR;
+#endif
+} USB_TypeDef;
+
+// F303 D/E have 2x16 access scheme
+typedef struct{
+#if defined USB2_16
+    __IO uint16_t USB_ADDR_TX;
+    __IO uint16_t USB_COUNT_TX;
+    __IO uint16_t USB_ADDR_RX;
+    __IO uint16_t USB_COUNT_RX;
+#define ACCESSZ (1)
+#define BUFTYPE uint8_t
+#elif defined USB1_16
+    __IO uint32_t USB_ADDR_TX;
+    __IO uint32_t USB_COUNT_TX;
+    __IO uint32_t USB_ADDR_RX;
+    __IO uint32_t USB_COUNT_RX;
+#define ACCESSZ (2)
+#define BUFTYPE uint16_t
+#else
+#error "Define USB1_16 or USB2_16"
+#endif
+} USB_EPDATA_TypeDef;
+
+
+typedef struct{
+    __IO USB_EPDATA_TypeDef EP[STM32ENDPOINTS];
+} USB_BtableDef;
+
+void USB_setup();
diff --git a/F1:F103/I2Cscan/version.inc b/F1:F103/I2Cscan/version.inc
new file mode 100644
index 0000000..95f8f38
--- /dev/null
+++ b/F1:F103/I2Cscan/version.inc
@@ -0,0 +1,2 @@
+#define BUILD_NUMBER "7"
+#define BUILD_DATE "2024-11-29"