fixed header in help

F3:F303/MLX90640multi/i2c.c

@@ -33,6 +33,7 @@ static volatile int I2Cbusy = 0, goterr = 0; // busy==1 when DMA active, goterr=
 static uint16_t I2Cbuf[I2C_BUFSIZE];
 static uint16_t i2cbuflen = 0; // buffer for DMA rx and its len
 static volatile uint16_t dma_remain = 0; // remain bytes of DMA read/write
+static uint8_t dmaaddr = 0; // address to continuous read by DMA
 
 // macros for I2C rx/tx
 #define DMARXCCR    (DMA_CCR_MINC | DMA_CCR_TCIE | DMA_CCR_TEIE)
@@ -271,6 +272,7 @@ static uint8_t dmard(uint8_t addr, uint16_t nbytes){
     (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;
+    dmaaddr = addr;
     dma_remain = nbytes > 255 ? nbytes - 255 : 0; // remainder after first read finish
     I2Cbusy = 1;
     return 1;
@@ -329,7 +331,8 @@ void i2c_bufdudump(){
 
 // get DMA buffer with conversion to little-endian (if transfer was for 16-bit)
 uint16_t *i2c_dma_getbuf(uint16_t *len){
-    if(i2c_got_DMA) USND("DMA GOT!");
+    //if(i2c_got_DMA) USND("DMA GOT!");
+    //U("T="); U(u2str(Tms)); U("; cndtr: "); USND(u2str(DMA1_Channel7->CNDTR));
     if(!i2c_got_DMA || i2cbuflen < 1) return NULL;
     i2c_got_DMA = 0;
     i2cbuflen >>= 1; // for hexdump16 - now buffer have uint16_t!
@@ -358,7 +361,7 @@ static void I2C_isr(int rx){
         uint16_t len = (dma_remain > 255) ? 255 : dma_remain;
         ch->CNDTR = len;
         if(rx){
-            if(!i2c_startr(0, dma_remain, 0)){
+            if(!i2c_startr(dmaaddr, dma_remain, 0)){
                 goterr = 1; goto ret;
             }
             ch->CMAR += 255;

F3:F303/MLX90640multi/main.c

@@ -41,7 +41,7 @@ int main(void){
     }
     USBPU_OFF();
     hw_setup();
-    i2c_setup(I2C_SPEED_100K);
+    i2c_setup(I2C_SPEED_400K);
     USB_setup();
     USBPU_ON();
     uint32_t ctr = Tms, Tlastima[N_SESORS] = {0};
@@ -49,6 +49,7 @@ int main(void){
     while(1){
         if(Tms - ctr > 499){
             ctr = Tms;
+            if(!mlx_nactive()){ mlx_stop(); mlx_continue(); }
             pin_toggle(GPIOB, 1 << 1 | 1 << 0); // toggle LED @ PB0
         }
         int l = USB_receivestr(inbuff, MAXSTRLEN);
@@ -72,7 +73,8 @@ int main(void){
             if(Tnow != Tlastima[i]){
                 fp_t *im = mlx_getimage(i);
                 if(im){
-                    U("Timage="); USND(u2str(Tnow)); drawIma(im);
+                    U(Sensno); USND(i2str(i));
+                    U(Timage); USND(u2str(Tnow)); drawIma(im);
                     Tlastima[i] = Tnow;
                 }
             }

F3:F303/MLX90640multi/mlx90640.c

@@ -31,7 +31,10 @@
 // tolerance of floating point comparison
 #define FP_TOLERANCE    (1e-3)
 
+// 3072 bytes
 static fp_t mlx_image[MLX_PIXNO] = {0}; // ready image
+// 10100 bytes:
+static MLX90640_params params; // calculated parameters (in heap, not stack!) for other functions
 
 void dumpIma(const fp_t im[MLX_PIXNO]){
     for(int row = 0; row < MLX_H; ++row){
@@ -100,29 +103,29 @@ static void occacc(int8_t *arr, int l, const uint16_t *regstart){
 }
 
 // get all parameters' values from `dataarray`, return FALSE if something failed
-int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *params){
+MLX90640_params *get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN]){
     #define CREG_VAL(reg) dataarray[CREG_IDX(reg)]
     int8_t i8;
     int16_t i16;
     uint16_t *pu16;
     uint16_t val = CREG_VAL(REG_VDD);
     i8 = (int8_t) (val >> 8);
-    params->kVdd = i8 * 32; // keep sign
+    params.kVdd = i8 * 32; // keep sign
-    if(params->kVdd == 0) return FALSE;
+    if(params.kVdd == 0){USND("kvdd=0"); return NULL;}
     i16 = val & 0xFF;
-    params->vdd25 = ((i16 - 0x100) * 32) - (1<<13);
+    params.vdd25 = ((i16 - 0x100) * 32) - (1<<13);
     val = CREG_VAL(REG_KVTPTAT);
     i16 = (val & 0xFC00) >> 10;
     if(i16 > 0x1F) i16 -= 0x40;
-    params->KvPTAT = (fp_t)i16 / (1<<12);
+    params.KvPTAT = (fp_t)i16 / (1<<12);
     i16 = (val & 0x03FF);
     if(i16 > 0x1FF) i16 -= 0x400;
-    params->KtPTAT = (fp_t)i16 / 8.;
+    params.KtPTAT = (fp_t)i16 / 8.;
-    params->vPTAT25 = (int16_t) CREG_VAL(REG_PTAT);
+    params.vPTAT25 = (int16_t) CREG_VAL(REG_PTAT);
     val = CREG_VAL(REG_APTATOCCS) >> 12;
-    params->alphaPTAT = val / 4. + 8.;
+    params.alphaPTAT = val / 4. + 8.;
-    params->gainEE = (int16_t)CREG_VAL(REG_GAIN);
+    params.gainEE = (int16_t)CREG_VAL(REG_GAIN);
-    if(params->gainEE == 0) return FALSE;
+    if(params.gainEE == 0){USND("gainee=0"); return NULL;}
     int8_t occRow[MLX_H];
     int8_t occColumn[MLX_W];
     occacc(occRow, MLX_H, &CREG_VAL(REG_OCCROW14));
@@ -150,11 +153,11 @@ int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *pa
     // so index of ktaavg is 2*(row&1)+(col&1)
     val = CREG_VAL(REG_KTAVSCALE);
     uint8_t scale1 = ((val & 0xFF)>>4) + 8, scale2 = (val&0xF);
-    if(scale1 == 0 || scale2 == 0) return FALSE;
+    if(scale1 == 0 || scale2 == 0){USND("scale1/2=0"); return NULL;}
     fp_t mul = (fp_t)(1<<scale2), div = (fp_t)(1<<scale1); // kta_scales
     uint16_t a_r = CREG_VAL(REG_SENSIVITY); // alpha_ref
     val = CREG_VAL(REG_SCALEACC);
-    fp_t *a = params->alpha;
+    fp_t *a = params.alpha;
     uint32_t diva32 = 1 << (val >> 12);
     fp_t diva = (fp_t)(diva32);
     diva *= (fp_t)(1<<30); // alpha_scale
@@ -162,8 +165,8 @@ int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *pa
           accColumnScale = 1<<((val & 0x00f0)>>4),
           accRemScale = 1<<(val & 0x0f);
     pu16 = (uint16_t*)&CREG_VAL(REG_OFFAK1);
-    fp_t *kta = params->kta, *offset = params->offset;
+    fp_t *kta = params.kta, *offset = params.offset;
-    uint8_t *ol = params->outliers;
+    uint8_t *ol = params.outliers;
     for(int row = 0; row < MLX_H; ++row){
         int idx = (row&1)<<1;
         for(int col = 0; col < MLX_W; ++col){
@@ -197,59 +200,59 @@ int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *pa
     ktaavg[2] = (int8_t)i16; // odd col, even row
     i16 = val & 0x0F; if(i16 > 0x07) i16 -= 0x10;
     ktaavg[3] = (int8_t)i16; // even col, even row
-    for(int i = 0; i < 4; ++i) params->kv[i] = ktaavg[i] / div;
+    for(int i = 0; i < 4; ++i) params.kv[i] = ktaavg[i] / div;
     val = CREG_VAL(REG_CPOFF);
-    params->cpOffset[0] = (val & 0x03ff);
+    params.cpOffset[0] = (val & 0x03ff);
-    if(params->cpOffset[0] > 0x1ff) params->cpOffset[0] -= 0x400;
+    if(params.cpOffset[0] > 0x1ff) params.cpOffset[0] -= 0x400;
-    params->cpOffset[1] = val >> 10;
+    params.cpOffset[1] = val >> 10;
-    if(params->cpOffset[1] > 0x1f) params->cpOffset[1] -= 0x40;
+    if(params.cpOffset[1] > 0x1f) params.cpOffset[1] -= 0x40;
-    params->cpOffset[1] += params->cpOffset[0];
+    params.cpOffset[1] += params.cpOffset[0];
     val = ((CREG_VAL(REG_KTAVSCALE) & 0xF0) >> 4) + 8;
     i8 = (int8_t)(CREG_VAL(REG_KVTACP) & 0xFF);
-    params->cpKta = (fp_t)i8 / (1<<val);
+    params.cpKta = (fp_t)i8 / (1<<val);
     val = (CREG_VAL(REG_KTAVSCALE) & 0x0F00) >> 8;
     i16 = CREG_VAL(REG_KVTACP) >> 8;
     if(i16 > 0x7F) i16 -= 0x100;
-    params->cpKv = (fp_t)i16 / (1<<val);
+    params.cpKv = (fp_t)i16 / (1<<val);
     i16 = CREG_VAL(REG_KSTATGC) & 0xFF;
     if(i16 > 0x7F) i16 -= 0x100;
-    params->tgc = (fp_t)i16;
+    params.tgc = (fp_t)i16;
-    params->tgc /= 32.;
+    params.tgc /= 32.;
     val = (CREG_VAL(REG_SCALEACC)>>12); // alpha_scale_CP
     i16 = CREG_VAL(REG_ALPHA)>>10; // cp_P1_P0_ratio
     if(i16 > 0x1F) i16 -= 0x40;
     div = (fp_t)(1<<val);
     div *= (fp_t)(1<<27);
-    params->cpAlpha[0] = (fp_t)(CREG_VAL(REG_ALPHA) & 0x03FF) / div;
+    params.cpAlpha[0] = (fp_t)(CREG_VAL(REG_ALPHA) & 0x03FF) / div;
     div = (fp_t)(1<<7);
-    params->cpAlpha[1] = params->cpAlpha[0] * (1. + (fp_t)i16/div);
+    params.cpAlpha[1] = params.cpAlpha[0] * (1. + (fp_t)i16/div);
     i8 = (int8_t)(CREG_VAL(REG_KSTATGC) >> 8);
-    params->KsTa = (fp_t)i8/(1<<13);
+    params.KsTa = (fp_t)i8/(1<<13);
     div = 1<<((CREG_VAL(REG_CT34) & 0x0F) + 8); // kstoscale
     val = CREG_VAL(REG_KSTO12);
     i8 = (int8_t)(val & 0xFF);
-    params->KsTo[0] = i8 / div;
+    params.KsTo[0] = i8 / div;
     i8 = (int8_t)(val >> 8);
-    params->KsTo[1] = i8 / div;
+    params.KsTo[1] = i8 / div;
     val = CREG_VAL(REG_KSTO34);
     i8 = (int8_t)(val & 0xFF);
-    params->KsTo[2] = i8 / div;
+    params.KsTo[2] = i8 / div;
     i8 = (int8_t)(val >> 8);
-    params->KsTo[3] = i8 / div;
+    params.KsTo[3] = i8 / div;
     // CT1 = -40, CT2 = 0 -> start from zero index, so CT[0] is CT2, CT[1] is CT3, CT[2] is CT4
-    params->CT[0] = 0.; // 0degr - between ranges 1 and 2
+    params.CT[0] = 0.; // 0degr - between ranges 1 and 2
     val = CREG_VAL(REG_CT34);
     mul = ((val & 0x3000)>>12)*10.; // step
-    params->CT[1] = ((val & 0xF0)>>4)*mul; // CT3 - between ranges 2 and 3
+    params.CT[1] = ((val & 0xF0)>>4)*mul; // CT3 - between ranges 2 and 3
-    params->CT[2] = ((val & 0x0F00) >> 8)*mul + params->CT[1]; // CT4 - between ranges 3 and 4
+    params.CT[2] = ((val & 0x0F00) >> 8)*mul + params.CT[1]; // CT4 - between ranges 3 and 4
     // alphacorr for each range: 11.1.11
-    params->alphacorr[0] = 1./(1. + params->KsTo[0] * 40.);
+    params.alphacorr[0] = 1./(1. + params.KsTo[0] * 40.);
-    params->alphacorr[1] = 1.;
+    params.alphacorr[1] = 1.;
-    params->alphacorr[2] = (1. + params->KsTo[1] * params->CT[1]);
+    params.alphacorr[2] = (1. + params.KsTo[1] * params.CT[1]);
-    params->alphacorr[3] = (1. + params->KsTo[2] * (params->CT[2] - params->CT[1])) * params->alphacorr[2];
+    params.alphacorr[3] = (1. + params.KsTo[2] * (params.CT[2] - params.CT[1])) * params.alphacorr[2];
-    params->resolEE = (uint8_t)((CREG_VAL(REG_KTAVSCALE) & 0x3000) >> 12);
+    params.resolEE = (uint8_t)((CREG_VAL(REG_KTAVSCALE) & 0x3000) >> 12);
     // Don't forget to check 'outlier' flags for wide purpose
-    return TRUE;
+    return &params;
 #undef CREG_VAL
 }
 
@@ -261,37 +264,37 @@ int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *pa
  * @param subpageno
  * @return
  */
-fp_t *process_image(const MLX90640_params *params, const int16_t subpage1[REG_IMAGEDATA_LEN]){
+fp_t *process_image(const int16_t subpage1[REG_IMAGEDATA_LEN]){
 #define IMD_VAL(reg) subpage1[IMD_IDX(reg)]
     // 11.2.2.1. Resolution restore
-    //fp_t resol_corr = (fp_t)(1<<params->resolEE) / (1<<mlx_getresolution()); // calibrated resol/current resol
+    //fp_t resol_corr = (fp_t)(1<<params.resolEE) / (1<<mlx_getresolution()); // calibrated resol/current resol
-    fp_t resol_corr = (fp_t)(1<<params->resolEE) / (1<<2); // ONLY DEFAULT!
+    fp_t resol_corr = (fp_t)(1<<params.resolEE) / (1<<2); // ONLY DEFAULT!
     int16_t i16a;
     fp_t dvdd, dTa, Kgain, pixOS[2]; // values for both subpages
     // 11.2.2.2. Supply voltage value calculation
     i16a = (int16_t)IMD_VAL(REG_IVDDPIX);
     //U("rval="); USND(i2str(i16a));
-    dvdd = resol_corr*i16a - params->vdd25;
+    dvdd = resol_corr*i16a - params.vdd25;
-    dvdd /= params->kVdd;
+    dvdd /= params.kVdd;
     //U("dvdd="); USND(float2str(dvdd, 2));
-    fp_t dV = i16a - params->vdd25; // for next step
+    fp_t dV = i16a - params.vdd25; // for next step
-    dV /= params->kVdd;
+    dV /= params.kVdd;
     // 11.2.2.3. Ambient temperature calculation
     i16a = (int16_t)IMD_VAL(REG_ITAPTAT);
     int16_t i16b = (int16_t)IMD_VAL(REG_ITAVBE);
-    dTa = (fp_t)i16a / (i16a * params->alphaPTAT + i16b); // vptatart
+    dTa = (fp_t)i16a / (i16a * params.alphaPTAT + i16b); // vptatart
     dTa *= (fp_t)(1<<18);
-    dTa = (dTa / (1. + params->KvPTAT*dV)) - params->vPTAT25;
+    dTa = (dTa / (1. + params.KvPTAT*dV)) - params.vPTAT25;
-    dTa = dTa / params->KtPTAT; // without 25degr - Ta0
+    dTa = dTa / params.KtPTAT; // without 25degr - Ta0
     // 11.2.2.4. Gain parameter calculation
     i16a = (int16_t)IMD_VAL(REG_IGAIN);
-    Kgain = params->gainEE / (fp_t)i16a;
+    Kgain = params.gainEE / (fp_t)i16a;
     // 11.2.2.6.1
     pixOS[0] = ((int16_t)IMD_VAL(REG_ICPSP0))*Kgain; // pix_OS_CP_SPx
     pixOS[1] = ((int16_t)IMD_VAL(REG_ICPSP1))*Kgain;
     // 11.2.2.6.2
     for(int sp = 0; sp < 2; ++sp)
-        pixOS[sp] -= params->cpOffset[sp]*(1. + params->cpKta*dTa)*(1. + params->cpKv*dvdd);
+        pixOS[sp] -= params.cpOffset[sp]*(1. + params.cpKta*dTa)*(1. + params.cpKv*dvdd);
     // now make first approximation to image
     uint16_t pixno = 0;  // current pixel number - for indexing in parameters etc
     for(int row = 0, rowidx = 0; row < MLX_H; ++row, rowidx ^= 2){
@@ -300,34 +303,34 @@ fp_t *process_image(const MLX90640_params *params, const int16_t subpage1[REG_IM
             // 11.2.2.5.1
             fp_t curval = (fp_t)(subpage1[pixno]) * Kgain; // gain compensation
             // 11.2.2.5.3
-            curval -= params->offset[pixno] * (1. + params->kta[pixno]*dTa) *
+            curval -= params.offset[pixno] * (1. + params.kta[pixno]*dTa) *
-                    (1. + params->kv[idx]*dvdd); // add offset
+                    (1. + params.kv[idx]*dvdd); // add offset
             // now `curval` is pix_OS == V_IR_emiss_comp (we can divide it by `emissivity` to compensate for it)
             // 11.2.2.7: 'Pattern' is just subpage number!
-            fp_t IRcompens = curval - params->tgc * pixOS[sp]; // 11.2.2.8. Normalizing to sensitivity
+            fp_t IRcompens = curval - params.tgc * pixOS[sp]; // 11.2.2.8. Normalizing to sensitivity
             // 11.2.2.8
-            fp_t alphaComp = params->alpha[pixno] - params->tgc * params->cpAlpha[sp];
+            fp_t alphaComp = params.alpha[pixno] - params.tgc * params.cpAlpha[sp];
-            alphaComp *= 1. + params->KsTa * dTa;
+            alphaComp *= 1. + params.KsTa * dTa;
             // 11.2.2.9: calculate To for basic range
             fp_t Tar = dTa + 273.15 + 25.; // Ta+273.15
             Tar = Tar*Tar*Tar*Tar; // T_aK4 (when \epsilon==1 this is T_{a-r} too)
             fp_t ac3 = alphaComp*alphaComp*alphaComp;
             fp_t Sx = ac3*IRcompens + alphaComp*ac3*Tar;
-            Sx = params->KsTo[1] * SQRT(SQRT(Sx));
+            Sx = params.KsTo[1] * SQRT(SQRT(Sx));
-            fp_t To4 = IRcompens / (alphaComp * (1. - 273.15*params->KsTo[1]) + Sx) + Tar;
+            fp_t To4 = IRcompens / (alphaComp * (1. - 273.15*params.KsTo[1]) + Sx) + Tar;
             curval = SQRT(SQRT(To4)) - 273.15;
             // 11.2.2.9.1.3. Extended To range calculation
             int r = 0; // range 1 by default
             fp_t ctx = -40.;
-            if(curval > params->CT[2]){ // range 4
+            if(curval > params.CT[2]){ // range 4
-                r = 3; ctx = params->CT[2];
+                r = 3; ctx = params.CT[2];
-            }else if(curval > params->CT[1]){ // range 3
+            }else if(curval > params.CT[1]){ // range 3
-                r = 2; ctx = params->CT[1];
+                r = 2; ctx = params.CT[1];
-            }else if(curval > params->CT[0]){ // range 2, default
+            }else if(curval > params.CT[0]){ // range 2, default
-                r = 1; ctx = params->CT[0];
+                r = 1; ctx = params.CT[0];
             }
             if(r != 1){ // recalculate for extended range if we are out of standard range
-                To4 = IRcompens / (alphaComp * params->alphacorr[r] * (1. + params->KsTo[r]*(curval - ctx))) + Tar;
+                To4 = IRcompens / (alphaComp * params.alphacorr[r] * (1. + params.KsTo[r]*(curval - ctx))) + Tar;
                 curval = SQRT(SQRT(To4)) - 273.15;
             }
             mlx_image[pixno] = curval;
@@ -337,26 +340,3 @@ fp_t *process_image(const MLX90640_params *params, const int16_t subpage1[REG_IM
 #undef IMD_VAL
 }
 
-/*
-int MLXtest(){
-    MLX90640_params p;
-    USB_sendstr("    Extract parameters - ");
-    if(!get_parameters(EEPROM, &p)) return 2;
-    USB_sendstr(OK);
-    dump_parameters(&p, &extracted_parameters);
-    fp_t *sp;
-    for(int i = 0; i < 2; ++i){
-        USB_sendstr("    100 times process subpage - "); printi(i); USB_putbyte(' ');
-        uint32_t Tstart = Tms;
-        for(int _ = 0; _ < 100; ++_){
-            sp = process_subpage(&p, DataFrame[i], i, 2);
-            if(!sp) return 1;
-        }
-        USB_sendstr(OKs); printfl((Tms - Tstart)/100.f, 3); USB_sendstr(" ms\n");
-        dumpIma(sp);
-        chkImage(sp, ToFrame[i]);
-    }
-    drawIma(sp);
-    return 0;
-}
-*/

F3:F303/MLX90640multi/mlx90640.creator.user

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 17.0.1, 2025-09-23T22:23:26. -->
+<!-- Written by QtCreator 17.0.1, 2025-09-24T23:35:56. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>

F3:F303/MLX90640multi/mlx90640.h

@@ -59,7 +59,7 @@ typedef struct{
 } MLX90640_params;
 
 int ch_resolution(uint8_t newresol);
-int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *params);
+MLX90640_params *get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN]);
-fp_t *process_image(const MLX90640_params *params, const int16_t subpage1[REG_IMAGEDATA_LEN]);
+fp_t *process_image(const int16_t subpage1[REG_IMAGEDATA_LEN]);
 void dumpIma(const fp_t im[MLX_PIXNO]);
 void drawIma(const fp_t im[MLX_PIXNO]);

F3:F303/MLX90640multi/mlxproc.c

@@ -21,8 +21,20 @@
 #include "i2c.h"
 #include "mlxproc.h"
 #include "mlx90640_regs.h"
+
+//#define DEBUGPROC
+
+#ifdef DEBUGPROC
 #include "usb_dev.h"
 #include "strfunc.h"
+#define D(x)        U(x)
+#define DN(x)       USND(x)
+#define DB(x)       USB_putbute(x)
+#else
+#define D(x)
+#define DN(x)
+#define DB(x)
+#endif
 
 extern volatile uint32_t Tms;
 
@@ -32,11 +44,19 @@ static int errctr = 0; // errors counter - cleared by mlx_continue
 static uint32_t Tlastimage[N_SESORS] = {0};
 
 // subpages and configs of all sensors
+// 8320 bytes:
 static int16_t imdata[N_SESORS][REG_IMAGEDATA_LEN];
+// 8340 bytes:
 static uint16_t confdata[N_SESORS][MLX_DMA_MAXLEN];
 static uint8_t sens_addresses[N_SESORS] = {0x10<<1, 0x11<<1, 0x12<<1, 0x13<<1, 0x14<<1}; // addresses of all sensors (if 0 - omit this one)
 static uint8_t sensaddr[N_SESORS];
 
+// get compile-time size: (gcc shows it in error message)
+//char (*__kaboom)[sizeof( confdata )] = 1;
+
+// return `sensaddr`
+uint8_t *mlx_activeids(){return sensaddr;}
+
 static int sensno = -1;
 
 // get current state
@@ -54,12 +74,14 @@ void mlx_pause(){
     MLX_oldstate = MLX_state;
     MLX_state = MLX_RELAX;
 }
+// TODO: add here power management
 void mlx_stop(){
     MLX_oldstate = MLX_NOTINIT;
     MLX_state = MLX_RELAX;
 }
 
 // continue processing
+// TODO: add here power management
 void mlx_continue(){
     errctr = 0;
     switch(MLX_oldstate){
@@ -70,6 +92,7 @@ void mlx_continue(){
         //case MLX_NOTINIT:
         //case MLX_WAITPARAMS:
         default:
+            i2c_setup(i2c_curspeed); // restart I2C (what if there was errors?)
             memcpy(sensaddr, sens_addresses, sizeof(sens_addresses));
             MLX_state = MLX_NOTINIT;
             sensno = -1;
@@ -85,7 +108,7 @@ static int nextsensno(int s){
     int next = s + 1;
     for(; next < N_SESORS; ++next) if(sensaddr[next]) break;
     if(next == N_SESORS) return nextsensno(-1); // roll to start
-        U(i2str(next)); USND(" - new sensor number");
+        D(i2str(next)); DB('('); D(i2str(s)); DB(')'); DN(" - new sensor number");
     return next;
 }
 
@@ -115,20 +138,20 @@ void mlx_process(){
     switch(MLX_state){
         case MLX_NOTINIT: // start reading parameters
             if(i2c_read_reg16(sensaddr[sensno], REG_CALIDATA, MLX_DMA_MAXLEN, 1)){
-                    U(i2str(sensno)); USND(" wait conf");
+                    D(i2str(sensno)); DN(" wait conf");
                 errctr = 0;
                 MLX_state = MLX_WAITPARAMS;
             }else ++errctr;
         break;
         case MLX_WAITPARAMS: // check DMA ends and calculate parameters
-            if(i2c_dma_haderr()){ MLX_state = MLX_NOTINIT; USND("DMA err");}
+            if(i2c_dma_haderr()){ MLX_state = MLX_NOTINIT; DN("DMA err");}
             else{
                 uint16_t len, *buf = i2c_dma_getbuf(&len);
-                if(buf) USND("READ");
+                if(!buf) break;
-                else break;
+                DN("READ");
                 if(len != MLX_DMA_MAXLEN){ MLX_state = MLX_NOTINIT; break; }
                 memcpy(confdata[sensno], buf, MLX_DMA_MAXLEN * sizeof(uint16_t));
-                    U(i2str(sensno)); USND(" got conf");
+                    D(i2str(sensno)); DN(" got conf");
                 int next = nextsensno(sensno);
                 errctr = 0;
                 if(next <= sensno) MLX_state = MLX_WAITSUBPAGE; // all configuration read
@@ -143,14 +166,20 @@ void mlx_process(){
                 if(subpage == (*got & REG_STATUS_SPNO)){
                     errctr = 0;
                     if(subpage == 0){ // omit zero subpage for each sensor
+                        DN("omit 0 -> next sens");
                         int next = nextsensno(sensno);
-                        if(next <= sensno) subpage = 1; // all scanned - now wait for page 1
+                        if(next <= sensno){ // all scanned - now wait for page 1
+                            subpage = 1;
+                            DN("Wait for 1");
+                        }
+                        sensno = next;
                         break;
                     }
+                    D(i2str(sensno)); DN(" - ask for image");
                     if(i2c_read_reg16(sensaddr[sensno], REG_IMAGEDATA, REG_IMAGEDATA_LEN, 1)){
                         errctr = 0;
                         MLX_state = MLX_READSUBPAGE;
-                        //    U("spstart"); USB_putbyte('0'+subpage); USB_putbyte('='); USND(u2str(Tms - Tlast));
+                        //    D("spstart"); DB('0'+subpage); DB('='); DN(u2str(Tms - Tlast));
                     }else ++errctr;
                 }
             }else ++errctr;
@@ -161,17 +190,21 @@ void mlx_process(){
             else{
                 uint16_t len, *buf = i2c_dma_getbuf(&len);
                 if(buf){
-                    //    U("spread="); USND(u2str(Tms - Tlast));
+                    //    D("spread="); DN(u2str(Tms - Tlast));
                     if(len != REG_IMAGEDATA_LEN){
                         ++errctr;
                     }else{ // fine! we could check next sensor
                         errctr = 0;
                         memcpy(imdata[sensno], buf, REG_IMAGEDATA_LEN * sizeof(int16_t));
-                        //  U("spgot="); USND(u2str(Tms - Tlast));
+                        //  D("spgot="); DN(u2str(Tms - Tlast));
                         Tlastimage[sensno] = Tms;
-                        //  U("imgot="); USND(u2str(Tms - Tlast)); Tlast = Tms;
+                        //  D("imgot="); DN(u2str(Tms - Tlast)); Tlast = Tms;
                         int next = nextsensno(sensno);
-                        if(next <= sensno) subpage = 0; // roll to start - omit page 0 for all
+                        if(next <= sensno){
+                            subpage = 0; // roll to start - omit page 0 for all
+                            DN("All got -> start from 0");
+                        }
+                        sensno = next;
                     }
                     MLX_state = MLX_WAITSUBPAGE;
                 }
@@ -180,7 +213,7 @@ void mlx_process(){
         default:
             return;
     }
-    if(MLX_state != MLX_RELAX && Tms - Tlastimage[sensno] > MLX_I2CERR_TMOUT){ i2c_setup(i2c_curspeed); Tlastimage[sensno] = Tms; }
+    //if(MLX_state != MLX_RELAX && Tms - Tlastimage[sensno] > MLX_I2CERR_TMOUT){ i2c_setup(i2c_curspeed); Tlastimage[sensno] = Tms; }
     if(errctr > MLX_MAX_ERRORS){
         errctr = 0;
         sensaddr[sensno] = 0; // throw out this value
@@ -189,19 +222,18 @@ void mlx_process(){
 }
 
 // recalculate parameters
-int mlx_getparams(int n, MLX90640_params *pars){
+MLX90640_params *mlx_getparams(int n){
-    if(!pars) return 0;
+    MLX90640_params *p = get_parameters(confdata[n]);
-    if(!get_parameters(confdata[n], pars)) return 0;
+    return p;
-    return 1;
 }
 
 uint32_t mlx_lastimT(int n){ return Tlastimage[n]; }
 
 fp_t *mlx_getimage(int n){
     if(n < 0 || n >= N_SESORS || !sensaddr[n]) return NULL;
-    MLX90640_params p;
+    MLX90640_params *p = get_parameters(confdata[n]);
-    if(!get_parameters(confdata[n], &p)) return NULL;
+    if(!p) return NULL;
-    fp_t *ready_image = process_image(&p, imdata[n]);
+    fp_t *ready_image = process_image(imdata[n]);
     if(!ready_image) return NULL;
     return ready_image;
 }
@@ -212,7 +244,7 @@ int mlx_sethwaddr(uint8_t MLX_address, uint8_t addr){
     if(addr > 0x7f) return 0;
     uint16_t data[2], *ptr;
     if(!(ptr = i2c_read_reg16(MLX_address, REG_MLXADDR, 1, 0))) return 0;
-    //U("Old address: "); USND(uhex2str(*ptr));
+    //D("Old address: "); DN(uhex2str(*ptr));
     data[0] = REG_MLXADDR; data[1] = 0;
     uint16_t oldreg = *ptr;
     if(!i2c_write(MLX_address, data, 2)) return 0; // clear address
@@ -227,11 +259,11 @@ int mlx_sethwaddr(uint8_t MLX_address, uint8_t addr){
     }
     data[0] = REG_MLXADDR; // i2c_write swaps bytes, so we need init data again
     data[1] = (oldreg & ~REG_MLXADDR_MASK) | addr;
-    //U("Write address: "); U(uhex2str(data[0])); U(", "); USND(uhex2str(data[1]));
+    //D("Write address: "); D(uhex2str(data[0])); D(", "); DN(uhex2str(data[1]));
     if(!i2c_write(MLX_address, data, 2)) return 0;
     while(Tms - Told < 10);
     if(!(ptr = i2c_read_reg16(MLX_address, REG_MLXADDR, 1, 0))) return 0;
-    //U("Got address: "); USND(uhex2str(*ptr));
+    //D("Got address: "); DN(uhex2str(*ptr));
     if((*ptr & REG_MLXADDR_MASK) != addr) return 0;
     return 1;
 }

F3:F303/MLX90640multi/mlxproc.h

@@ -41,11 +41,12 @@ typedef enum{
 int mlx_setaddr(int n, uint8_t addr);
 mlx_state_t mlx_state();
 int mlx_nactive();
+uint8_t *mlx_activeids();
 void mlx_pause();
 void mlx_stop();
 void mlx_continue();
 void mlx_process();
-int mlx_getparams(int sensno, MLX90640_params *pars);
+MLX90640_params *mlx_getparams(int sensno);
 fp_t *mlx_getimage(int sensno);
 int mlx_sethwaddr(uint8_t MLX_address, uint8_t addr);
 uint32_t mlx_lastimT(int sensno);

F3:F303/MLX90640multi/proto.c

@@ -32,17 +32,24 @@ static uint8_t I2Caddress = 0x33 << 1;
 extern volatile uint32_t Tms;
 uint8_t cartoon = 0; // "cartoon" mode: refresh image each time we get new
 
+// common names for frequent keys
+const char *Timage = "TIMAGE=";
+const char *Sensno = "SENSNO=";
+
 static const char *OK = "OK\n", *ERR = "ERR\n";
 const char *helpstring =
-        "https://github.com/eddyem/stm32samples/tree/master/F3:F303/mlx90640 build#" BUILD_NUMBER " @ " BUILD_DATE "\n"
+        "https://github.com/eddyem/stm32samples/tree/master/F3:F303/MLX90640multi build#" BUILD_NUMBER " @ " BUILD_DATE "\n"
         "    management of single IR bolometer MLX90640\n"
         "aa - change I2C address to a (a should be non-shifted value!!!)\n"
         "c - continue MLX\n"
-        "d - draw image in ASCII\n"
+        "dn - draw nth image in ASCII\n"
+        "gn - get nth image 'as is' - float array of 768x4 bytes\n"
         "i0..4 - setup I2C with speed 10k, 100k, 400k, 1M or 2M (experimental!)\n"
+        "l - list active sensors IDs\n"
+        "tn - show temperature map of nth image\n"
         "p - pause MLX\n"
         "s - stop MLX (and start from zero @ 'c'\n"
-        "t - show temperature map\n"
+        "tn - show nth image aquisition time\n"
         "C - \"cartoon\" mode on/off (show each new image)\n"
         "Dn - dump MLX parameters for sensor number n\n"
         "G - get MLX state\n"
@@ -90,16 +97,23 @@ TRUE_INLINE const char *chhwaddr(const char *buf){
     return OK;
 }
 
+// read sensor's number from `buf`; return -1 if error
+static int getsensnum(const char *buf){
+    if(!buf || !*buf) return -1;
+    uint32_t num;
+    const char *nxt = getnum(buf, &num);
+    if(!nxt || nxt == buf || num >= N_SESORS) return -1;
+    return (int) num;
+}
+
 TRUE_INLINE const char *chaddr(const char *buf){
-    uint32_t addr, num;
+    uint32_t addr;
     const char *nxt = getnum(buf, &addr);
     if(nxt && nxt != buf){
         if(addr > 0x7f) return ERR;
         I2Caddress = (uint8_t) addr << 1;
-        buf = getnum(nxt, &num);
+        int n = getsensnum(nxt);
-        if(buf && nxt != buf && num < N_SESORS){
+        if(n > -1) mlx_setaddr(n, addr);
-            mlx_setaddr(num, addr);
-        }
     }else addr = I2Caddress >> 1;
     U("I2CADDR="); USND(uhex2str(addr));
     return NULL;
@@ -156,21 +170,20 @@ static void dumpfarr(float *arr){
 }
 // dump MLX parameters
 TRUE_INLINE void dumpparams(const char *buf){
-    uint32_t N = 0;
+    int N = getsensnum(buf);
-    const char *nxt = getnum(buf, &N);
+    if(N < 0){ U(ERR); return; }
-    U(u2str(N)); USND("sn");
+    MLX90640_params *params = mlx_getparams(N);
-    if(!nxt || buf == nxt || N > N_SESORS){ U(ERR); return; }
+    if(!params){ U(ERR); return; }
-    MLX90640_params params;
+    U(Sensno); USND(i2str(N));
-    if(!mlx_getparams(N, &params)){ U(ERR); return; }
+    U("\nkVdd="); printi(params->kVdd);
-    U("\nkVdd="); printi(params.kVdd);
+    U("\nvdd25="); printi(params->vdd25);
-    U("\nvdd25="); printi(params.vdd25);
+    U("\nKvPTAT="); printfl(params->KvPTAT, 4);
-    U("\nKvPTAT="); printfl(params.KvPTAT, 4);
+    U("\nKtPTAT="); printfl(params->KtPTAT, 4);
-    U("\nKtPTAT="); printfl(params.KtPTAT, 4);
+    U("\nvPTAT25="); printi(params->vPTAT25);
-    U("\nvPTAT25="); printi(params.vPTAT25);
+    U("\nalphaPTAT="); printfl(params->alphaPTAT, 2);
-    U("\nalphaPTAT="); printfl(params.alphaPTAT, 2);
+    U("\ngainEE="); printi(params->gainEE);
-    U("\ngainEE="); printi(params.gainEE);
     U("\nPixel offset parameters:\n");
-    float *offset = params.offset;
+    float *offset = params->offset;
     for(int row = 0; row < 24; ++row){
         for(int col = 0; col < 32; ++col){
             printfl(*offset++, 2); USB_putbyte(' ');
@@ -178,28 +191,28 @@ TRUE_INLINE void dumpparams(const char *buf){
         newline();
     }
     U("K_talpha:\n");
-    dumpfarr(params.kta);
+    dumpfarr(params->kta);
     U("Kv: ");
     for(int i = 0; i < 4; ++i){
-        printfl(params.kv[i], 2); USB_putbyte(' ');
+        printfl(params->kv[i], 2); USB_putbyte(' ');
     }
     U("\ncpOffset=");
-    printi(params.cpOffset[0]); U(", "); printi(params.cpOffset[1]);
+    printi(params->cpOffset[0]); U(", "); printi(params->cpOffset[1]);
-    U("\ncpKta="); printfl(params.cpKta, 2);
+    U("\ncpKta="); printfl(params->cpKta, 2);
-    U("\ncpKv="); printfl(params.cpKv, 2);
+    U("\ncpKv="); printfl(params->cpKv, 2);
-    U("\ntgc="); printfl(params.tgc, 2);
+    U("\ntgc="); printfl(params->tgc, 2);
-    U("\ncpALpha="); printfl(params.cpAlpha[0], 2);
+    U("\ncpALpha="); printfl(params->cpAlpha[0], 2);
-    U(", "); printfl(params.cpAlpha[1], 2);
+    U(", "); printfl(params->cpAlpha[1], 2);
-    U("\nKsTa="); printfl(params.KsTa, 2);
+    U("\nKsTa="); printfl(params->KsTa, 2);
     U("\nAlpha:\n");
-    dumpfarr(params.alpha);
+    dumpfarr(params->alpha);
-    U("\nCT3="); printfl(params.CT[1], 2);
+    U("\nCT3="); printfl(params->CT[1], 2);
-    U("\nCT4="); printfl(params.CT[2], 2);
+    U("\nCT4="); printfl(params->CT[2], 2);
     for(int i = 0; i < 4; ++i){
         U("\nKsTo"); USB_putbyte('0'+i); USB_putbyte('=');
-        printfl(params.KsTo[i], 2);
+        printfl(params->KsTo[i], 2);
         U("\nalphacorr"); USB_putbyte('0'+i); USB_putbyte('=');
-        printfl(params.alphacorr[i], 2);
+        printfl(params->alphacorr[i], 2);
     }
     newline();
 }
@@ -217,34 +230,81 @@ TRUE_INLINE void getst(){
     USND(states[s]);
 }
 
-// `draw`==1 - draw, ==0 - show T map
+// `draw`==1 - draw, ==0 - show T map, 2 - send raw float array with prefix 'SENSNO=x\nTimage=y\n' and postfix "ENDIMAGE\n"
 static const char *drawimg(const char *buf, int draw){
-    uint32_t sensno;
+    int sensno = getsensnum(buf);
-    const char *nxt = getnum(buf, &sensno);
+    if(sensno > -1){
-    if(nxt && nxt != buf && sensno < N_SESORS){
         uint32_t T = mlx_lastimT(sensno);
         fp_t *img = mlx_getimage(sensno);
         if(img){
-            U("Timage="); USND(u2str(T));
+            U(Sensno); USND(u2str(sensno));
-            if(draw) drawIma(img);
+            U(Timage); USND(u2str(T));
-            else dumpIma(img);
+            switch(draw){
+                case 0:
+                    dumpIma(img);
+                break;
+                case 1:
+                    drawIma(img);
+                break;
+                case 2:
+                {
+                    uint8_t *d = (uint8_t*)img;
+                    uint32_t _2send = MLX_PIXNO * sizeof(float);
+                    // send by portions of 256 bytes (as image is larger than ringbuffer)
+                    while(_2send){
+                        uint32_t portion = (_2send > 256) ? 256 : _2send;
+                        USB_send(d, portion);
+                        _2send -= portion;
+                        d += portion;
+                    }
+                }
+                    USND("ENDIMAGE");
+            }
             return NULL;
         }
     }
     return ERR;
 }
 
+TRUE_INLINE void listactive(){
+    int N =  mlx_nactive();
+    if(!N){ USND("No active sensors found!"); return; }
+    uint8_t *ids = mlx_activeids();
+    U("Found "); USB_putbyte('0'+N); USND(" active sensors:");
+    for(int i = 0; i < N_SESORS; ++i)
+        if(ids[i]){
+            U("SENSID"); U(u2str(i)); USB_putbyte('=');
+            U(uhex2str(ids[i] >> 1));
+            newline();
+        }
+}
+
+static void getimt(const char *buf){
+    int sensno = getsensnum(buf);
+    if(sensno > -1){
+        U(Timage); USND(u2str(mlx_lastimT(sensno)));
+    }else U(ERR);
+}
+
 const char *parse_cmd(char *buf){
     if(!buf || !*buf) return NULL;
     if(buf[1]){
         switch(*buf){ // "long" commands
             case 'a':
                 return chhwaddr(buf + 1);
+            case 'd':
+                return drawimg(buf+1, 1);
+            case 'g':
+                return drawimg(buf+1, 2);
             case 'i':
                 return setupI2C(buf + 1);
+            case 'm':
+                return drawimg(buf+1, 0);
+            case 't':
+                getimt(buf + 1); return NULL;
             case 'D':
                 dumpparams(buf + 1);
-                return;
+                return NULL;
             break;
             case 'I':
                 buf = omit_spaces(buf + 1);
@@ -270,18 +330,15 @@ const char *parse_cmd(char *buf){
         case 'c':
             mlx_continue(); return OK;
         break;
-        case 'd':
-            return drawimg(buf+1, 1);
-        break;
         case 'i': return setupI2C(NULL); // current settings
+        case 'l':
+            listactive();
+        break;
         case 'p':
             mlx_pause(); return OK;
         break;
         case 's':
             mlx_stop(); return OK;
-        case 't':
-            return drawimg(buf+1, 0);
-        break;
         case 'C':
             cartoon = !cartoon; return OK;
         case 'G':

F3:F303/MLX90640multi/proto.h

@@ -18,5 +18,7 @@
 
 #pragma once
 
+extern const char *Timage, *Sensno;
+
 extern uint8_t cartoon;
 char *parse_cmd(char *buf);

F3:F303/MLX90640multi/usb_dev.h

@@ -44,7 +44,7 @@ void linecoding_handler(usb_LineCoding *lc);
 
 // sizes of ringbuffers for outgoing and incoming data
 #define RBOUTSZ     (1024)
-#define RBINSZ      (1024)
+#define RBINSZ      (128)
 
 #define newline()   USB_putbyte('\n')
 #define USND(s)     do{USB_sendstr(s); USB_putbyte('\n');}while(0)

F3:F303/MLX90640multi/version.inc

@@ -1,2 +1,2 @@
-#define BUILD_NUMBER "30"
+#define BUILD_NUMBER "66"
-#define BUILD_DATE "2025-09-23"
+#define BUILD_DATE "2025-09-24"