From 5bb9980bdd5ce78b58b3224aff1041b3f0cc2579 Mon Sep 17 00:00:00 2001 From: Edward Emelianov Date: Sun, 18 Sep 2022 12:21:54 +0300 Subject: [PATCH] add MLX90640 --- MLX90640_OrangePi/Makefile | 53 +++ MLX90640_OrangePi/cmdlnopts.c | 86 ++++ MLX90640_OrangePi/cmdlnopts.h | 32 ++ MLX90640_OrangePi/main.c | 65 +++ MLX90640_OrangePi/mlx | Bin 0 -> 21664 bytes MLX90640_OrangePi/mlx90640.c | 441 +++++++++++++++++++++ MLX90640_OrangePi/mlx90640.h | 71 ++++ MLX90640_OrangePi/mlx90640_regs.h | 77 ++++ MLX90640_OrangePi/mxl90640OPi.cflags | 1 + MLX90640_OrangePi/mxl90640OPi.config | 4 + MLX90640_OrangePi/mxl90640OPi.creator | 1 + MLX90640_OrangePi/mxl90640OPi.creator.user | 174 ++++++++ MLX90640_OrangePi/mxl90640OPi.cxxflags | 1 + MLX90640_OrangePi/mxl90640OPi.files | 6 + MLX90640_OrangePi/mxl90640OPi.includes | 2 + 15 files changed, 1014 insertions(+) create mode 100644 MLX90640_OrangePi/Makefile create mode 100644 MLX90640_OrangePi/cmdlnopts.c create mode 100644 MLX90640_OrangePi/cmdlnopts.h create mode 100644 MLX90640_OrangePi/main.c create mode 100755 MLX90640_OrangePi/mlx create mode 100644 MLX90640_OrangePi/mlx90640.c create mode 100644 MLX90640_OrangePi/mlx90640.h create mode 100644 MLX90640_OrangePi/mlx90640_regs.h create mode 100644 MLX90640_OrangePi/mxl90640OPi.cflags create mode 100644 MLX90640_OrangePi/mxl90640OPi.config create mode 100644 MLX90640_OrangePi/mxl90640OPi.creator create mode 100644 MLX90640_OrangePi/mxl90640OPi.creator.user create mode 100644 MLX90640_OrangePi/mxl90640OPi.cxxflags create mode 100644 MLX90640_OrangePi/mxl90640OPi.files create mode 100644 MLX90640_OrangePi/mxl90640OPi.includes diff --git a/MLX90640_OrangePi/Makefile b/MLX90640_OrangePi/Makefile new file mode 100644 index 0000000..9ab7bd3 --- /dev/null +++ b/MLX90640_OrangePi/Makefile @@ -0,0 +1,53 @@ +# run `make DEF=...` to add extra defines +PROGRAM := mlx +LDFLAGS := -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--discard-all +LDFLAGS += -lwiringPi -lusefull_macros -L/usr/local/lib -lm -lcrypt +SRCS := $(wildcard *.c) +DEFINES := $(DEF) -D_GNU_SOURCE -D_XOPEN_SOURCE=1111 +OBJDIR := mk +CFLAGS += -O2 -Wall -Wextra -Wno-trampolines -std=gnu99 +OBJS := $(addprefix $(OBJDIR)/, $(SRCS:%.c=%.o)) +DEPS := $(OBJS:.o=.d) +TARGFILE := $(OBJDIR)/TARGET +CC = gcc +#TARGET := RELEASE + +ifeq ($(shell test -e $(TARGFILE) && echo -n yes),yes) + TARGET := $(file < $(TARGFILE)) +else + TARGET := RELEASE +endif + +release: $(PROGRAM) + +debug: CFLAGS += -DEBUG -Werror +debug: TARGET := DEBUG +debug: $(PROGRAM) + +$(TARGFILE): $(OBJDIR) + @echo -e "\t\tTARGET: $(TARGET)" + @echo "$(TARGET)" > $(TARGFILE) + +$(PROGRAM) : $(TARGFILE) $(OBJS) + @echo -e "\t\tLD $(PROGRAM)" + $(CC) $(OBJS) $(LDFLAGS) -o $(PROGRAM) + +$(OBJDIR): + @mkdir $(OBJDIR) + +ifneq ($(MAKECMDGOALS),clean) +-include $(DEPS) +endif + +$(OBJDIR)/%.o: %.c + @echo -e "\t\tCC $<" + $(CC) -MD -c $(LDFLAGS) $(CFLAGS) $(DEFINES) -o $@ $< + +clean: + @echo -e "\t\tCLEAN" + @rm -rf $(OBJDIR) 2>/dev/null || true + +xclean: clean + @rm -f $(PROGRAM) + +.PHONY: clean xclean diff --git a/MLX90640_OrangePi/cmdlnopts.c b/MLX90640_OrangePi/cmdlnopts.c new file mode 100644 index 0000000..07b8baf --- /dev/null +++ b/MLX90640_OrangePi/cmdlnopts.c @@ -0,0 +1,86 @@ +/* geany_encoding=koi8-r + * cmdlnopts.c - the only function that parse cmdln args and returns glob parameters + * + * Copyright 2013 Edward V. Emelianoff + * + * 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 2 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ +#include +#include +#include +#include +#include +#include "cmdlnopts.h" +#include "usefull_macros.h" + +/* + * here are global parameters initialisation + */ +static int help; +static glob_pars G; + +// default PID filename: +#define DEFAULT_PIDFILE "/tmp/testcmdlnopts.pid" +#define DEFAULT_I2C "/dev/i2c-3" + +// DEFAULTS +// default global parameters +static glob_pars const Gdefault = { + .device = DEFAULT_I2C, + .pidfile = DEFAULT_PIDFILE, + .logfile = NULL // don't save logs +}; + +/* + * Define command line options by filling structure: + * name has_arg flag val type argptr help +*/ +static myoption cmdlnopts[] = { +// common options + {"help", NO_ARGS, NULL, 'h', arg_int, APTR(&help), _("show this help")}, + {"logfile", NEED_ARG, NULL, 'l', arg_string, APTR(&G.logfile), _("file to save logs")}, + {"pidfile", NEED_ARG, NULL, 'P', arg_string, APTR(&G.pidfile), _("pidfile (default: " DEFAULT_PIDFILE ")")}, + {"device", NEED_ARG, NULL, 'd', arg_string, APTR(&G.device), _("I2C device path (default: " DEFAULT_I2C ")")}, + end_option +}; + +/** + * Parse command line options and return dynamically allocated structure + * to global parameters + * @param argc - copy of argc from main + * @param argv - copy of argv from main + * @return allocated structure with global parameters + */ +glob_pars *parse_args(int argc, char **argv){ + int i; + void *ptr; + ptr = memcpy(&G, &Gdefault, sizeof(G)); assert(ptr); + size_t hlen = 1024; + char helpstring[1024], *hptr = helpstring; + snprintf(hptr, hlen, "Usage: %%s [args]\n\n\tWhere args are:\n"); + // format of help: "Usage: progname [args]\n" + change_helpstring(helpstring); + // parse arguments + parseargs(&argc, &argv, cmdlnopts); + if(help) showhelp(-1, cmdlnopts); + if(argc > 0){ + WARNX("Ignoring arguments:"); + for (i = 0; i < argc; i++) + printf("\t%s\n", argv[i]); + } + return &G; +} + diff --git a/MLX90640_OrangePi/cmdlnopts.h b/MLX90640_OrangePi/cmdlnopts.h new file mode 100644 index 0000000..3d37d41 --- /dev/null +++ b/MLX90640_OrangePi/cmdlnopts.h @@ -0,0 +1,32 @@ +/* + * This file is part of the mxl90640wPi project. + * Copyright 2022 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 + +/* + * here are some typedef's for global data + */ +typedef struct{ + char *device; // I2C device + char *pidfile; // name of PID file + char *logfile; // logging to this file +} glob_pars; + + +glob_pars *parse_args(int argc, char **argv); + diff --git a/MLX90640_OrangePi/main.c b/MLX90640_OrangePi/main.c new file mode 100644 index 0000000..47a425d --- /dev/null +++ b/MLX90640_OrangePi/main.c @@ -0,0 +1,65 @@ +/* + * This file is part of the mxl90640wPi project. + * Copyright 2022 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 + +#include "cmdlnopts.h" +#include "mlx90640.h" + +#define DEVICE_ID 0x33 + +static glob_pars *GP = NULL; + +void signals(int sig){ + if(sig){ + signal(sig, SIG_IGN); + DBG("Get signal %d, quit.\n", sig); + } + LOGERR("Exit with status %d", sig); + if(GP && GP->pidfile) // remove unnesessary PID file + unlink(GP->pidfile); + exit(sig); +} + + + +int main (int argc, char **argv){ + initial_setup(); + char *self = strdup(argv[0]); + GP = parse_args(argc, argv); + check4running(self, GP->pidfile); + FREE(self); + if(GP->logfile) OPENLOG(GP->logfile, LOGLEVEL_ANY, 1); + + if(!mlx90640_init(GP->device, DEVICE_ID)) ERR("Can't open device"); + double *ima = NULL; + if(!mlx90640_take_image(0, &ima) || !ima) ERRX("Can't take image"); + // mlx90640_dump_parameters(); + double *ptr = ima; + green("Image:\n"); + for(int row = 0; row < MLX_H; ++row){ + for(int col = 0; col < MLX_W; ++col){ + printf("%5.1f ", *ptr++); + } + printf("\n"); + } + return 0; +} diff --git a/MLX90640_OrangePi/mlx b/MLX90640_OrangePi/mlx new file mode 100755 index 0000000000000000000000000000000000000000..fe423f413e8a49b5d83b1f6d202f3e18ace47429 GIT binary patch literal 21664 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. + * + * 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 +#include +#include +#include +#include +#include +#include + +#include "mlx90640.h" +#include "mlx90640_regs.h" + + +static int I2Cfd = -1; +static uint8_t lastaddr = 0; +static MLX90640_params params; + +static uint16_t dataarray[MLX_DMA_MAXLEN]; // array for raw data from sensor +static double mlx_image[MLX_PIXNO]; // ready image + +#define CREG_VAL(reg) dataarray[CREG_IDX(reg)] +#define IMD_VAL(reg) dataarray[IMD_IDX(reg)] + +// reg_control values for subpage #0 and #1 +static const uint16_t reg_control_val[2] = { + REG_CONTROL_CHESS | REG_CONTROL_RES18 | REG_CONTROL_REFR_2HZ | REG_CONTROL_SUBPSEL | REG_CONTROL_DATAHOLD | REG_CONTROL_SUBPEN, + REG_CONTROL_CHESS | REG_CONTROL_RES18 | REG_CONTROL_REFR_2HZ | REG_CONTROL_SUBP1 | REG_CONTROL_SUBPSEL | REG_CONTROL_DATAHOLD | REG_CONTROL_SUBPEN +}; + + +// read register value +static int read_reg(uint16_t regaddr, uint16_t *data){ + if(I2Cfd < 1) return FALSE; + struct i2c_msg m[2]; + struct i2c_rdwr_ioctl_data x = {.msgs = m, .nmsgs = 2}; + m[0].addr = lastaddr; m[1].addr = lastaddr; + m[0].flags = 0; + m[1].flags = I2C_M_RD; + m[0].len = 2; m[1].len = 2; + uint8_t a[2], d[2] = {0}; + a[0] = regaddr >> 8; + a[1] = regaddr & 0xff; + m[0].buf = a; m[1].buf = d; + if(ioctl(I2Cfd, I2C_RDWR, &x) < 0) return FALSE; + if(data) *data = (uint16_t)((d[0] << 8) | (d[1])); + return TRUE; +} + +// blocking read N uint16_t values starting from `reg` +// @param reg - register to read +// @param N (io) - amount of bytes to read / bytes read +// @return `dataarray` or NULL if failed +static uint16_t *read_data(uint16_t reg, uint16_t *N){ + if(I2Cfd < 1 || !N || *N < 1) return NULL; + uint16_t n = *N; + if(n < 1 || n > MLX_DMA_MAXLEN) return NULL; + uint16_t i, *data = dataarray; + for(i = 0; i < n; ++i){ + if(!read_reg(reg++, data++)){ + DBG("can't read"); + break; + } + } + *N = i; + return dataarray; +} + +// write register value +static int write_reg(uint16_t regaddr, uint16_t data){ + if(I2Cfd < 1) return FALSE; + union i2c_smbus_data d; + d.block[0] = 3; + d.block[1] = regaddr & 0xff; + d.block[2] = data >> 8; + d.block[3] = data & 0xff; + struct i2c_smbus_ioctl_data args; + args.read_write = I2C_SMBUS_WRITE; + args.command = regaddr >> 8; + args.size = I2C_SMBUS_I2C_BLOCK_DATA; + args.data = &d; + if(ioctl(I2Cfd, I2C_SMBUS, &args) < 0) return FALSE; + return TRUE; +} + +int mlx90640_set_slave_address(uint8_t addr){ + if(I2Cfd < 1) return FALSE; + if(ioctl (I2Cfd, I2C_SLAVE, addr) < 0) return FALSE; + lastaddr = addr; + return TRUE; +} + +int mlx90640_init(const char *dev, uint8_t ID){ + if(I2Cfd > 0) close(I2Cfd); + I2Cfd = open(dev, O_RDWR); + if(I2Cfd < 1) return FALSE; + if(!mlx90640_set_slave_address(ID)) return FALSE; + if(!read_reg(0, NULL)) return FALSE; + return TRUE; +} + +static void dumpIma(double *im){ + for(int row = 0; row < MLX_H; ++row){ + for(int col = 0; col < MLX_W; ++col){ + printf("%5.1f ", *im++); + } + printf("\n"); + } +} + +void mlx90640_dump_parameters(){ + printf("kVdd=%d\nvdd25=%d\nKvPTAT=%g\nKtPTAT=%g\nvPTAT25=%d\n", params.kVdd, params.vdd25, params.KvPTAT, params.KtPTAT, params.vPTAT25); + printf("alphaPTAT=%g\ngainEE=%d\ntgc=%g\ncpKv=%g\ncpKta=%g\n", params.alphaPTAT, params.gainEE, params.tgc, params.cpKta, params.cpKta); + printf("KsTa=%g\nCT[]={%g, %g, %g}\n", params.KsTa, params.CT[0], params.CT[1], params.CT[2]); + printf("ksTo[]={"); for(int i = 0; i < 4; ++i) printf("%s%g", (i) ? ", " : "", params.ksTo[i]); printf("}\n"); + printf("alphacorr[]={"); for(int i = 0; i < 4; ++i) printf("%s%g", (i) ? ", " : "", params.alphacorr[i]); printf("}\n"); + printf("alpha[]=\n"); dumpIma(params.alpha); + printf("offset[]=\n"); dumpIma(params.offset); + printf("kta[]=\n"); dumpIma(params.kta); + printf("kv[]={"); for(int i = 0; i < 4; ++i) printf("%s%g", (i) ? ", " : "", params.kv[i]); printf("}\n"); + printf("cpAlpha[]={%g, %g}\n", params.cpAlpha[0], params.cpAlpha[1]); + printf("cpOffset[]={%d, %d}\n", params.cpOffset[0], params.cpOffset[1]); +} + +/***************************************************************************** + Calculate parameters & values + *****************************************************************************/ + +// fill OCC/ACC row/col arrays +static void occacc(int8_t *arr, int l, 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 +static int get_parameters(){ + 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 = (double)i16 / (1<<12); + i16 = (val & 0x03FF); + if(i16 > 0x1FF) i16 -= 0x400; + params.KtPTAT = (double)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: + double 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 chould 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, even row -> 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; + double mul = (double)(1<> 12); + diva *= (double)(1<<30); // alpha_scale + double accRowScale = 1<<((val & 0x0f00)>>8), + accColumnScale = 1<<((val & 0x00f0)>>4), + accRemScale = 1<<(val & 0x0f); + pu16 = &CREG_VAL(REG_OFFAK1); + double *kta = params.kta, *offset = params.offset; + 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++ = (double)offavg + (double)occRow[row]*occRowScale + (double)occColumn[col]*occColumnScale + (double)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; + double oft = (double)a_r + accRow[row]*accRowScale + accColumn[col]*accColumnScale +i16*accRemScale; + *a++ = oft / diva; + } + } + scale1 = (CREG_VAL(REG_KTAVSCALE) >> 8) & 0xF; // kvscale + div = (double)(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 = (double)i8 / (1<> 8; + i16 = CREG_VAL(REG_KVTACP) >> 8; + if(i16 > 0x7F) i16 -= 0x100; + params.cpKv = (double)i16 / (1< 0x7F) i16 -= 0x100; + params.tgc = (double)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 = (double)(1<> 8); + params.KsTa = (double)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] = 273.15 * i8 / div; + i8 = (int8_t)(val >> 8); + params.ksTo[1] = 273.15 * i8 / div; + val = CREG_VAL(REG_KSTO34); + i8 = (int8_t)(val & 0xFF); + params.ksTo[2] = 273.15 * i8 / div; + i8 = (int8_t)(val >> 8); + params.ksTo[3] = 273.15 * i8 / div; + 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 + params.alphacorr[0] = 1./(1. + params.ksTo[0] * 40.); + params.alphacorr[1] = 1.; + params.alphacorr[2] = (1. + params.ksTo[2] * params.CT[1]); + params.alphacorr[3] = (1. + params.ksTo[3] * (params.CT[2] - params.CT[1])) * params.alphacorr[2]; + // Don't forget to check 'outlier' flags for wide purpose + return TRUE; +} + +/** + * @brief process_subpage - calculate all parameters from `dataarray` into `mlx_image` + */ +static void process_subpage(int subpageno, int simpleimage){ + DBG("process_subpage(%d)", subpageno); + int16_t i16a = (int16_t)IMD_VAL(REG_IVDDPIX); + double dvdd = i16a - params.vdd25; + dvdd = dvdd / params.kVdd; + DBG("Vd=%g", dvdd+3.3); + i16a = (int16_t)IMD_VAL(REG_ITAPTAT); + int16_t i16b = (int16_t)IMD_VAL(REG_ITAVBE); + double dTa = (double)i16a / (i16a * params.alphaPTAT + i16b); // vptatart + dTa *= (double)(1<<18); + dTa = (dTa / (1 + params.KvPTAT*dvdd) - params.vPTAT25); + dTa = dTa / params.KtPTAT; // without 25degr - Ta0 + DBG("Ta=%g", dTa+25.); + i16a = (int16_t)IMD_VAL(REG_IGAIN); + double Kgain = params.gainEE / (double)i16a; + DBG("Kgain=%g", Kgain); + // now make first approximation to image + uint16_t pixno = 0; // current pixel number - for indexing in parameters etc + for(int row = 0; row < MLX_H; ++row){ + int idx = (row&1)<<1; // index for params.kv + for(int col = 0; col < MLX_W; ++col, ++pixno){ + uint8_t sp = (row&1)^(col&1); // subpage of current pixel + if(sp != subpageno) continue; + double curval = (double)((int16_t)dataarray[pixno]) * Kgain; // gain compensation + curval -= params.offset[pixno] * (1. + params.kta[pixno]*dTa) * + (1. + params.kv[idx|(col&1)]*dvdd); // add offset + double IRcompens = curval; // IR_compensated + if(simpleimage){ + curval -= params.cpOffset[subpageno] * (1. - params.cpKta * dTa) * + (1. + params.cpKv * dvdd); // CP + curval = IRcompens - params.tgc * curval; // IR gradient compens + }else{ + double alphaComp = params.alpha[pixno] - params.tgc * params.cpAlpha[subpageno]; + alphaComp /= 1. + params.KsTa * dTa; + // calculate To for basic range + double Tar = dTa + 273.15 + 25.; + Tar = Tar*Tar*Tar*Tar; + double ac3 = alphaComp*alphaComp*alphaComp; + double Sx = ac3*IRcompens + alphaComp*ac3*Tar; + Sx = params.KsTa * sqrt(sqrt(Sx)); + double To = IRcompens / (alphaComp * (1. - params.ksTo[1]) + Sx) + Tar; + curval = sqrt(sqrt(To)) - 273.15; // To + // TODO: extended + } + mlx_image[pixno] = curval; + } + } +} + +static int errctr = 0; +static double Tlast = 0.; +#define chstate() do{errctr = 0; Tlast = dtime(); }while(0) +#define chkerr() do{if(++errctr > MLX_MAXERR_COUNT){ DBG("-> M_ERROR"); return FALSE;}else continue;}while(0) +#define chktmout() do{if(dtime() - Tlast > MLX_TIMEOUT){ DBG("Timeout! -> M_ERROR"); return FALSE;}else continue;}while(0) + +static int process_readconf(){ + chstate(); + while(1){ + if(get_parameters()) return TRUE; + else chkerr(); + } +} +static int process_firstrun(){ + uint16_t reg, N; + chstate(); + while(1){ + if(write_reg(REG_CONTROL, reg_control_val[0]) + && read_reg(REG_CONTROL, ®)){ + DBG("REG_CTRL=0x%04x", reg); + if(read_reg(REG_STATUS, ®)) DBG("REG_STATUS=0x%04x", reg); + N = REG_CALIDATA_LEN; + if(read_data(REG_CALIDATA, &N)){ + DBG("-> M_READCONF"); + return process_readconf(); + }else chkerr(); + }else chkerr(); + } + return FALSE; +} +// start image acquiring for next subpage +static int process_startima(int subpageno){ + chstate(); + DBG("startima()"); + uint16_t reg, N; + while(1){ + // write `overwrite` flag twice + if(!write_reg(REG_CONTROL, reg_control_val[subpageno]) || + !write_reg(REG_STATUS, REG_STATUS_OVWEN) || + !write_reg(REG_STATUS, REG_STATUS_OVWEN)) chkerr(); + if(read_reg(REG_STATUS, ®)){ + if(reg & REG_STATUS_NEWDATA){ + if(subpageno != (reg & REG_STATUS_SPNO)){ + DBG("wrong subpage number -> M_ERROR"); + return FALSE; + }else{ // all OK, run image reading + chstate(); + write_reg(REG_STATUS, 0); // clear rdy bit + N = MLX_PIXARRSZ; + if(read_data(REG_IMAGEDATA, &N)){ + DBG("-> M_READOUT, N=%u", N); + return TRUE; + }else chkerr(); + } + }else chktmout(); + }else chkerr(); + } + return FALSE; +} + +void mlx90640_restart(){ + memset(¶ms, 0, sizeof(params)); + process_firstrun(); +} + +// if state of MLX allows, make an image else return error +// @param simple ==1 for simplest image processing (without T calibration) +int mlx90640_take_image(uint8_t simple, double **image){ + if(I2Cfd < 1) return FALSE; + if(params.kVdd == 0){ // no parameters -> make first run + if(!process_firstrun()) return FALSE; + } + //subpageno = 0; + DBG("-> M_STARTIMA"); + for(int sp = 0; sp < 2; ++sp){ + if(!process_startima(sp)) return FALSE; // get first subpage + process_subpage(sp, simple); + } + if(image) *image = mlx_image; + return TRUE; +} + + diff --git a/MLX90640_OrangePi/mlx90640.h b/MLX90640_OrangePi/mlx90640.h new file mode 100644 index 0000000..f8daa99 --- /dev/null +++ b/MLX90640_OrangePi/mlx90640.h @@ -0,0 +1,71 @@ +/* + * This file is part of the mxl90640wPi project. + * Copyright 2022 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 + +// timeout for reading operations, s +#define MLX_TIMEOUT 5. +// counter of errors, when > max -> M_ERROR +#define MLX_MAXERR_COUNT 10 +// wait after power off, s +#define MLX_POWOFF_WAIT 0.5 +// wait after power on, s +#define MLX_POWON_WAIT 2. + +// 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; + double KvPTAT; + double KtPTAT; + int16_t vPTAT25; + double alphaPTAT; + int16_t gainEE; + double tgc; + double cpKv; // K_V_CP + double cpKta; // K_Ta_CP + double KsTa; + double CT[3]; // range borders (0, 160, 320 degrC?) + double ksTo[4]; // K_S_To for each range * 273.15 + double alphacorr[4]; // Alpha_corr for each range + double alpha[MLX_PIXNO]; // full - with alpha_scale + double offset[MLX_PIXNO]; + double kta[MLX_PIXNO]; // full K_ta - with scale1&2 + double 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 + double cpAlpha[2]; // alpha_CP_subpage 0 and 1 + int16_t cpOffset[2]; +} MLX90640_params; + +// default I2C address +#define MLX_DEFAULT_ADDR (0x33) +// max datalength by one read (in 16-bit values) +#define MLX_DMA_MAXLEN (832) + +void mlx90640_dump_parameters(); +int mlx90640_init(const char *dev, uint8_t ID); +int mlx90640_set_slave_address(uint8_t addr); +int mlx90640_take_image(uint8_t simple, double **image); +void mlx90640_restart(); diff --git a/MLX90640_OrangePi/mlx90640_regs.h b/MLX90640_OrangePi/mlx90640_regs.h new file mode 100644 index 0000000..71d1ad9 --- /dev/null +++ b/MLX90640_OrangePi/mlx90640_regs.h @@ -0,0 +1,77 @@ +/* + * This file is part of the mxl90640wPi project. + * Copyright 2022 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_RES18 (2<<10) +#define REG_CONTROL_RESMASK (3<<10) +#define REG_CONTROL_REFR_2HZ (2<<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) + +// calibration data start & len +#define REG_CALIDATA 0x2410 +#define REG_CALIDATA_LEN 816 + +#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 +// indeg of register in array (from REG_IMAGEDATA) +#define IMD_IDX(addr) ((addr)-REG_IMAGEDATA) diff --git a/MLX90640_OrangePi/mxl90640OPi.cflags b/MLX90640_OrangePi/mxl90640OPi.cflags new file mode 100644 index 0000000..68d5165 --- /dev/null +++ b/MLX90640_OrangePi/mxl90640OPi.cflags @@ -0,0 +1 @@ +-std=c17 \ No newline at end of file diff --git a/MLX90640_OrangePi/mxl90640OPi.config b/MLX90640_OrangePi/mxl90640OPi.config new file mode 100644 index 0000000..e93f8a9 --- /dev/null +++ b/MLX90640_OrangePi/mxl90640OPi.config @@ -0,0 +1,4 @@ +#define GNU_SOURCE 1 +#define _XOPEN_SOURCE 1111 +#define EBUG + diff --git a/MLX90640_OrangePi/mxl90640OPi.creator b/MLX90640_OrangePi/mxl90640OPi.creator new file mode 100644 index 0000000..e94cbbd --- /dev/null +++ b/MLX90640_OrangePi/mxl90640OPi.creator @@ -0,0 +1 @@ +[General] diff --git a/MLX90640_OrangePi/mxl90640OPi.creator.user b/MLX90640_OrangePi/mxl90640OPi.creator.user new file mode 100644 index 0000000..88d3f4b --- /dev/null +++ b/MLX90640_OrangePi/mxl90640OPi.creator.user @@ -0,0 +1,174 @@ + + + + + + EnvironmentId + {7bd84e39-ca37-46d3-be9d-99ebea85bc0d} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + KOI8-R + false + 4 + false + 80 + true + true + 1 + false + true + false + 0 + true + true + 0 + 8 + true + false + 1 + true + false + true + *.md, *.MD, Makefile + false + true + + + + ProjectExplorer.Project.PluginSettings + + + true + false + true + true + true + true + + + 0 + true + + true + Builtin.BuildSystem + + true + true + Builtin.DefaultTidyAndClazy + 2 + + + + true + + + + + ProjectExplorer.Project.Target.0 + + Desktop + Desktop + Desktop + {65a14f9e-e008-4c1b-89df-4eaa4774b6e3} + 0 + 0 + 0 + + /tmp/1/home/eddy/MLX90640_wiringPi + + + + all + + true + GenericProjectManager.GenericMakeStep + + 1 + Сборка + Сборка + ProjectExplorer.BuildSteps.Build + + + + + clean + + true + GenericProjectManager.GenericMakeStep + + 1 + Очистка + Очистка + ProjectExplorer.BuildSteps.Clean + + 2 + false + + false + + По умолчанию + GenericProjectManager.GenericBuildConfiguration + + 1 + + + 0 + Развёртывание + Развёртывание + ProjectExplorer.BuildSteps.Deploy + + 1 + + false + ProjectExplorer.DefaultDeployConfiguration + + 1 + + + 2 + + ProjectExplorer.CustomExecutableRunConfiguration + + false + true + false + true + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + + diff --git a/MLX90640_OrangePi/mxl90640OPi.cxxflags b/MLX90640_OrangePi/mxl90640OPi.cxxflags new file mode 100644 index 0000000..6435dfc --- /dev/null +++ b/MLX90640_OrangePi/mxl90640OPi.cxxflags @@ -0,0 +1 @@ +-std=c++17 \ No newline at end of file diff --git a/MLX90640_OrangePi/mxl90640OPi.files b/MLX90640_OrangePi/mxl90640OPi.files new file mode 100644 index 0000000..d70565e --- /dev/null +++ b/MLX90640_OrangePi/mxl90640OPi.files @@ -0,0 +1,6 @@ +cmdlnopts.c +cmdlnopts.h +main.c +mlx90640.c +mlx90640.h +mlx90640_regs.h diff --git a/MLX90640_OrangePi/mxl90640OPi.includes b/MLX90640_OrangePi/mxl90640OPi.includes new file mode 100644 index 0000000..774cf29 --- /dev/null +++ b/MLX90640_OrangePi/mxl90640OPi.includes @@ -0,0 +1,2 @@ +/usr/local/include +.