diff --git a/F3:F303/I2C_scan/i2c.c b/F3:F303/I2C_scan/i2c.c
index 416e6e9..0901a86 100644
--- a/F3:F303/I2C_scan/i2c.c
+++ b/F3:F303/I2C_scan/i2c.c
@@ -23,14 +23,15 @@
 #include "strfunc.h" // hexdump
 #include "usb.h"
 
-I2C_SPEED curI2Cspeed = LOW_SPEED;
+i2c_speed_t i2c_curspeed = I2C_SPEED_AMOUNT;
 extern volatile uint32_t Tms;
 static uint32_t cntr;
-static uint8_t i2c_got_DMA_Rx = 0;
-volatile uint8_t I2C_scan_mode = 0; // == 1 when I2C is in scan mode
+volatile uint8_t i2c_scanmode = 0; // == 1 when I2C is in scan mode
+volatile uint8_t i2c_got_DMA = 0; // got DMA data
 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[256], i2cbuflen = 0; // buffer for DMA tx/rx and its len
+static uint8_t I2Cbuf[I2C_BUFSIZE], i2cbuflen = 0; // buffer for DMA tx/rx and its len
+static uint8_t bigendian = 0; // ==1 for big-endian 16-bit data
 
 // macros for I2C rx/tx
 #define DMARXCCR    (DMA_CCR_MINC | DMA_CCR_TCIE | DMA_CCR_TEIE)
@@ -48,14 +49,44 @@ static inline int isI2Cbusy(){
 }
 
 // GPIO Resources: I2C1_SCL - PB6 (AF4), I2C1_SDA - PB7 (AF4)
