From 934f4fbddd2a24387a3854cb5f272da569fd1000 Mon Sep 17 00:00:00 2001
From: Edward Emelianov <edward.emelianoff@gmail.com>
Date: Thu, 18 Sep 2025 23:54:01 +0300
Subject: [PATCH] start working with DMA

---
 F3:F303/I2C_scan/i2c.c                | 147 ++++++++++++++++----------
 F3:F303/I2C_scan/i2c.h                |   8 +-
 F3:F303/I2C_scan/i2cscan.bin          | Bin 14684 -> 15340 bytes
 F3:F303/I2C_scan/i2cscan.creator.user |   2 +-
 F3:F303/I2C_scan/proto.c              |  93 ++++++++--------
 F3:F303/I2C_scan/proto.h              |   2 +-
 F3:F303/I2C_scan/strfunc.c            |  35 ++++--
 F3:F303/I2C_scan/strfunc.h            |   2 +-
 F3:F303/I2C_scan/version.inc          |   4 +-
 9 files changed, 171 insertions(+), 122 deletions(-)

diff --git a/F3:F303/I2C_scan/i2c.c b/F3:F303/I2C_scan/i2c.c
index 4e0c65c..cbe1ded 100644
--- a/F3:F303/I2C_scan/i2c.c
+++ b/F3:F303/I2C_scan/i2c.c
@@ -32,6 +32,7 @@ static uint8_t i2caddr  = I2C_ADDREND; // current address in scan mode
 static volatile int I2Cbusy = 0, goterr = 0; // busy==1 when DMA active, goterr==1 if 't was error @ last sent
 static uint8_t I2Cbuf[I2C_BUFSIZE];
 static uint16_t i2cbuflen = 0; // buffer for DMA tx/rx and its len
+static volatile uint16_t dma_remain = 0; // remain bytes of DMA read/write
 static uint8_t bigendian = 0; // ==1 for big-endian 16-bit data
 static uint8_t dma16bit = 0; // 16-bit reading - possible need conversion from bigendian
 
