From 080be6a1ecfa8c14f558fd1160fdb606cf7a0d32 Mon Sep 17 00:00:00 2001
From: Edward Emelianov <edward.emelianoff@gmail.com>
Date: Fri, 19 Sep 2025 21:24:19 +0300
Subject: [PATCH] OK, I2C read by DMA works

---
 F3:F303/I2C_scan/i2c.c                | 135 ++++++++++++--------------
 F3:F303/I2C_scan/i2c.h                |  26 ++---
 F3:F303/I2C_scan/i2cscan.bin          | Bin 15340 -> 9388 bytes
 F3:F303/I2C_scan/i2cscan.creator.user |   2 +-
 F3:F303/I2C_scan/main.c               |   6 +-
 F3:F303/I2C_scan/proto.c              |  26 ++---
 F3:F303/I2C_scan/ringbuffer.c         |  13 ++-
 F3:F303/I2C_scan/version.inc          |   4 +-
 8 files changed, 103 insertions(+), 109 deletions(-)

diff --git a/F3:F303/I2C_scan/i2c.c b/F3:F303/I2C_scan/i2c.c
index cbe1ded..433208b 100644
--- a/F3:F303/I2C_scan/i2c.c
+++ b/F3:F303/I2C_scan/i2c.c
@@ -136,40 +136,35 @@ static void i2cDMAsetup(int tx, uint16_t len){
 // 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;
+    //const char *errmsg = NULL;
     cntr = Tms;
-    if(bit != I2C_ISR_RXNE){ U("ISR wait "); U(uhex2str(bit)); USND(isset ? "set" : "reset"); }
+    //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";
+            //errmsg = "NAK";
             goto goterr;
         }
         if(Tms - cntr > I2C_TIMEOUT){
-            errmsg = "timeout";
+            //errmsg = "timeout";
             goto goterr;
         }
     }
     return 1;
 goterr:
-    U("wait ISR bit: "); USND(errmsg);
-    U("I2c->ISR = "); USND(uhex2str(I2C1->ISR));
+    /*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){
+static uint8_t i2c_startw(uint8_t addr, uint8_t nbytes, uint8_t stop){
     if(!waitISRbit(I2C_ISR_BUSY, 0)) return 0;
-    I2C1->CR2 = nbytes << 16 | addr;
-    if(stop){
-        I2C1->CR2 |= I2C_CR2_AUTOEND; // autoend
-    }else{
-        //I2C1->CR2 &= ~I2C_CR2_AUTOEND;
-        //I2C1->CR2 |= I2C_CR2_RELOAD;
-    }
+    uint32_t cr2 = nbytes << 16 | addr | I2C_CR2_START;
+    if(stop) cr2 |= I2C_CR2_AUTOEND;
     // now start transfer
-    I2C1->CR2 |= I2C_CR2_START;
+    I2C1->CR2 = cr2;
     return 1;
 }
 
@@ -181,7 +176,7 @@ static uint8_t i2c_startw(uint8_t addr, uint16_t nbytes, uint8_t stop){
  * @param stop - to set STOP
  * @return 0 if error
  */