-void i2c_setup(I2C_SPEED speed){
-    if(speed >= CURRENT_SPEED){
-        speed = curI2Cspeed;
-    }else{
-        curI2Cspeed = speed;
+void i2c_setup(i2c_speed_t speed){
+    uint8_t PRESC, SCLDEL = 0x04, SDADEL = 0x03, SCLH, SCLL; // I2C1->TIMINGR fields
+    switch(speed){
+        case I2C_SPEED_10K:
+            PRESC = 0x0F;
+            SCLH = 0xDA;
+            SCLL = 0xE0;
+        break;
+        case I2C_SPEED_100K:
+            PRESC = 0x0F;
+            SCLH = 0x13;
+            SCLL = 0x16;
+        break;
+        case I2C_SPEED_400K:
+            PRESC = 0x07;
+            SCLH = 0x08;
+            SCLL = 0x09;
+        break;
+        case I2C_SPEED_1M:
+            SDADEL = 1;
+            SCLDEL = 2;
+            PRESC = 0x3;
+            SCLH = 0x4;
+            SCLL = 0x6;
+        break;
+        case I2C_SPEED_2M:
+            SDADEL = 0;
+            SCLDEL = 1;
+            PRESC = 0x0;
+            SCLH = 0x1;
+            SCLL = 0x2;
+        break;
+        default:
+            USND("Wrong I2C speed!\n");
+            return; // wrong speed
     }
     RCC->AHBENR |= RCC_AHBENR_GPIOBEN;
-    I2C1->CR1 = 0;
+    I2C1->CR1 = 0; // disable I2C for setup
     I2C1->ICR = 0x3f38; // clear all errors
     GPIOB->AFR[0] = (GPIOB->AFR[0] & ~(GPIO_AFRL_AFRL6 | GPIO_AFRL_AFRL7)) |
                 AFRf(4, 6) | AFRf(4, 7);
@@ -66,25 +97,19 @@ void i2c_setup(I2C_SPEED speed){
     GPIOB->OTYPER |= GPIO_OTYPER_OT_6 | GPIO_OTYPER_OT_7; // both open-drain outputs
     // I2C (default timing from sys clock - 72MHz)
     RCC->APB1ENR |= RCC_APB1ENR_I2C1EN; // clocking
-    if(speed == HIGH_SPEED){
-        // activate "fast mode plus"
-        SYSCFG->CFGR1 |= SYSCFG_CFGR1_I2C1_FMP | SYSCFG_CFGR1_I2C_PB6_FMP | SYSCFG_CFGR1_I2C_PB7_FMP;
-    }else{
+    if(speed < I2C_SPEED_400K){ // slow cpeed - common mode
         SYSCFG->CFGR1 &= ~(SYSCFG_CFGR1_I2C1_FMP | SYSCFG_CFGR1_I2C_PB6_FMP | SYSCFG_CFGR1_I2C_PB7_FMP);
+    }else{ // activate "fast mode plus"
+        SYSCFG->CFGR1 |= SYSCFG_CFGR1_I2C1_FMP | SYSCFG_CFGR1_I2C_PB6_FMP | SYSCFG_CFGR1_I2C_PB7_FMP;
     }
-    if(speed == LOW_SPEED){ // 100kHz
-        I2C1->TIMINGR = (0xf<<28) | (0x04<<20) | (0x03<<16) | (0x12<<8) | (0x15);
-        //                 PRESC      SCLDEL        SDADEL        SCLH      SCLL
-    }else if(speed == HIGH_SPEED){ // 400kHz
-        I2C1->TIMINGR = (0x06<<28) | (0x04<<20) | (0x03<<16) | (0x06<<8) | (0x08);
-    }else{ // VERYLOW_SPEED - 10kHz
-        I2C1->TIMINGR = (0xf<<28) | (0x04<<20) | (0x03<<16) | (0xc3<<8) | (0xc7);
-    }
+    I2C1->TIMINGR = (PRESC<<I2C_TIMINGR_PRESC_Pos) | (SCLDEL<<I2C_TIMINGR_SCLDEL_Pos) |
+                    (SDADEL<<I2C_TIMINGR_SDADEL_Pos) | (SCLH<<I2C_TIMINGR_SCLH_Pos) | (SCLL<< I2C_TIMINGR_SCLL_Pos);
     I2C1->CR1 = I2CCR1;
     RCC->AHBENR |= RCC_AHBENR_DMA1EN;
     NVIC_EnableIRQ(DMA1_Channel6_IRQn);
     NVIC_EnableIRQ(DMA1_Channel7_IRQn);
     I2Cbusy = 0;
+    i2c_curspeed = speed;
 }
 
 // setup DMA for rx (tx==0) or tx (tx==1)
@@ -103,30 +128,24 @@ static void i2cDMAsetup(int tx, uint8_t len){
     }
 }
 
-static uint8_t i2c_chk(uint8_t busychk){
-    I2C1->CR2 = 0;
-    if(busychk){
-        cntr = Tms;
-        while(I2C1->ISR & I2C_ISR_BUSY){
-            IWDG->KR = IWDG_REFRESH;
-            if(Tms - cntr > I2C_TIMEOUT){
-                USND("i2c_chk: Line busy\n");
-                return 0;  // check busy
-        }}
-    }/*
+// return 1 if line busy (also show error message and clear busy flag)
+static uint8_t i2c_chkbusy(){
     cntr = Tms;
-    while(I2C1->CR2 & I2C_CR2_START){
+    while(I2C1->ISR & I2C_ISR_BUSY){
         IWDG->KR = IWDG_REFRESH;
         if(Tms - cntr > I2C_TIMEOUT){
-            USND("i2c_chk: No start\n");
-            return 0; // check start
-    }}*/
-    return 1;
+            USND("i2c_chkbusy: Line busy;");
+            USND("I2c->ISR = "); USND(uhex2str(I2C1->ISR)); newline();
+            I2C1->ICR = I2C_ICR_BERRCF;
+            return 1;  // line busy
+        }
+    }
+    return 0;
 }
 
 // start writing
 static uint8_t i2c_startw(uint8_t addr, uint8_t nbytes, uint8_t stop){
-    if(!i2c_chk(1)) return 0;
+    if(i2c_chkbusy()) return 0;
     I2C1->CR2 = nbytes << 16 | addr;
     if(stop){
         I2C1->CR2 |= I2C_CR2_AUTOEND; // autoend
@@ -168,10 +187,7 @@ static uint8_t write_i2cs(uint8_t addr, uint8_t *data, uint8_t nbytes, uint8_t s
     }
     cntr = Tms;
     if(stop){
-        while(I2C1->ISR & I2C_ISR_BUSY){
-            IWDG->KR = IWDG_REFRESH;
-            if(Tms - cntr > I2C_TIMEOUT){USND("write_i2cs: Busy timeout\n"); break;}
-        }
+        if(i2c_chkbusy()) return 0;
     }else{ // repeated start
         while(!(I2C1->ISR & I2C_ISR_TC)){
             IWDG->KR = IWDG_REFRESH;
@@ -202,8 +218,7 @@ uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint8_t nbytes){
 }
 
 // start reading
-static uint8_t i2c_startr(uint8_t addr, uint8_t nbytes, uint8_t busychk){
-    if(!i2c_chk(busychk)) return 0;
+static uint8_t i2c_startr(uint8_t addr, uint8_t nbytes){
     // read N bytes
     I2C1->CR2 = (nbytes<<16) | addr /*| I2C_CR2_AUTOEND*/ | I2C_CR2_RD_WRN;
     I2C1->CR2 |= I2C_CR2_START;
@@ -217,8 +232,9 @@ static uint8_t i2c_startr(uint8_t addr, uint8_t nbytes, uint8_t busychk){
  * `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, uint8_t *data, uint8_t nbytes, uint8_t busychk){
-    if(!i2c_startr(addr, nbytes, busychk)) return 0;
+static uint8_t *read_i2cb(uint8_t addr, uint8_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;
@@ -226,31 +242,22 @@ static uint8_t read_i2cb(uint8_t addr, uint8_t *data, uint8_t nbytes, uint8_t bu
             IWDG->KR = IWDG_REFRESH;
             if(I2C1->ISR & I2C_ISR_NACKF){
                 I2C1->ICR |= I2C_ICR_NACKCF;
-                USND("read_i2_nostart: NAK\n");
-                return 0;
+                USND("read_i2cb: NAK\n");
+                return NULL;
             }
             if(Tms - cntr > I2C_TIMEOUT){
-                USND("read_i2_nostart: Timeout\n");
-                return 0;
+                USND("read_i2cb: Timeout\n");
+                return NULL;
             }
         }
-        *data++ = I2C1->RXDR;
-    }/*
-    cntr = Tms;
-    while(!(I2C1->ISR & I2C_ISR_TC)){
-        IWDG->KR = IWDG_REFRESH;
-        if(Tms - cntr > I2C_TIMEOUT){
-            USND("read_i2cs: TC timeout\n");
-            return 0;
-        }
+        I2Cbuf[i] = I2C1->RXDR;
     }
-    I2C1->CR2 = I2C_CR2_STOP;*/
-    return 1;
+    return I2Cbuf;
 }
 
-uint8_t read_i2c(uint8_t addr, uint8_t *data, uint8_t nbytes){
+uint8_t *read_i2c(uint8_t addr, uint8_t nbytes){
     if(isI2Cbusy()) return 0;
-    return read_i2cb(addr, data, nbytes, 1);
+    return read_i2cb(addr, nbytes, 1);
 }
 
 uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes){
@@ -258,31 +265,41 @@ uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes){
     if(isI2Cbusy()) return 0;
     i2cDMAsetup(0, nbytes);
     goterr = 0;
-    if(!i2c_startr(addr, nbytes, 1)) return 0;
+    if(i2c_chkbusy() || !i2c_startr(addr, nbytes)) return 0;
+    i2c_got_DMA = 0;
     I2Cbusy = 1;
     DMA1_Channel7->CCR = DMARXCCR | DMA_CCR_EN; // start transfer
     return 1;
 }
 
+static void swapbytes(uint16_t *data, int datalen){
+    if(!datalen) return;
+    for(int i = 0; i < datalen; ++i)
+        data[i] = __REV16(data[i]);
+}
 
 // read register reg
-uint8_t read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t *data, uint8_t nbytes){
-    if(isI2Cbusy()) return 0;
-    if(!write_i2cs(addr, &reg, 1, 0)) return 0;
-    return read_i2cb(addr, data, nbytes, 0);
+uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t nbytes){
+    if(isI2Cbusy()) return NULL;
+    if(!write_i2cs(addr, &reg, 1, 0)) return NULL;
+    return read_i2cb(addr, nbytes, 0);
 }
 
 // read 16bit register reg
-uint8_t read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t *data, uint8_t nbytes){
-    if(isI2Cbusy()) return 0;
-    reg16 = __REV16(reg16);
-    if(!write_i2cs(addr, (uint8_t*)&reg16, 2, 0)) return 0;
-    return read_i2cb(addr, data, nbytes, 0);
+uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t nwords){
+    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(!read_i2cb(addr, nwords*2, 0)) return NULL;
+    uint16_t *buf = (uint16_t*)I2Cbuf;
+    //hexdump(USB_sendstr, I2Cbuf, nwords*2);
+    if(bigendian) swapbytes(buf, nwords);
+    return buf;
 }
 
 void i2c_init_scan_mode(){
     i2caddr = 1; // start from 1 as 0 is a broadcast address
-    I2C_scan_mode = 1;
+    i2c_scanmode = 1;
 }
 
 // return 1 if next addr is active & return in as `addr`
@@ -293,14 +310,10 @@ int i2c_scan_next_addr(uint8_t *addr){
     *addr = i2caddr;
     if(i2caddr == I2C_ADDREND){
         *addr = I2C_ADDREND;
-        I2C_scan_mode = 0;
+        i2c_scanmode = 0;
         return 0;
     }
-    /*while(!u3txrdy);
-    USND("Addr: "); USND(uhex2str(i2caddr)); USND("\n");
-    usart3_sendbuf();*/
-    uint8_t byte;
-    if(!read_i2c((i2caddr++)<<1, &byte, 1)) return 0;
+    if(!read_i2c((i2caddr++)<<1, 1)) return 0;
     return 1;
 }
 
@@ -314,10 +327,17 @@ void i2c_bufdudump(){
     hexdump(USB_sendstr, I2Cbuf, i2cbuflen);
 }
 
-void i2c_have_DMA_Rx(){
-    if(!i2c_got_DMA_Rx) return;
-    i2c_got_DMA_Rx = 0;
-    i2c_bufdudump();
+// get DMA buffer with conversion to little-endian; return 0 if no data, -1 on err, or words amount
+// TODO: fix this function, it should be called only for DMA reading!
+int i2c_getwords(uint16_t *buf, int bufsz){
+    if(!buf || bufsz < 1) return -1;
+    if(i2cbuflen < 2) return 0;
+    if(bufsz > i2cbuflen / 2) bufsz = i2cbuflen / 2;
+    if(bigendian){
+        uint16_t *b = (uint16_t*)I2Cbuf;
+        for(int i = 0; i < bufsz; ++i) buf[i] = __REV(b[i]);
+    }else memcpy(buf, I2Cbuf, bufsz * 2);
+    return bufsz;
 }
 
 int i2cdma_haderr(){
@@ -326,12 +346,16 @@ int i2cdma_haderr(){
     return r;
 }
 
+void endianness(uint8_t isbig){
+    bigendian = isbig;
+}
+
 // Rx (7) /Tx (6) interrupts
 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;
-    if(rx) i2c_got_DMA_Rx = 1; // last transfer was Rx
+    if(rx) i2c_got_DMA = 1; // last transfer was Rx
     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 fdb9358..50aa9e1 100644
--- a/F3:F303/I2C_scan/i2c.h
+++ b/F3:F303/I2C_scan/i2c.h
@@ -19,32 +19,36 @@
 #pragma once
 #include <stdint.h>
 
-#define I2C_ADDREND  (0x80)
+#define I2C_ADDREND     (0x80)
+#define I2C_BUFSIZE     (256)
 
 typedef enum{
-    VERYLOW_SPEED,
-    LOW_SPEED,
-    HIGH_SPEED,
-    CURRENT_SPEED
-} I2C_SPEED;
+    I2C_SPEED_10K,
+    I2C_SPEED_100K,
+    I2C_SPEED_400K,
+    I2C_SPEED_1M,
+    I2C_SPEED_2M, // EXPERIMENTAL! Could be unstable!!!  (speed near 1.9Mbaud)
+    I2C_SPEED_AMOUNT
+} i2c_speed_t;
 
-extern I2C_SPEED curI2Cspeed;
-extern volatile uint8_t I2C_scan_mode;
+extern i2c_speed_t i2c_curspeed;
+extern volatile uint8_t i2c_scanmode, i2c_got_DMA;
 
 // timeout of I2C bus in ms
 #define I2C_TIMEOUT             (100)
 
-void i2c_setup(I2C_SPEED speed);
-uint8_t read_i2c(uint8_t addr, uint8_t *data, uint8_t nbytes);
-uint8_t read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t *data, uint8_t nbytes);
-uint8_t read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t *data, uint8_t nbytes);
+void i2c_setup(i2c_speed_t speed);
+uint8_t *read_i2c(uint8_t addr, uint8_t nbytes);
+uint8_t *read_i2c_reg(uint8_t addr, uint8_t reg, uint8_t nbytes);
+uint16_t *read_i2c_reg16(uint8_t addr, uint16_t reg16, uint8_t nbytes);
 uint8_t write_i2c(uint8_t addr, uint8_t *data, uint8_t nbytes);
 uint8_t write_i2c_dma(uint8_t addr, uint8_t *data, uint8_t nbytes);
 uint8_t read_i2c_dma(uint8_t addr, uint8_t nbytes);
 
 void i2c_bufdudump();
-void i2c_have_DMA_Rx();
 int i2cdma_haderr();
+void endianness(uint8_t isbig);
+int i2c_getwords(uint16_t *buf, int bufsz);
 
 void i2c_init_scan_mode();
 int i2c_scan_next_addr(uint8_t *addr);
diff --git a/F3:F303/I2C_scan/main.c b/F3:F303/I2C_scan/main.c
index 0b93dad..88a74bd 100644
--- a/F3:F303/I2C_scan/main.c
+++ b/F3:F303/I2C_scan/main.c
@@ -39,22 +39,22 @@ int main(void){
         SysTick_Config((uint32_t)48000); // 1ms
     }
     hw_setup();
+    i2c_setup(I2C_SPEED_10K); // start from lowest speed
     USB_setup();
     uint32_t ctr = Tms;
     while(1){
         if(Tms - ctr > 499){
             ctr = Tms;
             pin_toggle(GPIOB, 1 << 1 | 1 << 0); // toggle LED @ PB0
-            //USND("HALO\n");
         }
         USB_proc();
         int l = USB_receivestr(inbuff, MAXSTRLEN);
-        if(l < 0) USB_sendstr("ERROR: USB buffer overflow or string was too long\n");
+        if(l < 0) USND("ERROR: USB buffer overflow or string was too long\n");
         else if(l){
             const char *ans = parse_cmd(inbuff);
-            if(ans) USB_sendstr(ans);
+            if(ans) USND(ans);
         }
-        if(I2C_scan_mode){
+        if(i2c_scanmode){
             uint8_t addr;
             int ok = i2c_scan_next_addr(&addr);
             if(addr == I2C_ADDREND) USND("Scan ends\n");
@@ -64,6 +64,9 @@ int main(void){
                 USND(") - found device\n");
             }
         }
-        i2c_have_DMA_Rx(); // check if there's DMA Rx complete
+        if(i2c_got_DMA){
+            i2c_bufdudump();
+            i2c_got_DMA = 0;
+        }
     }
 }
diff --git a/F3:F303/I2C_scan/proto.c b/F3:F303/I2C_scan/proto.c
index 7003a7d..e45ba5c 100644
--- a/F3:F303/I2C_scan/proto.c
+++ b/F3:F303/I2C_scan/proto.c
@@ -28,37 +28,49 @@
 static uint8_t locBuffer[LOCBUFFSZ];
 extern volatile uint32_t Tms;
 
-const char *helpstring =
+static const char *OK = "OK\n";
+static const char *helpstring =
         "https://github.com/eddyem/stm32samples/tree/master/F3:F303/I2C_scan build#" BUILD_NUMBER " @ " BUILD_DATE "\n"
-        "i0..2 - setup I2C with lowest..highest speed (7.7, 10 and 100kHz)\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"
         "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 bytes from 16-bit register\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"
+        "L - switch to little-endian (default) format for 16-bit registers\n"
         "T - print current Tms\n"
 ;
 
-static uint8_t i2cinited = 0;
 TRUE_INLINE const char *setupI2C(const char *buf){
+    if(!buf || !*buf){
+        USND("Current speed: "); USB_putbyte('0' + i2c_curspeed); newline();
+        return NULL;
+    }
     buf = omit_spaces(buf);
-    if(*buf < '0' || *buf > '2') return "Wrong speed\n";
-    i2c_setup(*buf - '0');
-    i2cinited = 1;
-    return "OK\n";
+    int speed = *buf - '0';
+    if(speed < 0 || speed >= I2C_SPEED_AMOUNT){
+        return "Wrong speed!\n";
+    }
+    i2c_setup((i2c_speed_t)speed);
+    return OK;
 }
 
 static uint8_t I2Caddress = 0;
 TRUE_INLINE const char *saI2C(const char *buf){
     uint32_t addr;
-    if(!getnum(buf, &addr) || addr > 0x7f) return "Wrong address\n";
-    I2Caddress = (uint8_t) addr << 1;
+    USND("saI2C: '"); USND(buf); USND("'\n");
+    const char *nxt = getnum(buf, &addr);
+    if(nxt && nxt != buf){
+        if(addr > 0x7f) return "Wrong address\n";
+        I2Caddress = (uint8_t) addr << 1;
+    }else addr = I2Caddress >> 1;
     USND("I2Caddr="); USND(uhex2str(addr)); newline();
-    return "OK\n";
+    return OK;
 }
 static void rdI2C(const char *buf, int is16){
     uint32_t N = 0;
@@ -85,35 +97,41 @@ static void rdI2C(const char *buf, int is16){
         return;
     }
     const char *erd = "Error reading I2C\n";
+    uint8_t *b8 = NULL; uint16_t *b16 = NULL;
     if(noreg){ // don't write register
         if(noreg == 1){
             USND("Simple read:\n");
-            if(!read_i2c(I2Caddress, locBuffer, N)){
+            if(!(b8 = read_i2c(I2Caddress, N))){
                 USND(erd);
                 return;
             }
         }else{
             USND("Try to read using DMA .. ");
             if(!read_i2c_dma(I2Caddress, N)) USND(erd);
-            else USND("OK\n");
+            else USND(OK);
             return;
         }
     }else{
         if(is16){
-            if(!read_i2c_reg16(I2Caddress, reg, locBuffer, N)){
+            if(!(b16 = read_i2c_reg16(I2Caddress, reg, N))){
                 USND(erd);
                 return;
             }
         }else{
-            if(!read_i2c_reg(I2Caddress, reg, locBuffer, N)){
+            if(!(b8 = read_i2c_reg(I2Caddress, reg, N))){
                 USND(erd);
                 return;
             }
         }
     }
-    if(N == 0){ USND("OK\n"); return; }
+    if(N == 0){ USND(OK); return; }
     if(!noreg){USND("Register "); USND(uhex2str(reg)); USND(":\n");}
-    hexdump(USB_sendstr, locBuffer, N);
+    if(!is16){ hexdump(USB_sendstr, b8, N); return; }
+    for(int i = 0; i < (int)N; ++i){
+        USND(uhex2str(b16[i])); USB_putbyte(' ');
+        if((i & 7) == 7) newline();
+    }
+    if(N & 7) newline();
 }
 // read N numbers from buf, @return 0 if wrong or none
 TRUE_INLINE uint16_t readNnumbers(const char *buf){
@@ -133,33 +151,49 @@ static const char *wrI2C(const char *buf, int isdma){
     int result = isdma ? write_i2c_dma(I2Caddress, locBuffer, N) :
                          write_i2c(I2Caddress, locBuffer, N);
     if(!result) return "Error writing I2C\n";
-    return "OK\n";
+    return OK;
 }
 
 const char *parse_cmd(const char *buf){
-    // "long" commands
-    switch(*buf){
+    if(!buf || !*buf) return NULL;
+    if(buf[1]) switch(*buf){ // "long" commands
         case 'i':
             return setupI2C(buf + 1);
         break;
         case 'I':
-            if(!i2cinited) return "Init I2C first";
             buf = omit_spaces(buf + 1);
-            if(*buf == 'a') return saI2C(buf + 1);
-            else if(*buf == 'r'){ rdI2C(buf + 1, 0); return NULL; }
-            else if(*buf == '2'){ rdI2C(buf + 1, 1); return NULL; }
-            else if(*buf == 'n'){ rdI2C(buf, 0); return NULL; }
-            else if(*buf == 'N'){ rdI2C(buf, 0); return NULL; }
-            else if(*buf == 'w') return wrI2C(buf + 1, 0);
-            else if(*buf == 'W') return wrI2C(buf + 1, 1);
-            else if(*buf == 's'){ i2c_init_scan_mode(); return "Start scan\n"; }
-            else if(*buf == 'g'){ i2c_bufdudump(); return NULL; }
-            else return "Command should be 'Ia', 'Iw', 'Ir' or 'Is'\n";
+            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");
     }
-    // "short" commands
-    if(buf[1]) return buf; // echo wrong data
     switch(*buf){
+        case 'i': return setupI2C(NULL); // current settings
+        case 'B':
+            endianness(1);
+            return OK;
+        break;
+        case 'L':
+            endianness(0);
+            return OK;
+        break;
         case 'T':
             USND("T=");
             USND(u2str(Tms));