From 9b0ee8789152988df2179ff0f854c8208c5c09c2 Mon Sep 17 00:00:00 2001 From: Edward Emelianov Date: Sat, 20 Sep 2025 23:26:46 +0300 Subject: [PATCH] continue --- F3:F303/MLX90640/i2c.c | 16 +- F3:F303/MLX90640/main.c | 2 + F3:F303/MLX90640/mlx90640.bin | Bin 7284 -> 19388 bytes F3:F303/MLX90640/mlx90640.c | 362 +++++++++++++++++++++++++ F3:F303/MLX90640/mlx90640.creator.user | 2 +- F3:F303/MLX90640/mlx90640.files | 5 + F3:F303/MLX90640/mlx90640.h | 65 +++++ F3:F303/MLX90640/mlx90640_regs.h | 90 ++++++ F3:F303/MLX90640/mlxproc.c | 104 +++++++ F3:F303/MLX90640/mlxproc.h | 41 +++ F3:F303/MLX90640/proto.c | 82 +++++- F3:F303/MLX90640/strfunc.c | 71 +++++ F3:F303/MLX90640/strfunc.h | 8 + F3:F303/MLX90640/version.inc | 4 +- 14 files changed, 841 insertions(+), 11 deletions(-) create mode 100644 F3:F303/MLX90640/mlx90640.c create mode 100644 F3:F303/MLX90640/mlx90640.h create mode 100644 F3:F303/MLX90640/mlx90640_regs.h create mode 100644 F3:F303/MLX90640/mlxproc.c create mode 100644 F3:F303/MLX90640/mlxproc.h diff --git a/F3:F303/MLX90640/i2c.c b/F3:F303/MLX90640/i2c.c index 788a88b..c0379c1 100644 --- a/F3:F303/MLX90640/i2c.c +++ b/F3:F303/MLX90640/i2c.c @@ -98,10 +98,12 @@ void i2c_setup(i2c_speed_t speed){ GPIOB->AFR[0] = (GPIOB->AFR[0] & ~(GPIO_AFRL_AFRL6 | GPIO_AFRL_AFRL7)) | AFRf(4, 6) | AFRf(4, 7); GPIOB->MODER = (GPIOB->MODER & ~(GPIO_MODER_MODER6 | GPIO_MODER_MODER7)) | - GPIO_MODER_MODER6_AF | GPIO_MODER_MODER7_AF; + MODER_AF(6) | MODER_AF(7); GPIOB->PUPDR = (GPIOB->PUPDR & !(GPIO_PUPDR_PUPDR6 | GPIO_PUPDR_PUPDR7)) | - GPIO_PUPDR6_PU | GPIO_PUPDR7_PU; // pullup (what if there's no external pullup?) - GPIOB->OTYPER |= GPIO_OTYPER_OT_6 | GPIO_OTYPER_OT_7; // both open-drain outputs + PUPD_PU(6) | PUPD_PU(7); // pullup (what if there's no external pullup?) + GPIOB->OTYPER |= OTYPER_OD(6) | OTYPER_OD(7); // both open-drain outputs + GPIOB->OSPEEDR = (GPIOB->OSPEEDR & OSPEED_CLR(6) & OSPEED_CLR(7)) | + OSPEED_HI(6) | OSPEED_HI(7); // I2C (default timing from sys clock - 72MHz) RCC->APB1ENR |= RCC_APB1ENR_I2C1EN; // clocking if(speed < I2C_SPEED_400K){ // slow cpeed - common mode @@ -257,12 +259,12 @@ static uint8_t *i2c_readb(uint8_t addr, uint16_t nbytes){ } uint8_t *i2c_read(uint8_t addr, uint16_t nbytes){ - if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0)) return 0; + if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0) || nbytes < 1 || nbytes > I2C_BUFSIZE*2) return 0; return i2c_readb(addr, nbytes); } static uint8_t dmard(uint8_t addr, uint16_t nbytes){ - if(nbytes < 1 || nbytes > I2C_BUFSIZE) return 0; + if(nbytes < 1 || nbytes > I2C_BUFSIZE*2) return 0; i2cDMAsetup(0, nbytes); goterr = 0; i2c_got_DMA = 0; @@ -275,14 +277,14 @@ static uint8_t dmard(uint8_t addr, uint16_t nbytes){ } 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 + if(nwords > I2C_BUFSIZE) return 0; // what if `nwords` is very large? we should check it if(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0)) return 0; return dmard(addr, nwords<<1); } // read 16bit register reg 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(isI2Cbusy() || !waitISRbit(I2C_ISR_BUSY, 0) || nwords < 1 || nwords > I2C_BUFSIZE) return 0; reg16 = __REV16(reg16); if(!i2c_writes(addr, (uint8_t*)®16, 2, 0)) return NULL; if(isdma){ diff --git a/F3:F303/MLX90640/main.c b/F3:F303/MLX90640/main.c index 5d4188b..05f1464 100644 --- a/F3:F303/MLX90640/main.c +++ b/F3:F303/MLX90640/main.c @@ -18,6 +18,7 @@ #include "hardware.h" #include "i2c.h" +#include "mlxproc.h" #include "proto.h" #include "strfunc.h" #include "usb_dev.h" @@ -64,5 +65,6 @@ int main(void){ USND(uhex2str(addr)); } } + mlx_process(); } } diff --git a/F3:F303/MLX90640/mlx90640.bin b/F3:F303/MLX90640/mlx90640.bin index 9149985a9237743bc2ee8b81a2b074271fc6401d..be149a0784531f9175500b3e3ce70baa55f14d6c 100755 GIT binary patch literal 19388 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 literal 7284 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 V8-Vi-ap2#41Mz>~Cwt0+{s$?0$V31D diff --git a/F3:F303/MLX90640/mlx90640.c b/F3:F303/MLX90640/mlx90640.c new file mode 100644 index 0000000..af9f235 --- /dev/null +++ b/F3:F303/MLX90640/mlx90640.c @@ -0,0 +1,362 @@ +/* + * This file is part of the mlx90640 project. + * Copyright 2025 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include + +#include "strfunc.h" + +#include "mlx90640.h" +#include "mlx90640_regs.h" + +// static const char *OK = "OK\n", *OKs = "OK ", *NOTEQ = "NOT equal!\n", *NOTEQi = "NOT equal on index "; + +// tolerance of floating point comparison +#define FP_TOLERANCE (1e-3) + +static fp_t mlx_image[MLX_PIXNO] = {0}; // ready image + +void dumpIma(const fp_t im[MLX_PIXNO]){ + for(int row = 0; row < MLX_H; ++row){ + for(int col = 0; col < MLX_W; ++col){ + printfl(*im++, 1); + USB_putbyte(' '); + } + newline(); + } +} + +#define GRAY_LEVELS (16) +// 16-level character set ordered by fill percentage (provided by user) +static const char* CHARS_16 = " .':;+*oxX#&%B$@"; +void drawIma(const fp_t im[MLX_PIXNO]){ + // Find min and max values + fp_t min_val = im[0], max_val = im[0]; + const fp_t *iptr = im; + for(int row = 0; row < MLX_H; ++row){ + for(int col = 0; col < MLX_W; ++col){ + fp_t cur = *iptr++; + if(cur < min_val) min_val = cur; + else if(cur > max_val) max_val = cur; + } + } + fp_t range = max_val - min_val; + if(fabsf(range) < 0.001) range = 1.; // solid fill -> blank + // Generate and print ASCII art + iptr = im; + newline(); + for(int row = 0; row < MLX_H; ++row){ + for(int col = 0; col < MLX_W; ++col){ + fp_t normalized = ((*iptr++) - min_val) / range; + // Map to character index (0 to 15) + int index = (int)(normalized * (GRAY_LEVELS-1) + 0.5); + // Ensure we stay within bounds + if(index < 0) index = 0; + else if(index > (GRAY_LEVELS-1)) index = (GRAY_LEVELS-1); + USB_putbyte(CHARS_16[index]); + } + newline(); + } + newline(); +} + +/***************************************************************************** + Calculate parameters & values + *****************************************************************************/ + +// fill OCC/ACC row/col arrays +static void occacc(int8_t *arr, int l, const uint16_t *regstart){ + int n = l >> 2; // divide by 4 + int8_t *p = arr; + for(int i = 0; i < n; ++i){ + register uint16_t val = *regstart++; + *p++ = (val & 0x000F) >> 0; + *p++ = (val & 0x00F0) >> 4; + *p++ = (val & 0x0F00) >> 8; + *p++ = (val ) >> 12; + } + for(int i = 0; i < l; ++i, ++arr){ + if(*arr > 0x07) *arr -= 0x10; + } +} + +// get all parameters' values from `dataarray`, return FALSE if something failed +int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *params){ + #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 + if(params->kVdd == 0) return FALSE; + i16 = val & 0xFF; + 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); + i16 = (val & 0x03FF); + if(i16 > 0x1FF) i16 -= 0x400; + params->KtPTAT = (fp_t)i16 / 8.; + params->vPTAT25 = (int16_t) CREG_VAL(REG_PTAT); + val = CREG_VAL(REG_APTATOCCS) >> 12; + params->alphaPTAT = val / 4. + 8.; + params->gainEE = (int16_t)CREG_VAL(REG_GAIN); + if(params->gainEE == 0) return FALSE; + int8_t occRow[MLX_H]; + int8_t occColumn[MLX_W]; + occacc(occRow, MLX_H, &CREG_VAL(REG_OCCROW14)); + occacc(occColumn, MLX_W, &CREG_VAL(REG_OCCCOL14)); + int8_t accRow[MLX_H]; + int8_t accColumn[MLX_W]; + occacc(accRow, MLX_H, &CREG_VAL(REG_ACCROW14)); + occacc(accColumn, MLX_W, &CREG_VAL(REG_ACCCOL14)); + val = CREG_VAL(REG_APTATOCCS); + // need to do multiplication instead of bitshift, so: + fp_t occRemScale = 1<<(val&0x0F), + occColumnScale = 1<<((val>>4)&0x0F), + occRowScale = 1<<((val>>8)&0x0F); + int16_t offavg = (int16_t) CREG_VAL(REG_OSAVG); + // even/odd column/row numbers are for starting from 1, so for starting from 0 we should swap them: + // even - for 1,3,5,...; odd - for 0,2,4,... etc + int8_t ktaavg[4]; + // 0 - odd row, odd col; 1 - odd row even col; 2 - even row, odd col; 3 - even row, even col + val = CREG_VAL(REG_KTAAVGODDCOL); + ktaavg[2] = (int8_t)(val & 0xFF); // odd col (1,3,..), even row (2,4,..) -> col 0,2,..; row 1,3,.. + ktaavg[0] = (int8_t)(val >> 8); // odd col, odd row -> col 0,2,..; row 0,2,.. + val = CREG_VAL(REG_KTAAVGEVENCOL); + ktaavg[3] = (int8_t)(val & 0xFF); // even col, even row -> col 1,3,..; row 1,3,.. + ktaavg[1] = (int8_t)(val >> 8); // even col, odd row -> col 1,3,..; row 0,2,.. + // 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; + fp_t mul = (fp_t)(1<alpha; + uint32_t diva32 = 1 << (val >> 12); + fp_t diva = (fp_t)(diva32); + diva *= (fp_t)(1<<30); // alpha_scale + fp_t accRowScale = 1<<((val & 0x0f00)>>8), + accColumnScale = 1<<((val & 0x00f0)>>4), + accRemScale = 1<<(val & 0x0f); + pu16 = (uint16_t*)&CREG_VAL(REG_OFFAK1); + fp_t *kta = params->kta, *offset = params->offset; + 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){ + // offset + register uint16_t rv = *pu16++; + i16 = (rv & 0xFC00) >> 10; + if(i16 > 0x1F) i16 -= 0x40; + *offset++ = (fp_t)offavg + (fp_t)occRow[row]*occRowScale + (fp_t)occColumn[col]*occColumnScale + (fp_t)i16*occRemScale; + // kta + i16 = (rv & 0xF) >> 1; + if(i16 > 0x03) i16 -= 0x08; + *kta++ = (ktaavg[idx|(col&1)] + i16*mul) / div; + // alpha + i16 = (rv & 0x3F0) >> 4; + if(i16 > 0x1F) i16 -= 0x40; + fp_t oft = (fp_t)a_r + accRow[row]*accRowScale + accColumn[col]*accColumnScale +i16*accRemScale; + *a++ = oft / diva; + *ol++ = (rv&1) ? 1 : 0; + } + } + scale1 = (CREG_VAL(REG_KTAVSCALE) >> 8) & 0xF; // kvscale + div = (fp_t)(1<> 12; if(i16 > 0x07) i16 -= 0x10; + ktaavg[0] = (int8_t)i16; // odd col, odd row + i16 = (val & 0xF0) >> 4; if(i16 > 0x07) i16 -= 0x10; + ktaavg[1] = (int8_t)i16; // even col, odd row + i16 = (val & 0x0F00) >> 8; if(i16 > 0x07) i16 -= 0x10; + 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; + val = CREG_VAL(REG_CPOFF); + params->cpOffset[0] = (val & 0x03ff); + if(params->cpOffset[0] > 0x1ff) params->cpOffset[0] -= 0x400; + params->cpOffset[1] = val >> 10; + if(params->cpOffset[1] > 0x1f) params->cpOffset[1] -= 0x40; + 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<> 8; + i16 = CREG_VAL(REG_KVTACP) >> 8; + if(i16 > 0x7F) i16 -= 0x100; + params->cpKv = (fp_t)i16 / (1< 0x7F) i16 -= 0x100; + params->tgc = (fp_t)i16; + 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<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); + i8 = (int8_t)(CREG_VAL(REG_KSTATGC) >> 8); + 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; + i8 = (int8_t)(val >> 8); + params->KsTo[1] = i8 / div; + val = CREG_VAL(REG_KSTO34); + i8 = (int8_t)(val & 0xFF); + params->KsTo[2] = i8 / div; + i8 = (int8_t)(val >> 8); + 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 + 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[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[1] = 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->resolEE = (uint8_t)((CREG_VAL(REG_KTAVSCALE) & 0x3000) >> 12); + // Don't forget to check 'outlier' flags for wide purpose + return TRUE; +#undef CREG_VAL +} + +/** + * @brief process_subpage - calculate all parameters from `dataarray` into `mlx_image` + * @param subpageno - number of subpage + * @param simpleimage == 0 - simplest, 1 - narrow range, 2 - extended range + */ +fp_t *process_subpage(MLX90640_params *params, const int16_t Frame[MLX_DMA_MAXLEN], int subpageno, int simpleimage){ +#define IMD_VAL(reg) Frame[IMD_IDX(reg)] + // 11.2.2.1. Resolution restore + // temporary: + fp_t resol_corr = (fp_t)(1<resolEE) / (1<<2); // calibrated resol/current resol + //fp_t resol_corr = (fp_t)(1<resolEE) / (1<<((reg_control_val[subpageno]&0x0C00)>>10)); // calibrated resol/current resol + //DBG("resolEE=%d, resolCur=%d", params->resolEE, ((reg_control_val[subpageno]&0x0C00)>>10)); + // 11.2.2.2. Supply voltage value calculation + int16_t i16a = (int16_t)IMD_VAL(REG_IVDDPIX); + fp_t dvdd = resol_corr*i16a - params->vdd25; + dvdd /= params->kVdd; + fp_t dV = i16a - params->vdd25; // for next step + 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); + fp_t dTa = (fp_t)i16a / (i16a * params->alphaPTAT + i16b); // vptatart + dTa *= (fp_t)(1<<18); + dTa = (dTa / (1. + params->KvPTAT*dV)) - params->vPTAT25; + dTa = dTa / params->KtPTAT; // without 25degr - Ta0 + // 11.2.2.4. Gain parameter calculation + i16a = (int16_t)IMD_VAL(REG_IGAIN); + fp_t Kgain = params->gainEE / (fp_t)i16a; + fp_t pixOS[2]; // pix_gain_CP_SPx + // 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; + for(int i = 0; i < 2; ++i){ // calc pixOS by gain + // 11.2.2.6.2 + pixOS[i] -= params->cpOffset[i]*(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){ + for(int col = 0, idx = rowidx; col < MLX_W; ++col, ++pixno, idx ^= 1){ + uint8_t sp = (row&1)^(col&1); // subpage of current pixel + if(sp != subpageno) continue; + // 11.2.2.5.1 + fp_t curval = (fp_t)(Frame[pixno]) * Kgain; // gain compensation + // 11.2.2.5.3 + curval -= params->offset[pixno] * (1. + params->kta[pixno]*dTa) * + (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[subpageno]; // 11.2.2.8. Normalizing to sensitivity + if(simpleimage == 0){ // 13.3. Using the device in ?image mode? + curval = IRcompens; + }else{ + // 11.2.2.8 + fp_t alphaComp = params->alpha[pixno] - params->tgc * params->cpAlpha[subpageno]; + 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)); + fp_t To4 = IRcompens / (alphaComp * (1. - 273.15*params->KsTo[1]) + Sx) + Tar; + curval = SQRT(SQRT(To4)) - 273.15; + if(simpleimage == 2){ // 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 + r = 3; ctx = params->CT[2]; + }else if(curval > params->CT[1]){ // range 3 + r = 2; ctx = params->CT[1]; + }else if(curval > params->CT[0]){ // range 2, default + 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; + curval = SQRT(SQRT(To4)) - 273.15; + } + } + } + mlx_image[pixno] = curval; + } + } + return mlx_image; +#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; +} +*/ diff --git a/F3:F303/MLX90640/mlx90640.creator.user b/F3:F303/MLX90640/mlx90640.creator.user index 19c5b4c..3b0ec84 100644 --- a/F3:F303/MLX90640/mlx90640.creator.user +++ b/F3:F303/MLX90640/mlx90640.creator.user @@ -1,6 +1,6 @@ - + EnvironmentId diff --git a/F3:F303/MLX90640/mlx90640.files b/F3:F303/MLX90640/mlx90640.files index 9c687cb..43efe39 100644 --- a/F3:F303/MLX90640/mlx90640.files +++ b/F3:F303/MLX90640/mlx90640.files @@ -3,6 +3,11 @@ hardware.h i2c.c i2c.h main.c +mlx90640.c +mlx90640.h +mlx90640_regs.h +mlxproc.c +mlxproc.h proto.c proto.h ringbuffer.c diff --git a/F3:F303/MLX90640/mlx90640.h b/F3:F303/MLX90640/mlx90640.h new file mode 100644 index 0000000..c689868 --- /dev/null +++ b/F3:F303/MLX90640/mlx90640.h @@ -0,0 +1,65 @@ +/* + * This file is part of the mlx90640 project. + * Copyright 2025 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once + +#include + +// floating type & sqrt operator +typedef float fp_t; +#define SQRT(x) sqrtf((x)) + +// amount of pixels +#define MLX_W (32) +#define MLX_H (24) +#define MLX_PIXNO (MLX_W*MLX_H) +// pixels + service data +#define MLX_PIXARRSZ (MLX_PIXNO + 64) + +typedef struct{ + int16_t kVdd; + int16_t vdd25; + fp_t KvPTAT; + fp_t KtPTAT; + int16_t vPTAT25; + fp_t alphaPTAT; + int16_t gainEE; + fp_t tgc; + fp_t cpKv; // K_V_CP + fp_t cpKta; // K_Ta_CP + fp_t KsTa; + fp_t CT[3]; // range borders (0, 160, 320 degrC?) + fp_t KsTo[4]; // K_S_To for each range * 273.15 + fp_t alphacorr[4]; // Alpha_corr for each range + fp_t alpha[MLX_PIXNO]; // full - with alpha_scale + fp_t offset[MLX_PIXNO]; + fp_t kta[MLX_PIXNO]; // full K_ta - with scale1&2 + fp_t kv[4]; // full - with scale; 0 - odd row, odd col; 1 - odd row even col; 2 - even row, odd col; 3 - even row, even col + fp_t cpAlpha[2]; // alpha_CP_subpage 0 and 1 + uint8_t resolEE; // resolution_EE + int16_t cpOffset[2]; + uint8_t outliers[MLX_PIXNO]; // outliers - bad pixels (if == 1) +} MLX90640_params; + +// full amount of IMAGE data + EXTRA data (counts of uint16_t!) +#define MLX_DMA_MAXLEN (834) + +int get_parameters(const uint16_t dataarray[MLX_DMA_MAXLEN], MLX90640_params *params); +fp_t *process_subpage(MLX90640_params *params, const int16_t Frame[MLX_DMA_MAXLEN], int subpageno, int simpleimage); +void dumpIma(const fp_t im[MLX_PIXNO]); +void drawIma(const fp_t im[MLX_PIXNO]); diff --git a/F3:F303/MLX90640/mlx90640_regs.h b/F3:F303/MLX90640/mlx90640_regs.h new file mode 100644 index 0000000..273c0ca --- /dev/null +++ b/F3:F303/MLX90640/mlx90640_regs.h @@ -0,0 +1,90 @@ +/* + * This file is part of the mlx90640 project. + * Copyright 2025 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once + +#define REG_STATUS 0x8000 +#define REG_STATUS_OVWEN (1<<4) +#define REG_STATUS_NEWDATA (1<<3) +#define REG_STATUS_SPNO (1<<0) +#define REG_STATUS_SPMASK (3<<0) +#define REG_CONTROL 0x800D +#define REG_CONTROL_CHESS (1<<12) +#define REG_CONTROL_RES16 (0<<10) +#define REG_CONTROL_RES17 (1<<10) +#define REG_CONTROL_RES18 (2<<10) +#define REG_CONTROL_RES19 (3<<10) +#define REG_CONTROL_RESMASK (3<<10) +#define REG_CONTROL_REFR_05HZ (0<<7) +#define REG_CONTROL_REFR_1HZ (1<<7) +#define REG_CONTROL_REFR_2HZ (2<<7) +#define REG_CONTROL_REFR_4HZ (3<<7) +#define REG_CONTROL_REFR_8HZ (4<<7) +#define REG_CONTROL_REFR_16HZ (5<<7) +#define REG_CONTROL_REFR_32HZ (6<<7) +#define REG_CONTROL_REFR_64HZ (7<<7) +#define REG_CONTROL_SUBP1 (1<<4) +#define REG_CONTROL_SUBPMASK (3<<4) +#define REG_CONTROL_SUBPSEL (1<<3) +#define REG_CONTROL_DATAHOLD (1<<2) +#define REG_CONTROL_SUBPEN (1<<0) + +// default value +#define REG_CONTROL_DEFAULT (REG_CONTROL_CHESS|REG_CONTROL_RES18|REG_CONTROL_REFR_2HZ|REG_CONTROL_SUBPEN) + +// calibration data start & len +#define REG_CALIDATA 0x2400 +#define REG_CALIDATA_LEN 832 + +#define REG_APTATOCCS 0x2410 +#define REG_OSAVG 0x2411 +#define REG_OCCROW14 0x2412 +#define REG_OCCCOL14 0x2418 +#define REG_SCALEACC 0x2420 +#define REG_SENSIVITY 0x2421 +#define REG_ACCROW14 0x2422 +#define REG_ACCCOL14 0x2428 +#define REG_GAIN 0x2430 +#define REG_PTAT 0x2431 +#define REG_KVTPTAT 0x2432 +#define REG_VDD 0x2433 +#define REG_KVAVG 0x2434 +#define REG_ILCHESS 0x2435 +#define REG_KTAAVGODDCOL 0x2436 +#define REG_KTAAVGEVENCOL 0x2437 +#define REG_KTAVSCALE 0x2438 +#define REG_ALPHA 0x2439 +#define REG_CPOFF 0x243A +#define REG_KVTACP 0x243B +#define REG_KSTATGC 0x243C +#define REG_KSTO12 0x243D +#define REG_KSTO34 0x243E +#define REG_CT34 0x243F +#define REG_OFFAK1 0x2440 +// index of register in array (from REG_CALIDATA) +#define CREG_IDX(addr) ((addr)-REG_CALIDATA) + +#define REG_IMAGEDATA 0x0400 +#define REG_ITAVBE 0x0700 +#define REG_ICPSP0 0x0708 +#define REG_IGAIN 0x070A +#define REG_ITAPTAT 0x0720 +#define REG_ICPSP1 0x0728 +#define REG_IVDDPIX 0x072A +// index of register in array (from REG_IMAGEDATA) +#define IMD_IDX(addr) ((addr)-REG_IMAGEDATA) diff --git a/F3:F303/MLX90640/mlxproc.c b/F3:F303/MLX90640/mlxproc.c new file mode 100644 index 0000000..0d3fdba --- /dev/null +++ b/F3:F303/MLX90640/mlxproc.c @@ -0,0 +1,104 @@ +/* + * This file is part of the mlx90640 project. + * Copyright 2025 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include + +#include "i2c.h" +#include "mlxproc.h" +#include "mlx90640_regs.h" + +// current state and state before `stop` called +static mlx_state_t MLX_state = MLX_NOTINIT, MLX_oldstate = MLX_NOTINIT; +static MLX90640_params p; +static int parsrdy = 0; +static fp_t *ready_image = NULL; // will be pointer to `mlx_image` after both subpages process +static uint8_t MLX_address = 0x33 << 1; +static int errctr = 0; // errors counter - cleared by mlx_continue + +// get current state +mlx_state_t mlx_state(){ return MLX_state; } +// set address +int mlx_setaddr(uint8_t addr){ + if(addr > 0x7f) return 0; + MLX_address = addr << 1; + return 1; +} +// temporary stop +void mlx_stop(){ + MLX_oldstate = MLX_state; + MLX_state = MLX_RELAX; +} +// continue processing +void mlx_continue(){ + errctr = 0; + switch(MLX_oldstate){ + case MLX_WAITSUBPAGE: + case MLX_READSUBPAGE: + MLX_state = MLX_WAITSUBPAGE; + break; + //case MLX_NOTINIT: + //case MLX_WAITPARAMS: + default: + MLX_state = MLX_NOTINIT; + break; + } +} + +void mlx_process(){ + //static int subpageno = 0; // wait for given subpage + switch(MLX_state){ + case MLX_NOTINIT: // start reading parameters + if(i2c_read_reg16(MLX_address, REG_CALIDATA, MLX_DMA_MAXLEN, 1)) + MLX_state = MLX_WAITPARAMS; + else ++errctr; + break; + case MLX_WAITPARAMS: // check DMA ends and calculate parameters + if(i2c_dma_haderr()) MLX_state = MLX_NOTINIT; + else{ + uint16_t len, *buf = i2c_dma_getbuf(&len); + if(buf){ + if(len != MLX_DMA_MAXLEN) MLX_state = MLX_NOTINIT; + else if(get_parameters(buf, &p)){ + MLX_state = MLX_WAITSUBPAGE; // fine! we could wait subpage + parsrdy = 1; + } + } + } + break; + case MLX_WAITSUBPAGE: // wait for subpage N ready + ; + break; + case MLX_READSUBPAGE: // wait ends of DMA read and calculate subpage + ; + break; + default: + return; + } + if(errctr > MLX_MAX_ERRORS) mlx_stop(); +} + +// get parameters - memcpy to user's +int mlx_getparams(MLX90640_params *pars){ + if(!pars || !parsrdy) return 0; + memcpy(pars, &p, sizeof(p)); + return 1; +} + +fp_t *mlx_getimage(){ + return ready_image; +} diff --git a/F3:F303/MLX90640/mlxproc.h b/F3:F303/MLX90640/mlxproc.h new file mode 100644 index 0000000..8cf9610 --- /dev/null +++ b/F3:F303/MLX90640/mlxproc.h @@ -0,0 +1,41 @@ +/* + * This file is part of the mlx90640 project. + * Copyright 2025 Edward V. Emelianov . + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#pragma once + +#include + +#include "mlx90640.h" + +// maximal errors number to stop processing +#define MLX_MAX_ERRORS (11) + +typedef enum{ + MLX_NOTINIT, // just start - need to get parameters + MLX_WAITPARAMS, // wait for parameters DMA reading + MLX_WAITSUBPAGE, // wait for subpage changing + MLX_READSUBPAGE, // wait ending of subpage DMA reading + MLX_RELAX // do nothing - pause +} mlx_state_t; + +int mlx_setaddr(uint8_t addr); +mlx_state_t mlx_state(); +void mlx_stop(); +void mlx_continue(); +void mlx_process(); +int mlx_getparams(MLX90640_params *pars); diff --git a/F3:F303/MLX90640/proto.c b/F3:F303/MLX90640/proto.c index 869969c..35d6543 100644 --- a/F3:F303/MLX90640/proto.c +++ b/F3:F303/MLX90640/proto.c @@ -20,6 +20,7 @@ #include #include "i2c.h" +#include "mlxproc.h" #include "strfunc.h" #include "usb_dev.h" #include "version.inc" @@ -35,6 +36,8 @@ const char *helpstring = "https://github.com/eddyem/stm32samples/tree/master/F3:F303/mlx90640 build#" BUILD_NUMBER " @ " BUILD_DATE "\n" " management of single IR bolometer MLX90640\n" "i0..3 - setup I2C with speed 10k, 100k, 400k, 1M or 2M (experimental!)\n" + "D - dump MLX parameters\n" + "G - get MLX state\n" "Ia addr - set device address\n" "Ir reg n - read n words from 16-bit register\n" "Iw words - send words (hex/dec/oct/bin) to I2C\n" @@ -67,6 +70,7 @@ TRUE_INLINE const char *chaddr(const char *buf){ const char *nxt = getnum(buf, &addr); if(nxt && nxt != buf){ if(addr > 0x7f) return ERR; + mlx_setaddr(addr); I2Caddress = (uint8_t) addr << 1; }else addr = I2Caddress >> 1; U("I2CADDR="); USND(uhex2str(addr)); @@ -99,7 +103,7 @@ TRUE_INLINE uint16_t readNnumbers(const char *buf){ uint16_t N = 0; while((nxt = getnum(buf, &D)) && nxt != buf && N < LOCBUFFSZ){ buf = nxt; - locBuffer[N++] = (uint8_t) D&0xff; + locBuffer[N++] = (uint16_t) D; } return N; } @@ -107,10 +111,80 @@ TRUE_INLINE uint16_t readNnumbers(const char *buf){ static const char *wrI2C(const char *buf){ uint16_t N = readNnumbers(buf); if(N == 0) return ERR; + for(int i = 0; i < N; ++i){ + U("byte "); U(u2str(i)); U(" :"); USND(uhex2str(locBuffer[i])); + } if(!i2c_write(I2Caddress, locBuffer, N)) return ERR; return OK; } +static void dumpfarr(float *arr){ + for(int row = 0; row < 24; ++row){ + for(int col = 0; col < 32; ++col){ + printfl(*arr++, 2); USB_putbyte(' '); + } + newline(); + } +} +// dump MLX parameters +TRUE_INLINE void dumpparams(){ + MLX90640_params params; + if(!mlx_getparams(¶ms)){ U(ERR); return; } + U("\nkVdd="); printi(params.kVdd); + U("\nvdd25="); printi(params.vdd25); + U("\nKvPTAT="); printfl(params.KvPTAT, 4); + U("\nKtPTAT="); printfl(params.KtPTAT, 4); + U("\nvPTAT25="); printi(params.vPTAT25); + U("\nalphaPTAT="); printfl(params.alphaPTAT, 2); + U("\ngainEE="); printi(params.gainEE); + U("\nPixel offset parameters:\n"); + float *offset = params.offset; + for(int row = 0; row < 24; ++row){ + for(int col = 0; col < 32; ++col){ + printfl(*offset++, 2); USB_putbyte(' '); + } + newline(); + } + U("K_talpha:\n"); + dumpfarr(params.kta); + U("Kv: "); + for(int i = 0; i < 4; ++i){ + printfl(params.kv[i], 2); USB_putbyte(' '); + } + U("\ncpOffset="); + printi(params.cpOffset[0]); U(", "); printi(params.cpOffset[1]); + U("\ncpKta="); printfl(params.cpKta, 2); + U("\ncpKv="); printfl(params.cpKv, 2); + U("\ntgc="); printfl(params.tgc, 2); + U("\ncpALpha="); printfl(params.cpAlpha[0], 2); + U(", "); printfl(params.cpAlpha[1], 2); + U("\nKsTa="); printfl(params.KsTa, 2); + U("\nAlpha:\n"); + dumpfarr(params.alpha); + U("\nCT3="); printfl(params.CT[1], 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); + U("\nalphacorr"); USB_putbyte('0'+i); USB_putbyte('='); + printfl(params.alphacorr[i], 2); + } + newline(); +} +// get MLX state +TRUE_INLINE void getst(){ + static const char *states[] = { + [MLX_NOTINIT] = "not init", + [MLX_WAITPARAMS] = "wait parameters DMA read", + [MLX_WAITSUBPAGE] = "wait subpage", + [MLX_READSUBPAGE] = "wait subpage DMA read", + [MLX_RELAX] = "do nothing" + }; + mlx_state_t s = mlx_state(); + U("MLXSTATE="); + USND(states[s]); +} + const char *parse_cmd(char *buf){ if(!buf || !*buf) return NULL; if(buf[1]){ @@ -139,6 +213,12 @@ const char *parse_cmd(char *buf){ } switch(*buf){ // "short" (one letter) commands case 'i': return setupI2C(NULL); // current settings + case 'D': + dumpparams(); + break; + case 'G': + getst(); + break; case 'T': U("T="); USND(u2str(Tms)); diff --git a/F3:F303/MLX90640/strfunc.c b/F3:F303/MLX90640/strfunc.c index e8bbc6a..51b14fb 100644 --- a/F3:F303/MLX90640/strfunc.c +++ b/F3:F303/MLX90640/strfunc.c @@ -16,6 +16,8 @@ * along with this program. If not, see . */ +#include // isnan / isinf + #include "strfunc.h" // hex line number for hexdumps @@ -304,3 +306,72 @@ const char *getint(const char *txt, int32_t *I){ *I = sign * (int32_t)U; return nxt; } + + +// be careful: if pow10 would be bigger you should change str[] size! +static const float pwr10[] = {1.f, 10.f, 100.f, 1000.f, 10000.f}; +static const float rounds[] = {0.5f, 0.05f, 0.005f, 0.0005f, 0.00005f}; +#define P10L (sizeof(pwr10)/sizeof(uint32_t) - 1) +char *float2str(float x, uint8_t prec){ + static char str[16] = {0}; // -117.5494E-36\0 - 14 symbols max! + if(prec > P10L) prec = P10L; + if(isnan(x)){ memcpy(str, "NAN", 4); return str;} + else{ + int i = isinf(x); + if(i){memcpy(str, "-INF", 5); if(i == 1) return str+1; else return str;} + } + char *s = str + 14; // go to end of buffer + uint8_t minus = 0; + if(x < 0){ + x = -x; + minus = 1; + } + int pow = 0; // xxxEpow + // now convert float to 1.xxxE3y + while(x > 1000.f){ + x /= 1000.f; + pow += 3; + } + if(x > 0.) while(x < 1.){ + x *= 1000.f; + pow -= 3; + } + // print Eyy + if(pow){ + uint8_t m = 0; + if(pow < 0){pow = -pow; m = 1;} + while(pow){ + register int p10 = pow/10; + *s-- = '0' + (pow - 10*p10); + pow = p10; + } + if(m) *s-- = '-'; + *s-- = 'E'; + } + // now our number is in [1, 1000] + uint32_t units; + if(prec){ + units = (uint32_t) x; + uint32_t decimals = (uint32_t)((x-units+rounds[prec])*pwr10[prec]); + // print decimals + while(prec){ + register int d10 = decimals / 10; + *s-- = '0' + (decimals - 10*d10); + decimals = d10; + --prec; + } + // decimal point + *s-- = '.'; + }else{ // without decimal part + units = (uint32_t) (x + 0.5); + } + // print main units + if(units == 0) *s-- = '0'; + else while(units){ + register uint32_t u10 = units / 10; + *s-- = '0' + (units - 10*u10); + units = u10; + } + if(minus) *s-- = '-'; + return s+1; +} diff --git a/F3:F303/MLX90640/strfunc.h b/F3:F303/MLX90640/strfunc.h index 6161bfd..fb7d830 100644 --- a/F3:F303/MLX90640/strfunc.h +++ b/F3:F303/MLX90640/strfunc.h @@ -21,6 +21,13 @@ #include #include +#include "usb_dev.h" + +#define printu(x) do{USB_sendstr(u2str(x));}while(0) +#define printi(x) do{USB_sendstr(i2str(x));}while(0) +#define printuhex(x) do{USB_sendstr(uhex2str(x));}while(0) +#define printfl(x,n) do{USB_sendstr(float2str(x, n));}while(0) + void u16s(uint16_t n, char *buf); void hexdump16(int (*sendfun)(const char *s), uint16_t *arr, uint16_t len); void hexdump(int (*sendfun)(const char *s), uint8_t *arr, uint16_t len); @@ -30,3 +37,4 @@ const char *uhex2str(uint32_t val); const char *getnum(const char *txt, uint32_t *N); char *omit_spaces(const char *buf); const char *getint(const char *txt, int32_t *I); +char *float2str(float x, uint8_t prec); diff --git a/F3:F303/MLX90640/version.inc b/F3:F303/MLX90640/version.inc index 650158e..48efeab 100644 --- a/F3:F303/MLX90640/version.inc +++ b/F3:F303/MLX90640/version.inc @@ -1,2 +1,2 @@ -#define BUILD_NUMBER "13" -#define BUILD_DATE "2025-09-19" +#define BUILD_NUMBER "22" +#define BUILD_DATE "2025-09-20"