-static uint8_t write_i2cs(uint8_t addr, uint8_t *data, uint16_t nbytes, uint8_t stop){
+static uint8_t i2c_writes(uint8_t addr, uint8_t *data, uint8_t nbytes, uint8_t stop){
     if(!i2c_startw(addr, nbytes, stop)) return 0;
     for(int i = 0; i < nbytes; ++i){
         cntr = Tms;
@@ -189,16 +184,16 @@ static uint8_t write_i2cs(uint8_t addr, uint8_t *data, uint16_t nbytes, uint8_t
             IWDG->KR = IWDG_REFRESH;
             if(I2C1->ISR & I2C_ISR_NACKF){
                 I2C1->ICR |= I2C_ICR_NACKCF;
-                USND("write_i2cs: NAK");
+                //USND("i2c_writes: NAK");
                 return 0;
             }
             if(Tms - cntr > I2C_TIMEOUT){
-                USND("write_i2cs: Timeout");
+                //USND("i2c_writes: Timeout");
                 return 0;
             }
         }
         I2C1->TXDR = data[i]; // send data
-        U("write_i2cs: "); USND(uhex2str(data[i]));
+        //U("i2c_writes: "); USND(uhex2str(data[i]));
     }
     cntr = Tms;
     if(stop){
@@ -209,19 +204,13 @@ static uint8_t write_i2cs(uint8_t addr, uint8_t *data, uint16_t nbytes, uint8_t
     return 1;
 }
 
-uint8_t write_i2c(uint8_t addr, uint8_t *data, uint16_t nbytes){
+uint8_t i2c_write(uint8_t addr, uint8_t *data, uint8_t nbytes){
     if(isI2Cbusy()) return 0;
-    return write_i2cs(addr, data, nbytes, 1);
+    return i2c_writes(addr, data, nbytes, 1);
 }
 
-/*
-uint8_t write_i2c16(uint8_t addr, uint8_t *data, uint8_t nbytes){
-    if(isI2Cbusy()) return 0;
-    return write_i2cs(addr, data, nbytes, 1);
-}*/
-
-uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint16_t nbytes){
-    if(!data || nbytes < 1 || nbytes > I2C_BUFSIZE) return 0;
+uint8_t i2c_write_dma(uint8_t addr, uint8_t *data, uint8_t nbytes){
+    if(!data || nbytes < 1) return 0;
     if(isI2Cbusy()) return 0;
     memcpy(I2Cbuf, data, nbytes);
     i2cDMAsetup(1, nbytes);
@@ -232,8 +221,8 @@ uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint16_t nbytes){
     return 1;
 }
 
-uint8_t write_i2c_dma16(uint8_t addr, uint16_t *data, uint16_t nwords){
-    if(!data || nwords < 1 || nwords > I2C_BUFSIZE/2) return 0;
+uint8_t i2c_write_dma16(uint8_t addr, uint16_t *data, uint8_t nwords){
+    if(!data || nwords < 1 || nwords > 127) return 0;
     if(isI2Cbusy()) return 0;
     uint16_t nbytes = nwords << 1;
     if(bigendian){
@@ -251,10 +240,8 @@ uint8_t write_i2c_dma16(uint8_t addr, uint16_t *data, uint16_t nwords){
 // 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);
+    if(nbytes > 255) cr2 |= I2C_CR2_RELOAD | (0xff0000);
+    else cr2 |= I2C_CR2_AUTOEND | (nbytes << 16);
     I2C1->CR2 = (start) ? cr2 | I2C_CR2_START : cr2;
     return 1;
 }
@@ -265,64 +252,64 @@ static uint8_t i2c_startr(uint8_t addr, uint16_t nbytes, uint8_t start){
  * `data` should be an array with at least `nbytes` length
  * @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 && !waitISRbit(I2C_ISR_BUSY, 0)) return NULL;
+static uint8_t *i2c_readb(uint8_t addr, uint16_t nbytes){
     uint8_t start = 1;
     uint8_t *bptr = I2Cbuf;
     while(nbytes){
-        U("Read "); U(u2str(nbytes)); USND(" bytes");
+        //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;
             }
-            while(waitISRbit(I2C_ISR_RXNE, 1)){
+            /*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;
         }
-        USND("next");
+        //USND("next");
         nbytes -= 255;
         start = 0;
     }
     return I2Cbuf;
 tmout:
-    USND("read I2C: Timeout");
+    //USND("read I2C: Timeout");
     return NULL;
 }
 
-uint8_t *read_i2c(uint8_t addr, uint16_t nbytes){
-    if(isI2Cbusy()) return 0;
-    return read_i2cb(addr, nbytes, 1);
+uint8_t *i2c_read(uint8_t addr, uint16_t nbytes){
+    if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0)) return 0;
+    return i2c_readb(addr, nbytes);
 }
 
-static uint8_t dmard(uint8_t addr, uint16_t nbytes, uint8_t stop){
+static uint8_t dmard(uint8_t addr, uint16_t nbytes){
     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_startr(addr, nbytes, 1)) return 0;
+    dma_remain = nbytes > 255 ? nbytes - 255 : 0; // remainder after first read finish
     I2Cbusy = 1;
     return 1;
 }
 
-uint8_t read_i2c_dma(uint8_t addr, uint16_t nbytes){
-    uint8_t got = dmard(addr, nbytes, 1);
+uint8_t i2c_read_dma(uint8_t addr, uint16_t nbytes){
+    if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0)) return 0;
+    uint8_t got = dmard(addr, nbytes);
     if(got) dma16bit = 0;
     return got;
 }
 
-uint8_t read_i2c_dma16(uint8_t addr, uint16_t nwords){
+uint8_t i2c_read_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, 1);
+    if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0)) return 0;
+    uint8_t got = dmard(addr, nwords<<1);
     if(got) dma16bit = 1;
     return got;
 }
@@ -334,30 +321,29 @@ 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 isdma){
-    if(isI2Cbusy()) return NULL;
-    if(!write_i2cs(addr, &reg, 1, 0)) return NULL;
+uint8_t *i2c_read_reg(uint8_t addr, uint8_t reg, uint16_t nbytes, uint8_t isdma){
+    if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0)) return NULL;
+    if(!i2c_writes(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
+        if(dmard(addr, nbytes)){ dma16bit = 0; return I2Cbuf;} // for DMA we just return something non-null to check OK
         return NULL;
     }
-    return read_i2cb(addr, nbytes, 0);
+    return i2c_readb(addr, nbytes);
 }
 
 
 // read 16bit register reg
-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;
+uint16_t *i2c_read_reg16(uint8_t addr, uint16_t reg16, uint16_t nwords, uint8_t isdma){
+    if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0) || 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(!i2c_writes(addr, (uint8_t*)&reg16, 2, 0)) return NULL;
     if(isdma){
-        if(dmard(addr, nwords<<1, 0)){ dma16bit = 1; return (uint16_t*)I2Cbuf; }
+        if(dmard(addr, nwords<<1)){ 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);
-    return buf;
+    if(!i2c_readb(addr, nwords<<1)) return NULL;
+    if(bigendian) swapbytes((uint16_t*)I2Cbuf, nwords);
+    return (uint16_t*)I2Cbuf;
 }
 
 void i2c_init_scan_mode(){
@@ -376,7 +362,7 @@ int i2c_scan_next_addr(uint8_t *addr){
         i2c_scanmode = 0;
         return 0;
     }
-    if(!read_i2c((i2caddr++)<<1, 1)) return 0;
+    if(!i2c_read((i2caddr++)<<1, 1)) return 0;
     return 1;
 }
 
@@ -389,31 +375,30 @@ void i2c_bufdudump(){
     if(i2cbuflen < 1) return;
     USND("I2C buffer:");
     if(dma16bit) hexdump16(USB_sendstr, (uint16_t*)I2Cbuf, i2cbuflen);
-    hexdump(USB_sendstr, I2Cbuf, i2cbuflen);
+    else hexdump(USB_sendstr, I2Cbuf, i2cbuflen);
 }
 
 // get DMA buffer with conversion to little-endian (if transfer was for 16-bit)
-uint8_t *i2cdma_getbuf(uint16_t *len){
+uint8_t *i2c_dma_getbuf(uint16_t *len){
     if(!i2c_got_DMA || i2cbuflen < 1) return NULL;
     i2c_got_DMA = 0;
     if(dma16bit){
         i2cbuflen >>= 1; // for hexdump16 - now buffer have uint16_t!
-        uint16_t *b = (uint16_t*)I2Cbuf;
-        if(bigendian){
-            for(int i = 0; i < i2cbuflen; ++i) b[i] = __REV(b[i]);
-        }
+        if(bigendian) swapbytes((uint16_t*)I2Cbuf, i2cbuflen);
     }
     if(len) *len = i2cbuflen;
     return I2Cbuf;
 }
 
-int i2cdma_haderr(){
+int i2c_dma_haderr(){
     int r = goterr;
     goterr = 0;
     return r;
 }
 
-void endianness(uint8_t isbig){
+int i2c_busy(){ return I2Cbusy;}
+
+void i2c_endianness(uint8_t isbig){
     bigendian = isbig;
 }
 
diff --git a/F3:F303/I2C_scan/i2c.h b/F3:F303/I2C_scan/i2c.h
index ff7c6a9..3869051 100644
--- a/F3:F303/I2C_scan/i2c.h
+++ b/F3:F303/I2C_scan/i2c.h
@@ -35,23 +35,25 @@ extern i2c_speed_t i2c_curspeed;
 extern volatile uint8_t i2c_scanmode;
 
 // timeout of I2C bus in ms
-#define I2C_TIMEOUT             (5)
+#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, 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);
+int i2c_busy();
 
-uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint16_t nbytes);
-uint8_t write_i2c_dma16(uint8_t addr, uint16_t *data, uint16_t nwords);
-uint8_t read_i2c_dma(uint8_t addr, uint16_t nbytes);
+uint8_t *i2c_read(uint8_t addr, uint16_t nbytes);
+uint8_t i2c_read_dma(uint8_t addr, uint16_t nbytes);
+uint8_t i2c_read_dma16(uint8_t addr, uint16_t nwords);
+uint8_t *i2c_read_reg(uint8_t addr, uint8_t reg, uint16_t nbytes, uint8_t isdma);
+uint16_t *i2c_read_reg16(uint8_t addr, uint16_t reg16, uint16_t nbytes, uint8_t isdma);
+
+uint8_t i2c_write(uint8_t addr, uint8_t *data, uint8_t nbytes);
+uint8_t i2c_write_dma(uint8_t addr, uint8_t *data, uint8_t nbytes);
+uint8_t i2c_write_dma16(uint8_t addr, uint16_t *data, uint8_t nwords);
 
 void i2c_bufdudump();
-int i2cdma_haderr();
-uint8_t *i2cdma_getbuf(uint16_t *len);
-uint8_t read_i2c_dma16(uint8_t addr, uint16_t nwords);
-void endianness(uint8_t isbig);
+int i2c_dma_haderr();
+uint8_t *i2c_dma_getbuf(uint16_t *len);
+void i2c_endianness(uint8_t isbig);
 int i2c_getwords(uint16_t *buf, int bufsz);
 
 void i2c_init_scan_mode();
diff --git a/F3:F303/I2C_scan/i2cscan.bin b/F3:F303/I2C_scan/i2cscan.bin
index 19d1344bad1da20581ea08431d9a3445174bf42e..ca529c2a8271c79c0880d1162608ad97a3a9767a 100755
GIT binary patch
literal 9388
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

literal 15340
zcmdsee{@^bo#%aevL(w-BHQ_4OAg3ZAPLG3Cx#@p+G1oQVk^{~I4oeN2g$a=lgB?4
z{~)qoaw4EDO2R@QOlfSklXhlL=X7T$j7SPtWz4pFma}`9J#x}c6Fb>?w4H_Nwnc#y
z%X*2mpYMH=Ee9xb=Ff4?)qC&$_}=fY`~80J_ujBG%y#;2W=x~Z-BQ>sf7FKxRnxQA
z{Mj+L!uYc9w^lIYyC`4Q@83iFFSdU%o#AuOyvEMjJ?(+2=7#I<*js(fE_+3VP0Er`
zBYS1Z_3?^<Q?5_1F1O3ULc25Q3>h4{%g&I|=?spBoS|{1ONpP9yO-P5V39o*jPdpu
z+GD{~D3)n&Nt|>QHneu&+0c^sh0EeKc=D<&-aL;`)#hW9MLXYie<P`vgAcGtX4cg+
zJ=+~V&(5Z2|2EAg!*6SNif;AbD|3cw<|v#|N5sVKIztnEw-*RDmePHEU(#;71=jma
zAvlE|t5n!r>MihCqyoHOwB$MTmyNr1iQo;vu2=F=#~dF`F?*Ri{5G4EjLh~BW42xQ
zFyo_mhR=T+e4_dF_Smp!mxt96y<^uU;Rkz@_5_>!XB{(sf+C2_xB}%4dfL_DX}fb+
zv8zLODfCr}uhsanD+YWS@l}AY3Pk`s9fzw9>rtDJ+F}Kg7#2{=&{sgM4z>A;8#u4N
zVY2BG|ExZ(G(d7LNG=S?-REK8XuYT5(_I78zI#2^ZhPWrgTAV6D8DK-n34^5=`N>a
zV_j;n_Hasmi3#9XDcUE73{|5;qlc+|^supRbm*<aqldNjV)y3e!iLfg2l!*Z9&Ff%
zxoi!k-u0dt=}u3}^)s$%?>bMrWN&Uryd$=HZ}-duZbKhddeNtj2#)+qw_)VkX8ZN;
zmX><+6brt}(N16L5sM*q#F}SmkdIjPmImh$tIpD(9=0^B@K}7yJ$pVDbQW(RC^P}O
zAh!C<w)AXjz8Jr=^97t*W3xI^8Z3kMgx}r|S#jOj$GHA5Ce)McU^Z-;{)D`RZaKWN
zS&o#3<w)8gTu$5Nunfr;#m$~EaBsP1Me~?<nP++Pw6_rbTD^rzk>@yC3O$8rDexH4
zV&pBkn&ySR^e|oh2F&fH`S89D@8R>`gx=7+YETU^hcJcNAlaA~QuS^HH?~46Wl8VY
z9N!GdZd5~(koeBL=q_{X5>+Z66W`!r$_5YBl&d894^yj^J3P&w{s?%j^Na_?gjr+`
zUA)SpdP|gY=y*9GlaA{y--bFP_&yeprPBHdY0UM0T(Db}a?JK|Dk<p_AEgN9-=|ig
z=3i1~z$<eLiG3Ly6yAC^W%8t}rePh*+-A=0#WfNH-w&gNiT~B$J?M_${W+AEQT_@g
zeE#Xo`YCkB!lmxmK~~vvoz<sj`_iJD_`>X~lvu=~S4S)jg`PHVY=k-T;zsC}0n%rK
zt*{mClAd&{wbd&C4`T)onor|%t+&{1anmZz&N4CbRzw{sbEjwjeqo+o@L%<Ml%3$w
zPH_KDylK4LvB1k^@fv9IcFb%RFZ#BDGy6Fo94TghP}v9$Z_IGmaQQB@KFC`u(E2q+
zlZXxyxe!;SI;phL61v?p)=`OmwJEK}8X_M5;HD<$EqwINITbcn^~NG8Na^g%3e2zq
z_z@=x;#q$EBjmyyCh)635i0Ak7XE?P5C<77$!F!0mC0+6!#gNH&yh#1S3L-6gwwM<
zzy)%MGkd-=5lM~+_F5@D+X}8_Ih~bZc8nA2CO;mFFo%fW*Z;`+h0Dx-r;?s^FTlE;
zWa_S!%%J_md@NG#7J%`t`DJ|dl5B)3lFmm9G~_D=_yqC~<M_>$Gp(!rD72<&t%c8h
z>lU3-M_>s%iGyiJKGt?DtV#`u@SqBhMsEynu?TF9Ta`*1@D9$3kP+z=Ll1qkrdcZ&
zy%E=~tnJTg)l!KpTfqG(@LwIi&*Sv<D))h6*IX<@az1lIlXKnNS5Uiij@DcLT<S<x
zH^&xq(+hs39bdgf8fu1o_2AZ3&dsLy7SChd&Olp5o$r4|Ex}w}`R&YdWdk6a=I-#c
zchii+nHdE>S3IdfdXq!?m#NAO<k$H3ZSk@tkXQ0m5QhH#zj!I2{!^0h{o5okbH>8t
zjY#ItPZ>M~h!bGVCJWK)J>F|PNftu0$0V=cK-YeULTmIoo-21SV+Bf9mrPizn*MD9
z###Ma)QkH*NB<UA_pQ3O1-fTkfU_RFEO#?-klifh`o@2Qi#Fl^EJ&`H^L^K3+CCml
zJIA7k6T$`HWr61ew6K6{WUelf9zKlH0lUxb5A;!s6Ug3+?kru4l$-%2>Yyr<oz@dJ
zK~-K{tA4-<pL;grE8vsBVGGux>?={^Ksy_S6|qK~K4+kPLiNr`*}CIVOIQvdQuE1?
z(ZHDN!x@rC#e)8xJWuhR-feV~Wwe9aB5bdw$7(P=dr-}CeVy{w+T;kc3svdaN450}
zi&CzT2U-y)Iv8K6U*Wo{k8}SUG<uA%ruoWZy9Az=xhbAIi8zYrB0V^Ho@l!Tk1%;-
z@&)PH%^Z*XDWY49%djS4ZcQ3tO|8Jd01K0)UX{k9v2ZQNRtIc_1#CAfv@(k^zMY+p
zW-<OXm$E)yLQ)Ktcr3uUOj+7zaSazL1s>Ulco4Jd0jb;_3Z!SZrDb?U;_Jz`yFgQx
zuJAc_mSR{-Q2S+*i*c*~y7!@Ix*qbTXD3owZdWR$9!p4;EWu*T6m}R87lZ+2IoAwk
zFIEt-hT1Boq6N*x!FDzi6)MS2b}neFX6v&)aB(hnb`|^va~R_*cMAz2ZL$f8_`I3x
zKjs2|%i?CVT%V_wpUp4ll;+1xXtTHrn~KmDnFIa!GBz3U^+A$!3h@<asm9u+Smz-;
zvpnc^U_EDaw+hf^q9nsgJ{NhVyOp(^s<nKkJK~4|BkjhqXc^X6Icz0j74W*8YrC0i
zdtHFEUG=I``2=Y?eJ^UdhN&Dl1#PF;O^oMzED`WBoR1i3QTJ(m60TW1Np4ykNYTFR
z<*N{}m!_@S?t^Gt+-vB0beS9HaTt6r5c1wbP<(`efM|g!HK4^AK%ATqbk2aqD<dv5
zb`pMDxc#_a*$m3Z!JS?4yZBq$Azs>`)hTJa`c&!|>^m@Gj+Kbzc;70`f*s>lO`NiF
zNH)b8n32S5Y0NY2U4x!uQT5nG%UE<JcuF`RUgkIyd0G<2fi`ckqH$^&*Hx0IGeElq
z6W0q7y^eOYc{RJu$hV@9k0pMPjU!%a_Klq-i+V)cm0@Q^{`|=$do+p<v|XBM#wkrl
zi})U`M7R(wY<vd(!K6^Fv59tYD@46hYq30;%V&mt8~Z)&-6(DhfhU6V^=sjy!bQQp
zLNPVdcdK_rWlJJmou2(^IuCS=L81oGL>?%+F3bvGV2$b_E1^b2G_|-wX^(gE{D1v;
z-Gl6`b1iY>Wki^#n(YZuZ1rk2#Hr^|D<+EI4-IkWT7pxzw$yvP`IIYh@mawAHb#U8
zOLIm%jam`W#?lc-_y`$oqljX|HMt{(X~cC_gAr4Ua~$L&f@rfR)`)$GMpufZ-fmBC
zbDKASS_w5vXYM38+RQm{9_MiOgASst4Wo3R@KKNT&mO_MSuE{bq_#Cft#JvpU*`}W
z@;uZ`F&XJ}%kK1Sb@~m(aLp(Z@9xLUjesTq!)zUK5BpGHMA2};6x9>|@YI!hYXS2Q
z7k6U59T}eIj@!1t^@8})aSlF?;_nTd^LEb5+_6|Yn3MQ_>(~lDwgT<MQ48=b0lup}
z72xPf)Rv-#IGPI$7BUO%777YDwEPTTu{Ys-&5p$mp64>cf7pT5qr;wbEsGZ;Uid+?
zzP=n5TQ4y-*|xy%TXEgTq3`qT1JBu{=hHAW{m?wmpj>CJG2cA)PRuqx`*&$w;u}dV
zvqJSv!1vu`#oZ5Jm-0(IFIryzW9sPgiw&82muG*#t{1P@Z~t|J2z~fkQ)$BqpW#}O
z*m6DWqv)~Z#=FTf{V$VccO$}|-U%OY75h#h@i*!!MXN1_Op3%ZH%t6>?%m`{^j%4P
z<9O<Y#Q)&E|6GNY<KAFXT&*DQH43<9y;?yYFMrAoxPQlchE*%zngL-AdeYvAC06pt
z53#dqLBIc`X6sWtz7P^GtE*7|qMDvv#r=O?yaeCJIJ`$yvQg)`&Aj)zj4aaNjYA($
zZh&OLWzcg)N9&&<&$J)DjQsRTJYPjQgK`cfeEvDuo}~9J?<j1F6MJ8^1J4dsvWEH`
zc~dIits&y?uwfOL#d3F25)yUET^-JD=2#X_NzU#uS3%qvKs0l2-h~+Kdcl-4KzozN
zfol!NRi~a)oZYI|8Bm{Dgt7)usJ|`_nRE&Y_R5_xAHg+b;EI4dfru~v!h?XdjKjK;
zdS3A$dO>~xn93b0`d7!v@~?@z(JPh0Dh<^IUWyhYMoZ8BHIGNcsZc;j{4Nz#Xswd`
z|8J^W`6~MV3j0#XD79<JsLIrv9Wg-O$j8M~`xL^|3@=v}at6ktvNRK&JCUBvQ$rmx
z`mN&qev+zJ?nDpu#N}wVS9<nr29}1yk5XIU*@$YwIWKO_;Pbsyl|r;En<@iVucXuy
zq#<HP6JAJBr1M;guz-aQj7Kf*k#6&DmRNT)AMoh=t?nXxKYgPb5gg_B>T4l$6fepU
z%5%^KJ?Q}6&!GGb3Xf~fN4Wo~g$E+O%1@VJpD6p@lH}uU6{AmE-2XGW$#Z(&CSc$J
z1~XB@?8neZ;-ic6uQ){(f#OJ(aHNxnYG|dT5W|nTK<V+@9lyA|7ULZ$`8bU}mKkkN
zm7~_iVSF?vA6K7IPf(@=b_yPpBD_+_C3T{xiDX%w6x{}eqPf%wBd=M8nwT#JehO3A
z!62?B>Do94dO+`Mpz$Xt{~hH$6ym{$coHAN=Z|OnF4=k+8c$G|{TuI-UdhmWs$q%i
zVQOo1=%<jwM12!tSgL7q)Widh`oyo$F4Q>rih#y;)2QWBXF%7vxxWCe)iuO1A#oJ@
zR3UMAj@ef$ySiCo<R+~mv^!OwN*Xbv2J{Z$>M2jYq6TQp{Omn9Uj#)f-=`UfZ;#)k
zIKdj)4!ph@-tKtk<L`$LIoK!P3;Xas9`-p`JJ`psgtIx@_sf{^zm$Kr{N?A=W&0hu
zrR_0%kKa;v0^fvF%-0P%>*wCY>iX)Og!j5RO%vXPCfqq6^2wlVMSLPanot;zNk@^9
zd>qmxJ!)su(QkMxLA}xrKD8TXqA_n9V3f_pAVp9J>qeY2bI$!!^6TKm^9s#7+RgZ0
z;V*77`?oSR+V0^ys5z`qdkDFm7w|RA+eeTyNY5U_dg@iuvwuE!pC^FlWk|yho6w2k
zLqBUM;4nd|`>yPBxZ?X94_$FNw#WB4cEml{QBmwmx`ODF%XmF-{b};f92x&dWC(=B
zaYTTSF*xw-ja?KklZ^SAfQ*p`6|P!H#(X8s&o<mB16@@LMVU1z+SybnWZO5VO7OlK
zSxh1ELXxtb#FO7)7fC$%HlOL?WFB@|nngR3gfB*1xFNItZ`2|u0X;9O)AYRp&kZP>
zP-q=|1<&0m`%s2ZzKcTs0)sO91Jbo=NtVWutINYaM0>wzF@RHTy#9g(mJs{)-2Fv1
z9}I4iR>u*))|f~JRTdw~WD52Hwhvz_DAF>m*}WCzkY#BMuxBu*Zi>e4#Mp7Z3(3~6
zxk@!oUlCd?l9P5)p;TzhCBXC0z5%NddzN;o4m$Vy8Okuo0oAMZMpkU0w<;At3Y3qe
z`6wg#`x%-scZa2A;4}|uP$s0-iWnsMSjC*TBt&+g?KXH$$H!CP{p4a!E!VFmLGvT&
zB==NgUwV~PH)wPTphAVGZIiIuM<zSgG10BUn+jLeZhFu5iIF!3b}s?*iSBaun}ByN
zt+hL*Q{6F)S${RwJt4)*u$z>q=Ay*{ZU25+m5enhX|w|#y<3HEwMc5f(uk**-sSFg
z;E_L*eZOF#7B;DNTfr9^IpLFiv2JiPKzz0|;)y+<MT!Nqk=b|X0b1B(4697@KiX-M
z#y8-<pb169amapDdP^eCbf-hm1JVY{K4`nM?ATGSlTH-|)KQ8%(zCytr_}^2J<aTu
zkaJsw#yJ@f#<{fh(<<aX3XPC`qX8$VGhD5cM)*wkAlhno<td{9?RztizP@0_9E_J`
zFrFKAN~0Xo+0ViG<oOc|krd&u|2D$79rote7H7vOkCSv)p!eLz)B`5TeFk!uJ4P2|
zEoWqX0kR(LehcdZS^asf-2~doAhQW+s%#WbO~z;ERjCM)O8H{Yc}NS=fh-#F^wPVU
zkyQ5mf`wY>?6b_hiRXH<+@=`tPf6<e&!IYd<|OCvi`E%QnAZ3hRu-$8=D!vnWfvDu
zK~J93@`%_=hehOqp>vU$DD9W8MAeA3Kn)jcGF(z6I$h9TtJYmWMwqOo_WcO|hAw3+
zt1?Y1kgUncp9CK`dH$7*G)moScy}{JoiBYTvNEr}raY{xF%?;YhHGoY+A8uRLgH=2
zFJ>{nM)ouN50iVVA48V=hslSktKg@sA&dKsxreI9nG2`DSqup`xfk(~e-XFrw}#sr
z7%w=-qXdV>GsmUrHvpR`T;Z@zX}wJpP4q(lfsa|IN@n+WAD~`B&3Ke*v?w-^&f=$6
zv~f0!(E1U+G4jP;eB0E>nCr|%t@mi}n5!uM#q+Sq{agds<g2j#;q%|g;n}V)<(d5!
zp4AesA|t(|v&Ct-R}XG#^cqBiW9`3!-gcHt^GEYvMzb!5=6C+pG(Vd0kDO+HzM`F7
zuEi-Lw?we&%weOw57(_~aJm9Iy}J1as%W1v#-Pp9(HOjUx%(I^Y^2QPMaxVyB?)yY
zZ*|RdR7K7+hU^=``PGz)SRoH5FdDSYfJT0A(N~Pa=l;Wc@4c7J18I><lv}4vj)!Ia
zqYl2zxmJXKLo7Oo-P)iFc95bG)6^?-E2>3qUF5-6=9WR<bn#7yTI4~Tun*dKKa2a7
zx#deV**WNx3mnEvGOX#SuTHMsJ{4WnJhcx#K2!4uYRssK$$}FR8elI6>|ai+vVh1|
z9fZGiI(^#gZ(hxBmSKHKpT#AaN@Tur;);Cm(;Bilu!f+y#3`cT`V?hT$TBTj3AR8x
z?N4ZjD*M*+(R9+V)p5sVRjzeZ0smFVCFJ8-il=c(mG5!nU3N<SiK8xfyTB^g{ZjWh
zD}}sdUrHt{tDT4pa^}A{1q)9e4j3%vSWllmU7qDX;h<utEc<FT90nkRA$4>s=2Ay%
z9lA@^_%<u*Xg#lSqh=>+45;zqHikNSz#&|EgvK0Zj*2+tPlFAlA6ZOQM0|3<Dgeh(
z^)T6Z!gMK~|BdtM^Ki|@Q{&ZbIlQU>uXZ}h!6Px@T{5dPKxZ&BU&xs&pUasqpKTkT
z4fIWC>2n5FVkVM-DsOX$Q*wavX-nz*g4r_n3~IrD)f<9$y)^%(m+W)3W7kv+a<qm*
zIM2}D9>pFkCh2NwA<Oja?T9()i(<S+oI|MI`(UkT#8yY?W$kUJWBDa|(?+!M5dt6K
z;3GEh5y)atwBoJAmo?OZ-2gpZe75Y^!JM(n_*j!tE4>MfPtPa4DJcdl=#~W8n`{IO
zJ<sIawG$&}xGo~YmJ1i05jrco*U@%K#(Bkvgp5w&`!^oN>5lredb}R{sd_uTW!p~O
zP><7Dn(Q5osK*gsgsE52ByyT|TCa5eq{I4Pj%{(u5{^faU2L!?>c!Yov19h@)p!q!
z&m^jKt2`F(DrEdcWo72}fVS2t2Fr^t^R)LMp9?+u2q!Dq_rf?q*2ft<D`C3l2F>@^
zTw^o2_x-HC-nD`;+@o0BE3`+frg6efYLCRQvIS?JqkiG;k$*ii4x@Yv<=sqq15d>5
z;7Lhk+3xi0<LQmib^30oT!rsP(vXp?cdWP+lS`U$hl#~xGd-)Vq0^MXLC^GTV|uxg
z#r0Fwn1NubGyuYmG}$99stCV*1wQfyO2o;G3GOc`Z;!h_JpZ?K3cSo@0xkT_;x2D0
z2b2~y<Rwo~HG`}MdSFFMr;rs{!OtmH@N*+GGNg-gAbH!tS$m>deCB%n-U3gXR}V~d
zgbj-36<&qkP*BdG+zs2xz}N8kmw=OVZ9UFZN-_6WQlT!n2X}v_a4sg*BZon>3Xsds
z)gpc_g3~Cpi__X&qXK-5MV)Ku4g*X4R27@$o>K2_?lEnc<2Po?n-JaBB^ayWH|Fx;
z6)L7zXSk3TU&-k!;q;X>W#GA|qsy@4S0jbEFGZSGjVyh7_OY}P(Vso>8mCteda+h;
z;*#-ylSCWQN;DI_*|;;`Gb$BJ<=z(~FO8fIj~&cCUnyJgH#n6JtC8ub9y90mV3Y52
zSUAn*ST3HM@Osdx!^tN*Rd27)aP4)K`h?%Uyn*5+x-&sL9EvejSOMJD6V+jQn<<D5
zt49P!HKK_2kj*JN)-UMt#=DrY0i^|{9VG_cxFfD&l~m!^;8;0Dmg4!eSus?VHqjdT
zQK}GeZ+nC+*>}=;N_zG`r%4w~qzg*y2<6(cI{b2qG=%CjS=0FADK@FCJ<gK_J4#w<
zh-W3HgAZbe)0q8sh4xIv(4T8_S}xCsU6hKwiW3$~vn_Pn1lh6aJjDpjqFqgT_MLfx
zpde3{wQ9u2MZMADef1!n2h#~E?S|JNLecK75H##P*9y?x0?hq7pIdNT!!3;L3@^<8
zDcIUN)5kvxUzTEC9Wds1kEFJW2`|MPpF%ns7J6k)B9C&AM_pP@f^a{1p6=g-ytU9r
z!@MnncTt>8-UbZAbD~>t%uQLi_E6?vBeIsGlBsevT7Qw$cvpI*)U#hI**!ly0O+r}
z3Xm&Uj&@&WG>uyZE|82hY-pDwIEl{`M`fc$x@$oCPiuYg{Py2)SCrp}#hS>RV3uU=
znVOc|Gqu&wP1DIwT3%q2lb`hCcgf1(cTUL;Kzd<1Rca3z9VKz2WAzo%seDJt6rCxN
z#xA>AqQutf_$e<-G|m+&LY0y0_1EU|7HsdXIhrB6-gkq>|BZ7by4SjlL&rV8cmed>
z%yYbL5xTu%;&)oxA_lytXV=f?YbU>eL-}ul5djQ>^B#wlvDev^de92Ue61c-M|6(0
zaTH*$iwihYE93Vpbn*1;iS#P0xQR5Vz|D*0@OwmUKF&Gl#w}6!>J1TVE^D2s*W%iH
z4_P^lD#AzecUhZ3dX2m%R)T&eyME81zovg$|Cc$BpG~$@Q}%PwNBl6kr}_;P^1!jK
z2gv{O8<MNznc7Z3jk`FX^TG2s=Jvoo8>Y#&lTEmR%sD}g!TRrr*J_v))9zLjpG`hc
z{R)Z>Hx_h`$_1WOD2uRf184q2+N#j4*;kS+wwI!{Yl#;_kTx=+OX|J}>z<{rF`4BP
zhlNOkZnLcM%mDwRVp(%Z<P^@6V3Q&ZXd8<bd#1Zq^7TcS=5y*0n}|ez9><4#NR}I#
z*F^LJuc<@y!X_Wmc6;z2&p`*WI>GgU-{%nB*}HzJ5qp!iLm0=dPG4h<Od$R$xSSeU
zdrN&R9E%7w?Pm2UC+tdUWK~YP6*(Bn6feVmtDQ|?4O<as$k<h6@{$4Ui+$=bEjMYv
z4S|V>RiOC@+r?c6oBR;ImU*)=(juM{xTmDWsNYK$;`RnbG>dwnKBXdtbG3p;0^RL!
zCGF;{Mq!0fjBxH4bV`Gl8d;ZvyBRe9?2`g<Jc@Xn@@%lr+mzIZHK&h=oJ47)AH8tD
z7@5{~v(uLvDaq+!tg%YSHS&E@3_02u_>cl0Qh}0)B^<+;7|uKNHL7nSfKxKpA7&`?
zw+?dB?xzslT5jl;yHuGwU5IB#42XL5_8%#9C-cWg#S3(s>c{-%#2IBTbjRY3MUbtG
zls3Np$MZ*pt2+D3SiNmJ?LLO<x1!LT;mz(02i;An5oitgW)tsAR#nRp5&IJGATHXU
zBp>w@#o!`h@OGp6R3V~o^7dN$0erO=j7M*;QJ<>ult=CcOsi1ZSWdT}BjPpID*my)
z6<okA-7PtsDueFamGiBynE;2XaMLFS%*UcO*tN<GEPV~_I;?<Rk*P7(l=FKrOX081
zfoH5K^WvU4_7McF2+-7Hr*%b{@kJP)8ZqVcFRGb<p3)gYHjlOkHj8wI^pNC2_Dgrx
z?XmXA-bPxLUAUc(T|gMt#uDeZ^MftdiyCC_y`K6i+|%)dtERi^JpI?h9c^9COe`f}
zX8^wdZ^#_JsqG7UhwAuNylWXYHCWxOhKP$r(5F<0^zw9c)9&mF6&p28^l?p0h3;HJ
z2gM5o@l?omOYL_bSfk<FO6@Z4`-fZYxc4G^iwVcQZCxugY(S40mY)2tjJvbp)&|~-
zMzBs9_q6-3Gf;&1SSsyWjLC^tWLt=D_itgwMZS^m@qp_38&=#srCS+-c#7_YNo9Dq
z;fBU4+{RvsTQdx|v3cy=g*=0oJd2FDg>ocjWHx3mbF8{}^zNs-P19WzySH^2@P8G;
z9hNSd<s-zYSzpTkzW@{J3AcN3C!=^z$%7^68`S+Q8L^RfU-a>L%3bb<E9~z56?D2`
z^1SN$^kTstSZupJDBNwt_uR#sv;TN={sY(&(D*9$LUf0T{vQdIpOc@(U8MOB=yx%m
zHZ{KJV%O3&Y%2JG`FwFw@Q6vF<we)rl=*F4qv$^6q88Ly=RVjM==Jvx4{fqFK6syP
zXu#Juc)&kk3-sB71N~17_y-5?W$clG{=O${P1_r6gF(N)s}i`drq;c-L%zTe;!QT_
zA7bc=U&g);wH(r5GTu%dI|4&>=-9NqbMx2e`>Qr~Xdp1;e>||gbFj`vV{*SUI4!9I
zXtvky>jD^DAR8I-4>H!$(h?l3v_0atNxmojHeX-=kObtZm8N5T{t%%A+%OL4*V(d=
z8QbF<99pE;-`6#0I}{j_Z2p0P{sB-()OHLX05j^?{d@Pe?5(ps-0I3y+4`UK4;<*}
zKV<74uni6k1i+p{zCqhif4{8<yuzHVoxVOBfyKLR17jO)n{5aBhx@v0UH&HnoqiMQ
z@29zJgdG8(8HWey4WeKz9ut#>hJu52Tem&|#D+VzboTdd^>=lR_<Oew4)xY-AN2JG
zd;Ei2hX(xqt-YYfKd{wZQ|GR!uGtD;j}H<G9m9d1F8j8c9kzPg_Ui5TY_6`|yls~$
zP`zbK4N!v6hJ$=+PCb{eZCmx9ZNd-z-pzlvJxGLZf6%tU9}4;hAl|+qUr*&mlZ!xL
zWTyn$A?7DGgX93FJ<vbU>l>nnZQG8`kUz+LB0wk(nwoqzUsu<FHanl2KA~!+rYBI@
zHQXDtb@ulSVG>*a0qOujn3@i0V&}uaMy><44U#{!waeeRwZC&{Ye%4OBjJG&rY2(S
z6Sh8d=i&z^NNH>b2KsyXoM<&QZKqD#cI0+D)IR`S;N5P)+|<;^J9ZC4b#j54ng$6g
zVmAq~V|dWCd9w}L2sQNe^w<Utfu7!8A1N7eWPQ_mR1Eik2tU-vH!$Sy(q>%WxPFtZ
z*YE4gsDZ5??Dh=>`ui}$X44*;W`W&3fuW%uf0pALy8H)x!#zVA|0M7C0YVV^I%Mk{
z9vC1F@9P~TU36iIWJP4_8}9A!5AeDkf8P^B(&y+Z2JIUdA$D_CENHH6%N85pwFXEz
zd0QPmv351_Q(GOzLgWhzwG~Q3^_qw<7i2$RgZlLNX_fZ(`7;<{oVI4jT4dG?>KZbn
zaP7s)*X)&MtI*5_eGp5XZ9QJudQ@obS*7D^oj$%w?X4sZE=yC6-OGq?lSZrL?+I2e
zz*%S;0z1~<yPk`fy3o{YAD~v_&t{{qf7@S)U=}{o3H8tD>mOk{K_?1~nexp7-s|zo
z3Um#4W#R1wxM?Hkbb>x_9Wx7g>jWm~*XeY5>++dk$U82Yn7KfYVJ018hP<bA_4E+v
z!SrH*zDTTQTaYN+!nUz8(a*Z@Zv^4UAoH<))DEy=W)>gDe{FHG&8&%SM>=x3IE?lV
z7Qk00;MBuMJ%l2mG@^u1^1_V8asTb-DAgf!%KrV7us5>bV4ux^dhXwEiauLMdy0B=
F`u}IO&w&5{

diff --git a/F3:F303/I2C_scan/i2cscan.creator.user b/F3:F303/I2C_scan/i2cscan.creator.user
index 138fc14..63477ae 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-18T23:52:40. -->
+<!-- Written by QtCreator 17.0.1, 2025-09-19T20:47:53. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
diff --git a/F3:F303/I2C_scan/main.c b/F3:F303/I2C_scan/main.c
index c646cd0..becd916 100644
--- a/F3:F303/I2C_scan/main.c
+++ b/F3:F303/I2C_scan/main.c
@@ -53,7 +53,7 @@ int main(void){
         if(l < 0) USND("ERROR: USB buffer overflow or string was too long");
         else if(l){
             const char *ans = parse_cmd(inbuff);
-            if(ans) USND(ans);
+            if(ans) U(ans);
         }
         if(i2c_scanmode){
             uint8_t addr;
@@ -65,7 +65,7 @@ int main(void){
                 U(") - found device\n");
             }
         }
-        if(i2cdma_haderr()) USND("Error reading I2C using DMA");
-        if(i2cdma_getbuf(NULL)) i2c_bufdudump();
+        if(i2c_dma_haderr()) USND("Error reading I2C using DMA");
+        if(i2c_dma_getbuf(NULL)) i2c_bufdudump();
     }
 }
diff --git a/F3:F303/I2C_scan/proto.c b/F3:F303/I2C_scan/proto.c
index e3dc07c..1746609 100644
--- a/F3:F303/I2C_scan/proto.c
+++ b/F3:F303/I2C_scan/proto.c
@@ -26,6 +26,7 @@
 #define LOCBUFFSZ       (32)
 // local buffer for I2C data to send
 static uint8_t locBuffer[LOCBUFFSZ];
+static uint8_t I2Caddress = 0x33 << 1;
 extern volatile uint32_t Tms;
 
 static const char *OK = "OK\n";
@@ -33,6 +34,7 @@ static const char *helpstring =
         "https://github.com/eddyem/stm32samples/tree/master/F3:F303/I2C_scan build#" BUILD_NUMBER " @ " BUILD_DATE "\n"
         "i0..3 - setup I2C with speed 10k, 100k, 400k, 1M or 2M (experimental!)\n"
         "B - switch to big-endian format for 16-bit registers\n"
+        "G - get busy state\n"
         "Ia addr - set I2C address\n"
         "Ig - dump content of I2Cbuf\n"
         "Iw bytes - send bytes (hex/dec/oct/bin) to I2C\n"
@@ -59,7 +61,6 @@ TRUE_INLINE const char *setupI2C(char *buf){
     return OK;
 }
 
-static uint8_t I2Caddress = 0;
 TRUE_INLINE const char *saI2C(const char *buf){
     uint32_t addr;
     U("saI2C: '"); U(buf); U("'\n");
@@ -98,24 +99,24 @@ static void rdI2C(const char *buf, int is16, int dmaflag){
     if(noreg){ // don't write register
         if(dmaflag){
             U("Try to read using DMA .. ");
-            if(!read_i2c_dma(I2Caddress, N)) U(erd);
+            if(!i2c_read_dma(I2Caddress, N)) U(erd);
             else U(OK);
             return;
         }else{
             USND("Simple read:");
-            if(!(b8 = read_i2c(I2Caddress, N))){
+            if(!(b8 = i2c_read(I2Caddress, N))){
                 U(erd);
                 return;
             }
         }
     }else{
         if(is16){
-            if(!(b16 = read_i2c_reg16(I2Caddress, reg, N, dmaflag))){
+            if(!(b16 = i2c_read_reg16(I2Caddress, reg, N, dmaflag))){
                 U(erd);
                 return;
             }
         }else{
-            if(!(b8 = read_i2c_reg(I2Caddress, reg, N, dmaflag))){
+            if(!(b8 = i2c_read_reg(I2Caddress, reg, N, dmaflag))){
                 U(erd);
                 return;
             }
@@ -142,8 +143,8 @@ 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);
+    int result = isdma ? i2c_write_dma(I2Caddress, locBuffer, N) :
+                         i2c_write(I2Caddress, locBuffer, N);
     if(!result) return "Error writing I2C\n";
     return OK;
 }
@@ -185,12 +186,15 @@ const char *parse_cmd(char *buf){
     switch(*buf){
         case 'i': return setupI2C(NULL); // current settings
         case 'B':
-            endianness(1);
-            return OK;
+            i2c_endianness(1);
+        return OK;
+        break;
+        case 'G':
+            U("I2Cbusy="); USB_putbyte('0' + i2c_busy()); newline();
         break;
         case 'L':
-            endianness(0);
-            return OK;
+            i2c_endianness(0);
+        return OK;
         break;
         case 'T':
             U("T=");
diff --git a/F3:F303/I2C_scan/ringbuffer.c b/F3:F303/I2C_scan/ringbuffer.c
index b0ffe8e..0f4ffc2 100644
--- a/F3:F303/I2C_scan/ringbuffer.c
+++ b/F3:F303/I2C_scan/ringbuffer.c
@@ -15,6 +15,8 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <string.h>
+
 #include "ringbuffer.h"
 
 static int datalen(ringbuffer *b){
@@ -58,10 +60,11 @@ int RB_hasbyte(ringbuffer *b, uint8_t byte){
     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){
@@ -76,9 +79,9 @@ static int read(ringbuffer *b, uint8_t *s, int len){
     int _1st = b->length - b->head;
     if(_1st > l) _1st = l;
     if(_1st > len) _1st = len;
-    mcpy(s, b->data + b->head, _1st);
+    memcpy(s, b->data + b->head, _1st);
     if(_1st < len && l > _1st){
-        mcpy(s+_1st, b->data, l - _1st);
+        memcpy(s+_1st, b->data, l - _1st);
         incr(b, &b->head, l);
         return l;
     }
@@ -132,9 +135,9 @@ static int write(ringbuffer *b, const uint8_t *str, int l){
     if(l > r || !l) return 0;
     int _1st = b->length - b->tail;
     if(_1st > l) _1st = l;
-    mcpy(b->data + b->tail, str, _1st);
+    memcpy(b->data + b->tail, str, _1st);
     if(_1st < l){ // add another piece from start
-        mcpy(b->data, str+_1st, l-_1st);
+        memcpy(b->data, str+_1st, l-_1st);
     }
     incr(b, &b->tail, l);
     return l;
diff --git a/F3:F303/I2C_scan/version.inc b/F3:F303/I2C_scan/version.inc
index f4704de..390f7b2 100644
--- a/F3:F303/I2C_scan/version.inc
+++ b/F3:F303/I2C_scan/version.inc
@@ -1,2 +1,2 @@
-#define BUILD_NUMBER "136"
-#define BUILD_DATE "2025-09-18"
+#define BUILD_NUMBER "152"
+#define BUILD_DATE "2025-09-19"