@@ -117,49 +118,49 @@ void i2c_setup(i2c_speed_t speed){
 // setup DMA for rx (tx==0) or tx (tx==1)
 // DMA channels: 7 - I2C1_Rx, 6 - I2C1_Tx
 static void i2cDMAsetup(int tx, uint16_t len){
+    i2cbuflen = len;
+    if(len > 255) len = 255;
     if(tx){
         DMA1_Channel6->CCR = DMATXCCR;
         DMA1_Channel6->CPAR = (uint32_t) &I2C1->TXDR;
         DMA1_Channel6->CMAR = (uint32_t) I2Cbuf;
-        DMA1_Channel6->CNDTR = i2cbuflen = len;
+        DMA1_Channel6->CNDTR = len;
     }else{
         DMA1_Channel7->CCR = DMARXCCR;
         DMA1_Channel7->CPAR = (uint32_t) &I2C1->RXDR;
         DMA1_Channel7->CMAR = (uint32_t) I2Cbuf;
-        DMA1_Channel7->CNDTR = i2cbuflen = len;
+        DMA1_Channel7->CNDTR = len;
     }
 }
 
-// return 1 if line busy (also show error message and clear busy flag)
-static uint8_t i2c_chkbusy(){
+// wait until bit set or clear; return 1 if OK, 0 in case of timeout
+static uint8_t waitISRbit(uint32_t bit, uint8_t isset){
+    uint32_t waitwhile = (isset) ? 0 : bit; // wait until !=
+    const char *errmsg = NULL;
     cntr = Tms;
-    while(I2C1->ISR & I2C_ISR_BUSY){
+    if(bit != I2C_ISR_RXNE){ U("ISR wait "); U(uhex2str(bit)); USND(isset ? "set" : "reset"); }
+    while((I2C1->ISR & bit) == waitwhile){
         IWDG->KR = IWDG_REFRESH;
+        if(I2C1->ISR & I2C_ISR_NACKF){
+            errmsg = "NAK";
+            goto goterr;
+        }
         if(Tms - cntr > I2C_TIMEOUT){
-            U("i2c_chkbusy: Line busy;");
-            U("I2c->ISR = "); USND(uhex2str(I2C1->ISR));
-            I2C1->ICR = I2C_ICR_BERRCF;
-            return 1;  // line busy
-        }
-    }
-    return 0;
-}
-
-static uint8_t tc_tmout(){
-    cntr = Tms;
-    while(!(I2C1->ISR & I2C_ISR_TC)){
-        IWDG->KR = IWDG_REFRESH;
-        if(Tms - cntr > I2C_TIMEOUT){
-            USND("i2c: TC timeout");
-            return 1;
+            errmsg = "timeout";
+            goto goterr;
         }
     }
+    return 1;
+goterr:
+    U("wait ISR bit: "); USND(errmsg);
+    U("I2c->ISR = "); USND(uhex2str(I2C1->ISR));
+    I2C1->ICR = 0xff;
     return 0;
 }
 
 // start writing
 static uint8_t i2c_startw(uint8_t addr, uint16_t nbytes, uint8_t stop){
-    if(i2c_chkbusy()) return 0;
+    if(!waitISRbit(I2C_ISR_BUSY, 0)) return 0;
     I2C1->CR2 = nbytes << 16 | addr;
     if(stop){
         I2C1->CR2 |= I2C_CR2_AUTOEND; // autoend
@@ -201,9 +202,9 @@ static uint8_t write_i2cs(uint8_t addr, uint8_t *data, uint16_t nbytes, uint8_t
     }
     cntr = Tms;
     if(stop){
-        if(i2c_chkbusy()) return 0;
+        if(!waitISRbit(I2C_ISR_BUSY, 0)) return 0;
     }else{ // repeated start
-        if(tc_tmout()) return 0;
+        if(!waitISRbit(I2C_ISR_TC, 1)) return 0;
     }
     return 1;
 }
@@ -247,12 +248,14 @@ uint8_t write_i2c_dma16(uint8_t addr, uint16_t *data, uint16_t nwords){
     return 1;
 }
 
-// start reading
-static uint8_t i2c_startr(uint8_t addr, uint16_t nbytes){
-    // read N bytes
-    I2C1->CR2 = (nbytes<<16) | addr | I2C_CR2_RD_WRN;
-    I2C1->CR2 |= I2C_CR2_START;
-    I2C1->CR2 |= I2C_CR2_AUTOEND;
+// start reading of `nbytes` from `addr`; if `start`==`, set START
+static uint8_t i2c_startr(uint8_t addr, uint16_t nbytes, uint8_t start){
+    uint32_t cr2 = addr | I2C_CR2_RD_WRN;
+    if(nbytes > 255){
+        nbytes = 255; cr2 |= I2C_CR2_RELOAD;
+    }else cr2 |= I2C_CR2_AUTOEND;
+    cr2 |= (nbytes << 16);
+    I2C1->CR2 = (start) ? cr2 | I2C_CR2_START : cr2;
     return 1;
 }
 
@@ -263,26 +266,33 @@ static uint8_t i2c_startr(uint8_t addr, uint16_t nbytes){
  * @return 1 if all OK, 0 if NACK or no device found
  */
 static uint8_t *read_i2cb(uint8_t addr, uint16_t nbytes, uint8_t busychk){
-    if(busychk && i2c_chkbusy()) return NULL;
-    if(!i2c_startr(addr, nbytes)) return NULL;
-    uint8_t i;
-    for(i = 0; i < nbytes; ++i){
-        cntr = Tms;
-        while(!(I2C1->ISR & I2C_ISR_RXNE)){ // wait for data
-            IWDG->KR = IWDG_REFRESH;
-            if(I2C1->ISR & I2C_ISR_NACKF){
-                I2C1->ICR |= I2C_ICR_NACKCF;
-                USND("read_i2cb: NAK");
-                return NULL;
+    if(busychk && !waitISRbit(I2C_ISR_BUSY, 0)) return NULL;
+    uint8_t start = 1;
+    uint8_t *bptr = I2Cbuf;
+    while(nbytes){
+        U("Read "); U(u2str(nbytes)); USND(" bytes");
+        if(!i2c_startr(addr, nbytes, start)) return NULL;
+        if(nbytes < 256){
+            for(int i = 0; i < nbytes; ++i){
+                if(!waitISRbit(I2C_ISR_RXNE, 1)) goto tmout;
+                *bptr++ = I2C1->RXDR;
             }
-            if(Tms - cntr > I2C_TIMEOUT){
-                USND("read_i2cb: Timeout");
-                return NULL;
+            while(waitISRbit(I2C_ISR_RXNE, 1)){
+                U("OOOps! We have another byte: "); USND(uhex2str(I2C1->RXDR));
             }
+            break;
+        }else while(!(I2C1->ISR & I2C_ISR_TCR)){ // until first part read
+            if(!waitISRbit(I2C_ISR_RXNE, 1)) goto tmout;
+            *bptr++ = I2C1->RXDR;
         }
-        I2Cbuf[i] = I2C1->RXDR;
+        USND("next");
+        nbytes -= 255;
+        start = 0;
     }
     return I2Cbuf;
+tmout:
+    USND("read I2C: Timeout");
+    return NULL;
 }
 
 uint8_t *read_i2c(uint8_t addr, uint16_t nbytes){
@@ -290,30 +300,29 @@ uint8_t *read_i2c(uint8_t addr, uint16_t nbytes){
     return read_i2cb(addr, nbytes, 1);
 }
 
-static uint8_t dmard(uint8_t addr, uint16_t nbytes){
+static uint8_t dmard(uint8_t addr, uint16_t nbytes, uint8_t stop){
     if(nbytes < 1 || nbytes > I2C_BUFSIZE) return 0;
     if(isI2Cbusy()) return 0;
     i2cDMAsetup(0, nbytes);
     goterr = 0;
     i2c_got_DMA = 0;
+    if(!i2c_startr(addr, nbytes, stop)) return 0;
+    dma_remain = nbytes > 255 ? nbytes - 255 : 0; // remainder after first read finish
+    (void) I2C1->RXDR; // avoid wrong first byte
     DMA1_Channel7->CCR = DMARXCCR | DMA_CCR_EN; // init DMA before START sequence
-    if(i2c_chkbusy() || !i2c_startr(addr, nbytes)){
-        DMA1_Channel7->CCR = 0;
-        return 0;
-    }
     I2Cbusy = 1;
     return 1;
 }
 
 uint8_t read_i2c_dma(uint8_t addr, uint16_t nbytes){
-    uint8_t got = dmard(addr, nbytes);
+    uint8_t got = dmard(addr, nbytes, 1);
     if(got) dma16bit = 0;
     return got;
 }
 
 uint8_t read_i2c_dma16(uint8_t addr, uint16_t nwords){
     if(nwords > I2C_BUFSIZE/2) return 0; // what if `nwords` is very large? we should check it
-    uint8_t got = dmard(addr, nwords<<1);
+    uint8_t got = dmard(addr, nwords<<1, 1);
     if(got) dma16bit = 1;
     return got;
 }
@@ -325,17 +334,26 @@ static void swapbytes(uint16_t *data, uint16_t datalen){
 }
 
 // read register reg
-uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint16_t nbytes){
+uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint16_t nbytes, uint8_t isdma){
     if(isI2Cbusy()) return NULL;
     if(!write_i2cs(addr, &reg, 1, 0)) return NULL;
+    if(isdma){
+        if(dmard(addr, nbytes, 0)){ dma16bit = 0; return I2Cbuf;} // for DMA we just return something non-null to check OK
+        return NULL;
+    }
     return read_i2cb(addr, nbytes, 0);
 }
 
+
 // read 16bit register reg
-uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint16_t nwords){
+uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint16_t nwords, uint8_t isdma){
     if(isI2Cbusy() || nwords < 1 || nwords > I2C_BUFSIZE/2) return 0;
     if(bigendian) reg16 = __REV16(reg16);
     if(!write_i2cs(addr, (uint8_t*)&reg16, 2, 0)) return NULL;
+    if(isdma){
+        if(dmard(addr, nwords<<1, 0)){ dma16bit = 1; return (uint16_t*)I2Cbuf; }
+        return NULL;
+    }
     if(!read_i2cb(addr, nwords*2, 0)) return NULL;
     uint16_t *buf = (uint16_t*)I2Cbuf;
     if(bigendian) swapbytes(buf, nwords);
@@ -403,8 +421,25 @@ void endianness(uint8_t isbig){
 static void I2C_isr(int rx){
     uint32_t isr = DMA1->ISR;
     DMA_Channel_TypeDef *ch = (rx) ? DMA1_Channel7 : DMA1_Channel6;
-    if(isr & (DMA_ISR_TEIF6 | DMA_ISR_TEIF6)) goterr = 1;
-    else if(rx) i2c_got_DMA = 1; // last transfer was Rx
+    ch->CCR &= ~DMA_CCR_EN; // clear enable for further settings
+    if(isr & (DMA_ISR_TEIF6 | DMA_ISR_TEIF7)){
+        goterr = 1; goto ret;
+    }
+    if(dma_remain){ // receive/send next portion
+        uint16_t len = (dma_remain > 255) ? 255 : dma_remain;
+        ch->CNDTR = len;
+        if(rx){
+            if(!i2c_startr(0, dma_remain, 0)){
+                goterr = 1; goto ret;
+            }
+            ch->CMAR += 255;
+        }
+        dma_remain -= len;
+        ch->CCR |= DMA_CCR_EN;
+        DMA1->IFCR = DMA_IFCR_CTCIF6 | DMA_IFCR_CTCIF7;
+        return;
+    }else if(rx) i2c_got_DMA = 1; // last transfer was Rx and all data read
+ret:
     ch->CCR = 0;
     I2Cbusy = 0;
     DMA1->IFCR = 0x0ff00000; // clear all flags for channel6/7
diff --git a/F3:F303/I2C_scan/i2c.h b/F3:F303/I2C_scan/i2c.h
index 2ac60e3..ff7c6a9 100644
--- a/F3:F303/I2C_scan/i2c.h
+++ b/F3:F303/I2C_scan/i2c.h
@@ -20,7 +20,7 @@
 #include <stdint.h>
 
 #define I2C_ADDREND     (0x80)
-#define I2C_BUFSIZE     (1024)
+#define I2C_BUFSIZE     (2048)
 
 typedef enum{
     I2C_SPEED_10K,
@@ -35,12 +35,12 @@ extern i2c_speed_t i2c_curspeed;
 extern volatile uint8_t i2c_scanmode;
 
 // timeout of I2C bus in ms
-#define I2C_TIMEOUT             (100)
+#define I2C_TIMEOUT             (5)
 
 void i2c_setup(i2c_speed_t speed);
 uint8_t *read_i2c(uint8_t addr, uint16_t nbytes);
-uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint16_t nbytes);
-uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint16_t nbytes);
+uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint16_t nbytes, uint8_t isdma);
+uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint16_t nbytes, uint8_t isdma);
 uint8_t write_i2c(uint8_t addr, uint8_t *data, uint16_t nbytes);
 
 uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint16_t nbytes);
diff --git a/F3:F303/I2C_scan/i2cscan.bin b/F3:F303/I2C_scan/i2cscan.bin
index 15842b428a1cf72b918f5b802b8598e22c07450f..19d1344bad1da20581ea08431d9a3445174bf42e 100755
GIT binary patch
delta 5901
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
PWpwDj<wtqcf|36Qb~P#F

delta 5325
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
LI7U-e3$6bGSBC&l

diff --git a/F3:F303/I2C_scan/i2cscan.creator.user b/F3:F303/I2C_scan/i2cscan.creator.user
index e4d65cf..138fc14 100644
--- a/F3:F303/I2C_scan/i2cscan.creator.user
+++ b/F3:F303/I2C_scan/i2cscan.creator.user
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 17.0.1, 2025-09-16T22:52:13. -->
+<!-- Written by QtCreator 17.0.1, 2025-09-18T23:52:40. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
diff --git a/F3:F303/I2C_scan/proto.c b/F3:F303/I2C_scan/proto.c
index 2657d0b..e3dc07c 100644
--- a/F3:F303/I2C_scan/proto.c
+++ b/F3:F303/I2C_scan/proto.c
@@ -36,17 +36,16 @@ static const char *helpstring =
         "Ia addr - set I2C address\n"
         "Ig - dump content of I2Cbuf\n"
         "Iw bytes - send bytes (hex/dec/oct/bin) to I2C\n"
-        "IW bytes - the same over DMA\n"
         "Ir reg n - read n bytes from I2C reg\n"
         "I2 reg16 n - read n words from 16-bit register\n"
         "In n - just read n bytes\n"
-        "IN n - the same but with DMA\n"
         "Is - scan I2C bus\n"
+        "-- note: all rw commands for 'I' could be started from 'D', meaning DMA operations --\n"
         "L - switch to little-endian (default) format for 16-bit registers\n"
         "T - print current Tms\n"
 ;
 
-TRUE_INLINE const char *setupI2C(const char *buf){
+TRUE_INLINE const char *setupI2C(char *buf){
     if(!buf || !*buf){
         U("Current speed: "); USB_putbyte('0' + i2c_curspeed); newline();
         return NULL;
@@ -72,16 +71,13 @@ TRUE_INLINE const char *saI2C(const char *buf){
     U("I2Caddr="); USND(uhex2str(addr));
     return OK;
 }
-static void rdI2C(const char *buf, int is16){
+static void rdI2C(const char *buf, int is16, int dmaflag){
     uint32_t N = 0;
-    int noreg = 0; // write register  (==1 - just read, ==2 - -//- using DMA)
+    int noreg = 0; // ==1 - just read (without sending regno)
     const char *nxt = NULL;
     if(*buf == 'n'){
         ++buf;
         noreg = 1;
-    }else if(*buf == 'N'){
-        ++buf;
-        noreg = 2;
     }else{
         nxt = getnum(buf, &N);
         if(!nxt || buf == nxt || N > 0xffff || (!is16 &&  N > 0xff)){
@@ -92,7 +88,7 @@ static void rdI2C(const char *buf, int is16){
     }
     uint16_t reg = N;
     nxt = getnum(buf, &N);
-    uint32_t maxn = (is16) ? I2C_BUFSIZE : I2C_BUFSIZE / 2;
+    uint32_t maxn = (is16) ? I2C_BUFSIZE / 2 : I2C_BUFSIZE;
     if(!nxt || buf == nxt || N > maxn){
         USND("Bad length");
         return;
@@ -100,32 +96,32 @@ static void rdI2C(const char *buf, int is16){
     const char *erd = "Error reading I2C\n";
     uint8_t *b8 = NULL; uint16_t *b16 = NULL;
     if(noreg){ // don't write register
-        if(noreg == 1){
+        if(dmaflag){
+            U("Try to read using DMA .. ");
+            if(!read_i2c_dma(I2Caddress, N)) U(erd);
+            else U(OK);
+            return;
+        }else{
             USND("Simple read:");
             if(!(b8 = read_i2c(I2Caddress, N))){
                 U(erd);
                 return;
             }
-        }else{
-            U("Try to read using DMA .. ");
-            if(!read_i2c_dma(I2Caddress, N)) U(erd);
-            else U(OK);
-            return;
         }
     }else{
         if(is16){
-            if(!(b16 = read_i2c_reg16(I2Caddress, reg, N))){
+            if(!(b16 = read_i2c_reg16(I2Caddress, reg, N, dmaflag))){
                 U(erd);
                 return;
             }
         }else{
-            if(!(b8 = read_i2c_reg(I2Caddress, reg, N))){
+            if(!(b8 = read_i2c_reg(I2Caddress, reg, N, dmaflag))){
                 U(erd);
                 return;
             }
         }
     }
-    if(N == 0){ U(OK); return; }
+    if(N == 0 || dmaflag){ U(OK); return; }
     if(!noreg){U("Register "); U(uhex2str(reg)); U(":\n");}
     if(is16) hexdump16(USB_sendstr, b16, N);
     else hexdump(USB_sendstr, b8, N);
@@ -145,41 +141,46 @@ TRUE_INLINE uint16_t readNnumbers(const char *buf){
 }
 static const char *wrI2C(const char *buf, int isdma){
     uint16_t N = readNnumbers(buf);
+    if(N == 0) return "Enter at least one number\n";
     int result = isdma ? write_i2c_dma(I2Caddress, locBuffer, N) :
                          write_i2c(I2Caddress, locBuffer, N);
     if(!result) return "Error writing I2C\n";
     return OK;
 }
 
-const char *parse_cmd(const char *buf){
+const char *parse_cmd(char *buf){
     if(!buf || !*buf) return NULL;
-    if(buf[1]) switch(*buf){ // "long" commands
-        case 'i':
-            return setupI2C(buf + 1);
-        break;
-        case 'I':
-            buf = omit_spaces(buf + 1);
-            switch(*buf){
-                case 'a': return saI2C(buf + 1);
-                case 'r':
-                    rdI2C(buf + 1, 0); return NULL;
-                case '2':
-                    rdI2C(buf + 1, 1); return NULL;
-                case 'n':
-                case 'N':
-                    rdI2C(buf, 0); return NULL;
-                case 'w': return wrI2C(buf + 1, 0);
-                case 'W': return wrI2C(buf + 1, 1);
-                case 's':
-                    i2c_init_scan_mode(); return "Start scan\n";
-                case 'g':
-                    i2c_bufdudump(); return NULL;
-                default:
-                    return "Wrong I2C command, read help!\n";
-            }
-        break;
-        default:
-            return("Wrong command, try '?' for help\n");
+    int dmaflag = 0;
+    if(buf[1]){
+        if(*buf == 'D'){
+            dmaflag = 1; *buf = 'I'; // parse as for normal, but with DMA flag
+        }
+        switch(*buf){ // "long" commands
+            case 'i':
+                return setupI2C(buf + 1);
+            break;
+            case 'I':
+                buf = omit_spaces(buf + 1);
+                switch(*buf){
+                    case 'a': return saI2C(buf + 1);
+                    case 'r':
+                        rdI2C(buf + 1, 0, dmaflag); return NULL;
+                    case '2':
+                        rdI2C(buf + 1, 1, dmaflag); return NULL;
+                    case 'n':
+                        rdI2C(buf, 0, dmaflag); return NULL;
+                    case 'w': return wrI2C(buf + 1, dmaflag);
+                    case 's':
+                        i2c_init_scan_mode(); return "Start scan\n";
+                    case 'g':
+                        i2c_bufdudump(); return NULL;
+                    default:
+                        return "Wrong I2C command, read help!\n";
+                }
+            break;
+            default:
+                return("Wrong command, try '?' for help\n");
+        }
     }
     switch(*buf){
         case 'i': return setupI2C(NULL); // current settings
diff --git a/F3:F303/I2C_scan/proto.h b/F3:F303/I2C_scan/proto.h
index 5c21204..62f183a 100644
--- a/F3:F303/I2C_scan/proto.h
+++ b/F3:F303/I2C_scan/proto.h
@@ -18,5 +18,5 @@
 
 #pragma once
 
-char *parse_cmd(char *buf);
+const char *parse_cmd(char *buf);
 
diff --git a/F3:F303/I2C_scan/strfunc.c b/F3:F303/I2C_scan/strfunc.c
index 26f5eed..7e0846c 100644
--- a/F3:F303/I2C_scan/strfunc.c
+++ b/F3:F303/I2C_scan/strfunc.c
@@ -18,6 +18,16 @@
 
 #include "strfunc.h"
 
+// hex line number for hexdumps
+static void u16s(uint16_t n, char *buf){
+    for(int j = 3; j > -1; --j){
+        register uint8_t q = n & 0xf;
+        n >>= 4;
+        if(q < 10) buf[j] = q + '0';
+        else buf[j] = q - 10 + 'a';
+    }
+}
+
 /**
  * @brief hexdump - dump hex array by 16 bytes in string
  * @param sendfun - function to send data
@@ -25,7 +35,7 @@
  * @param len - length of `arr`
  */
 void hexdump(int (*sendfun)(const char *s), uint8_t *arr, uint16_t len){
-    char buf[52], *bptr = buf;
+    char buf[64] = "0000  ", *bptr = &buf[6];
     for(uint16_t l = 0; l < len; ++l, ++arr){
         for(int16_t j = 1; j > -1; --j){
             register uint8_t half = (*arr >> (4*j)) & 0x0f;
@@ -36,10 +46,11 @@ void hexdump(int (*sendfun)(const char *s), uint8_t *arr, uint16_t len){
             *bptr++ = '\n';
             *bptr = 0;
             sendfun(buf);
-            bptr = buf;
+            u16s(l + 1, buf);
+            bptr = &buf[6];
         }else *bptr++ = ' ';
     }
-    if(bptr != buf){
+    if(bptr != &buf[6]){
         *bptr++ = '\n';
         *bptr = 0;
         sendfun(buf);
@@ -48,24 +59,26 @@ void hexdump(int (*sendfun)(const char *s), uint8_t *arr, uint16_t len){
 
 // dump uint16_t by 8 values in string
 void hexdump16(int (*sendfun)(const char *s), uint16_t *arr, uint16_t len){
-    char buf[52], *bptr = buf;
+    char buf[64] = "0000  ", *bptr = &buf[6];
     for(uint16_t l = 0; l < len; ++l, ++arr){
-        uint16_t val = *arr;
-        for(int16_t j = 3; j > -1; --j){
+        //uint16_t val = *arr;
+        u16s(*arr, bptr);
+        /*for(int16_t j = 3; j > -1; --j){
             register uint8_t q = val & 0xf;
             val >>= 4;
             if(q < 10) bptr[j] = q + '0';
             else bptr[j] = q - 10 + 'a';
-        }
+        }*/
         bptr += 4;
         if((l & 7) == 7){
             *bptr++ = '\n';
             *bptr = 0;
             sendfun(buf);
-            bptr = buf;
+            u16s((l + 1)*2, buf); // number of byte, not word!
+            bptr = &buf[6];
         }else *bptr++ = ' ';
     }
-    if(bptr != buf){
+    if(bptr != &buf[6]){
         *bptr++ = '\n';
         *bptr = 0;
         sendfun(buf);
@@ -142,12 +155,12 @@ const char *uhex2str(uint32_t val){
  * @param buf - string
  * @return - pointer to first character in `buf` > ' '
  */
-const char *omit_spaces(const char *buf){
+char *omit_spaces(const char *buf){
     while(*buf){
         if(*buf > ' ') break;
         ++buf;
     }
-    return buf;
+    return (char*)buf;
 }
 
 /**
diff --git a/F3:F303/I2C_scan/strfunc.h b/F3:F303/I2C_scan/strfunc.h
index 663cd29..0ee15d9 100644
--- a/F3:F303/I2C_scan/strfunc.h
+++ b/F3:F303/I2C_scan/strfunc.h
@@ -27,5 +27,5 @@ const char *u2str(uint32_t val);
 const char *i2str(int32_t i);
 const char *uhex2str(uint32_t val);
 const char *getnum(const char *txt, uint32_t *N);
-const char *omit_spaces(const char *buf);
+char *omit_spaces(const char *buf);
 const char *getint(const char *txt, int32_t *I);
diff --git a/F3:F303/I2C_scan/version.inc b/F3:F303/I2C_scan/version.inc
index 7d89eca..f4704de 100644
--- a/F3:F303/I2C_scan/version.inc
+++ b/F3:F303/I2C_scan/version.inc
@@ -1,2 +1,2 @@
-#define BUILD_NUMBER "104"
-#define BUILD_DATE "2025-09-16"
+#define BUILD_NUMBER "136"
+#define BUILD_DATE "2025-09-18"