diff --git a/boards/OPENMV_RT1060/manifest.py b/boards/OPENMV_RT1060/manifest.py index b6bc29ed90..3acdb86022 100644 --- a/boards/OPENMV_RT1060/manifest.py +++ b/boards/OPENMV_RT1060/manifest.py @@ -25,10 +25,9 @@ require("ntptime") require("webrepl") freeze ("$(OMV_LIB_DIR)/", "rpc.py") -freeze ("$(OMV_LIB_DIR)/", "rtsp.py") +# freeze ("$(OMV_LIB_DIR)/", "rtsp.py") # Use device/rtsp.py instead freeze ("$(OMV_LIB_DIR)/", "mqtt.py") freeze ("$(OMV_LIB_DIR)/", "requests.py") -require("microdot-lib") # Utils require("time") @@ -41,5 +40,12 @@ require("protocol", library="openmv-lib") include("$(MPY_DIR)/extmod/asyncio") +# GroupGets device stack. +GROUPGETS_DIR = "../../../groupgets" +freeze(GROUPGETS_DIR + "/frameworks/microdot/src", "microdot") +freeze(GROUPGETS_DIR, "device") +freeze(GROUPGETS_DIR + "/device", "main.py") # Top-level boot entry +freeze(GROUPGETS_DIR, "static") + # Boot script freeze ("$(OMV_LIB_DIR)/", "_boot.py") diff --git a/common/omv_csi.h b/common/omv_csi.h index 9a9b9073f0..f9608b43c6 100644 --- a/common/omv_csi.h +++ b/common/omv_csi.h @@ -200,47 +200,153 @@ typedef enum { } omv_csi_flags_t; typedef enum { - OMV_CSI_IOCTL_SET_READOUT_WINDOW = 0x00 | OMV_CSI_FLAG_IOCTL_ABORT, - OMV_CSI_IOCTL_GET_READOUT_WINDOW = 0x01, - OMV_CSI_IOCTL_SET_TRIGGERED_MODE = 0x02, - OMV_CSI_IOCTL_GET_TRIGGERED_MODE = 0x03, - OMV_CSI_IOCTL_SET_FOV_WIDE = 0x04, - OMV_CSI_IOCTL_GET_FOV_WIDE = 0x05, - OMV_CSI_IOCTL_TRIGGER_AUTO_FOCUS = 0x06, - OMV_CSI_IOCTL_PAUSE_AUTO_FOCUS = 0x07, - OMV_CSI_IOCTL_RESET_AUTO_FOCUS = 0x08, - OMV_CSI_IOCTL_WAIT_ON_AUTO_FOCUS = 0x09, - OMV_CSI_IOCTL_SET_NIGHT_MODE = 0x0A, - OMV_CSI_IOCTL_GET_NIGHT_MODE = 0x0B, - OMV_CSI_IOCTL_LEPTON_GET_WIDTH = 0x0C, - OMV_CSI_IOCTL_LEPTON_GET_HEIGHT = 0x0D, - OMV_CSI_IOCTL_LEPTON_GET_RADIOMETRY = 0x0E, - OMV_CSI_IOCTL_LEPTON_GET_REFRESH = 0x0F, - OMV_CSI_IOCTL_LEPTON_GET_RESOLUTION = 0x10, - OMV_CSI_IOCTL_LEPTON_RUN_COMMAND = 0x11, - OMV_CSI_IOCTL_LEPTON_SET_ATTRIBUTE = 0x12, - OMV_CSI_IOCTL_LEPTON_GET_ATTRIBUTE = 0x13, - OMV_CSI_IOCTL_LEPTON_GET_FPA_TEMP = 0x14, - OMV_CSI_IOCTL_LEPTON_GET_AUX_TEMP = 0x15, - OMV_CSI_IOCTL_LEPTON_SET_MODE = 0x16 | OMV_CSI_FLAG_IOCTL_ABORT, - OMV_CSI_IOCTL_LEPTON_GET_MODE = 0x17, - OMV_CSI_IOCTL_LEPTON_SET_RANGE = 0x18 | OMV_CSI_FLAG_IOCTL_ABORT, - OMV_CSI_IOCTL_LEPTON_GET_RANGE = 0x19, - OMV_CSI_IOCTL_HIMAX_MD_ENABLE = 0x1A, - OMV_CSI_IOCTL_HIMAX_MD_CLEAR = 0x1B, - OMV_CSI_IOCTL_HIMAX_MD_WINDOW = 0x1C | OMV_CSI_FLAG_IOCTL_ABORT, - OMV_CSI_IOCTL_HIMAX_MD_THRESHOLD = 0x1D, - OMV_CSI_IOCTL_HIMAX_OSC_ENABLE = 0x1E | OMV_CSI_FLAG_IOCTL_ABORT, - OMV_CSI_IOCTL_GET_RGB_STATS = 0x1F, - OMV_CSI_IOCTL_GENX320_SET_BIASES = 0x20, - OMV_CSI_IOCTL_GENX320_SET_BIAS = 0x21, - OMV_CSI_IOCTL_GENX320_SET_AFK = 0x22, - OMV_CSI_IOCTL_GENX320_SET_MODE = 0x23, - OMV_CSI_IOCTL_GENX320_READ_EVENTS = 0x24, - OMV_CSI_IOCTL_GENX320_CALIBRATE = 0x25, - OMV_CSI_IOCTL_GENX320_SET_STC = 0x26, - OMV_CSI_IOCTL_GENX320_READ_EVENTS_RAW = 0x27, - OMV_CSI_IOCTL_UPDATE_AGC_AEC = 0x7F + OMV_CSI_IOCTL_SET_READOUT_WINDOW = 0x00 | OMV_CSI_FLAG_IOCTL_ABORT, + OMV_CSI_IOCTL_GET_READOUT_WINDOW = 0x01, + OMV_CSI_IOCTL_SET_TRIGGERED_MODE = 0x02, + OMV_CSI_IOCTL_GET_TRIGGERED_MODE = 0x03, + OMV_CSI_IOCTL_SET_FOV_WIDE = 0x04, + OMV_CSI_IOCTL_GET_FOV_WIDE = 0x05, + OMV_CSI_IOCTL_TRIGGER_AUTO_FOCUS = 0x06, + OMV_CSI_IOCTL_PAUSE_AUTO_FOCUS = 0x07, + OMV_CSI_IOCTL_RESET_AUTO_FOCUS = 0x08, + OMV_CSI_IOCTL_WAIT_ON_AUTO_FOCUS = 0x09, + OMV_CSI_IOCTL_SET_NIGHT_MODE = 0x0A, + OMV_CSI_IOCTL_GET_NIGHT_MODE = 0x0B, + OMV_CSI_IOCTL_LEPTON_GET_WIDTH = 0x0C, + OMV_CSI_IOCTL_LEPTON_GET_HEIGHT = 0x0D, + OMV_CSI_IOCTL_LEPTON_GET_RADIOMETRY = 0x0E, + OMV_CSI_IOCTL_LEPTON_GET_REFRESH = 0x0F, + OMV_CSI_IOCTL_LEPTON_GET_RESOLUTION = 0x10, + OMV_CSI_IOCTL_LEPTON_RUN_COMMAND = 0x11, + OMV_CSI_IOCTL_LEPTON_SET_ATTRIBUTE = 0x12, + OMV_CSI_IOCTL_LEPTON_GET_ATTRIBUTE = 0x13, + OMV_CSI_IOCTL_LEPTON_GET_FPA_TEMP = 0x14, + OMV_CSI_IOCTL_LEPTON_GET_AUX_TEMP = 0x15, + OMV_CSI_IOCTL_LEPTON_SET_MODE = 0x16 | OMV_CSI_FLAG_IOCTL_ABORT, + OMV_CSI_IOCTL_LEPTON_GET_MODE = 0x17, + OMV_CSI_IOCTL_LEPTON_SET_RANGE = 0x18 | OMV_CSI_FLAG_IOCTL_ABORT, + OMV_CSI_IOCTL_LEPTON_GET_RANGE = 0x19, + OMV_CSI_IOCTL_HIMAX_MD_ENABLE = 0x1A, + OMV_CSI_IOCTL_HIMAX_MD_CLEAR = 0x1B, + OMV_CSI_IOCTL_HIMAX_MD_WINDOW = 0x1C | OMV_CSI_FLAG_IOCTL_ABORT, + OMV_CSI_IOCTL_HIMAX_MD_THRESHOLD = 0x1D, + OMV_CSI_IOCTL_HIMAX_OSC_ENABLE = 0x1E | OMV_CSI_FLAG_IOCTL_ABORT, + OMV_CSI_IOCTL_GET_RGB_STATS = 0x1F, + OMV_CSI_IOCTL_GENX320_SET_BIASES = 0x20, + OMV_CSI_IOCTL_GENX320_SET_BIAS = 0x21, + OMV_CSI_IOCTL_GENX320_SET_AFK = 0x22, + OMV_CSI_IOCTL_GENX320_SET_MODE = 0x23, + OMV_CSI_IOCTL_GENX320_READ_EVENTS = 0x24, + OMV_CSI_IOCTL_GENX320_CALIBRATE = 0x25, + OMV_CSI_IOCTL_GENX320_SET_STC = 0x26, + // Boson-specific + OMV_CSI_IOCTL_BOSON_GET_FPA_TEMP = 0x27, + OMV_CSI_IOCTL_BOSON_RUN_FFC = 0x28, + OMV_CSI_IOCTL_BOSON_GET_FFC_STATUS = 0x29, + OMV_CSI_IOCTL_BOSON_SET_FFC_MODE = 0x2A, + OMV_CSI_IOCTL_BOSON_SET_GAIN_MODE = 0x2B, + OMV_CSI_IOCTL_BOSON_GET_GAIN_MODE = 0x2C, + OMV_CSI_IOCTL_BOSON_SET_AGC_PARAM = 0x2D, + OMV_CSI_IOCTL_BOSON_GET_IMAGE_STATS = 0x2E, + OMV_CSI_IOCTL_BOSON_SET_STATS_ROI = 0x2F, + OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_ENABLE = 0x30, + OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_TEMPS = 0x31, + OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_UNIT = 0x32, + OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH = 0x33, + OMV_CSI_IOCTL_BOSON_GET_SERIAL = 0x34, + OMV_CSI_IOCTL_BOSON_GET_PART_NUMBER = 0x35, + OMV_CSI_IOCTL_BOSON_SET_COLORLUT = 0x36, + OMV_CSI_IOCTL_BOSON_SET_SCALER_ZOOM = 0x37, + OMV_CSI_IOCTL_BOSON_GET_SCALER_ZOOM = 0x38, + OMV_CSI_IOCTL_GENX320_READ_EVENTS_RAW = 0x39, + // Image Stats & Spot Meter + OMV_CSI_IOCTL_BOSON_GET_STATS_ROI = 0x70, + OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_ENABLE = 0x71, + OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ENABLE = 0x72, + OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_ROI = 0x73, + OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ROI = 0x74, + OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_STATS = 0x75, + OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_TEMP_STATS = 0x76, + OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ROI_MAX = 0x77, + // Isotherm Getters + OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_ENABLE = 0x78, + OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_UNIT = 0x79, + OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_TEMPS = 0x7A, + // Radiometry, Sensor Info & Overtemp + OMV_CSI_IOCTL_BOSON_GET_RADIOMETRY_CAPABLE = 0x7B, + OMV_CSI_IOCTL_BOSON_SET_RADIOMETRY_ENABLE = 0x7C, + OMV_CSI_IOCTL_BOSON_GET_RADIOMETRY_ENABLE = 0x7D, + OMV_CSI_IOCTL_BOSON_SET_EMISSIVITY = 0x7E, + OMV_CSI_IOCTL_UPDATE_AGC_AEC = 0x7F, + OMV_CSI_IOCTL_BOSON_GET_EMISSIVITY = 0x80, + OMV_CSI_IOCTL_BOSON_GET_SOFTWARE_REV = 0x81, + OMV_CSI_IOCTL_BOSON_GET_SENSOR_SN = 0x82, + OMV_CSI_IOCTL_BOSON_GET_OVERTEMP_THRESHOLD = 0x83, + OMV_CSI_IOCTL_BOSON_GET_OVERTEMP_EVENT_COUNT = 0x84, + OMV_CSI_IOCTL_BOSON_GET_LOW_POWER_MODE = 0x85, + // FFC control IOCTLs + OMV_CSI_IOCTL_BOSON_GET_FFC_MODE = 0x86, + OMV_CSI_IOCTL_BOSON_SET_FFC_TEMP_THRESHOLD = 0x87, + OMV_CSI_IOCTL_BOSON_GET_FFC_TEMP_THRESHOLD = 0x88, + OMV_CSI_IOCTL_BOSON_SET_FFC_FRAME_THRESHOLD = 0x89, + OMV_CSI_IOCTL_BOSON_GET_FFC_FRAME_THRESHOLD = 0x8A, + OMV_CSI_IOCTL_BOSON_SET_FFC_TEMP_THRESHOLD_LG = 0x8B, + OMV_CSI_IOCTL_BOSON_GET_FFC_TEMP_THRESHOLD_LG = 0x8C, + OMV_CSI_IOCTL_BOSON_SET_FFC_FRAME_THRESHOLD_LG = 0x8D, + OMV_CSI_IOCTL_BOSON_GET_FFC_FRAME_THRESHOLD_LG = 0x8E, + OMV_CSI_IOCTL_BOSON_SET_FFC_WARN_TIME = 0x8F, + OMV_CSI_IOCTL_BOSON_GET_FFC_WARN_TIME = 0x90, + OMV_CSI_IOCTL_BOSON_GET_FFC_DESIRED = 0x91, + OMV_CSI_IOCTL_BOSON_GET_LAST_FFC_FRAME_COUNT = 0x92, + OMV_CSI_IOCTL_BOSON_GET_LAST_FFC_TEMP = 0x93, + OMV_CSI_IOCTL_BOSON_SET_STARTUP_FFC_PERIOD = 0x94, + OMV_CSI_IOCTL_BOSON_GET_STARTUP_FFC_PERIOD = 0x95, + // FFC correction pipeline IOCTLs + OMV_CSI_IOCTL_BOSON_SET_SCNR_ENABLE = 0x96, + OMV_CSI_IOCTL_BOSON_GET_SCNR_ENABLE = 0x97, + OMV_CSI_IOCTL_BOSON_SET_TF_ENABLE = 0x98, + OMV_CSI_IOCTL_BOSON_GET_TF_ENABLE = 0x99, + OMV_CSI_IOCTL_BOSON_SET_SPNR_ENABLE = 0x9A, + OMV_CSI_IOCTL_BOSON_GET_SPNR_ENABLE = 0x9B, + OMV_CSI_IOCTL_BOSON_SET_BPR_ENABLE = 0x9C, + OMV_CSI_IOCTL_BOSON_GET_BPR_ENABLE = 0x9D, + OMV_CSI_IOCTL_BOSON_SET_LFSR_ENABLE = 0x9E, + OMV_CSI_IOCTL_BOSON_GET_LFSR_ENABLE = 0x9F, + OMV_CSI_IOCTL_BOSON_SET_SRNR_ENABLE = 0xA0, + OMV_CSI_IOCTL_BOSON_GET_SRNR_ENABLE = 0xA1, + OMV_CSI_IOCTL_BOSON_SET_GAO_ENABLE = 0xA2, + OMV_CSI_IOCTL_BOSON_GET_GAO_ENABLE = 0xA3, + OMV_CSI_IOCTL_BOSON_SET_FFC_PIPE_STATE = 0xA4, + OMV_CSI_IOCTL_BOSON_GET_FFC_PIPE_STATE = 0xA5, + OMV_CSI_IOCTL_BOSON_SET_SFFC_STATE = 0xA6, + OMV_CSI_IOCTL_BOSON_GET_SFFC_STATE = 0xA7, + // AGC control IOCTLs + OMV_CSI_IOCTL_BOSON_SET_AGC_MODE = 0xA8, + OMV_CSI_IOCTL_BOSON_GET_AGC_MODE = 0xA9, + OMV_CSI_IOCTL_BOSON_SET_AGC_PERCENT_PER_BIN = 0xAA, + OMV_CSI_IOCTL_BOSON_GET_AGC_PERCENT_PER_BIN = 0xAB, + OMV_CSI_IOCTL_BOSON_SET_AGC_OUTLIER_CUT = 0xAC, + OMV_CSI_IOCTL_BOSON_GET_AGC_OUTLIER_CUT = 0xAD, + OMV_CSI_IOCTL_BOSON_SET_AGC_DETAIL_HEADROOM = 0xAE, + OMV_CSI_IOCTL_BOSON_GET_AGC_DETAIL_HEADROOM = 0xAF, + OMV_CSI_IOCTL_BOSON_GET_AGC_LINEAR_PERCENT = 0xB0, + OMV_CSI_IOCTL_BOSON_GET_AGC_D2BR = 0xB1, + OMV_CSI_IOCTL_BOSON_GET_AGC_SIGMA_R = 0xB2, + OMV_CSI_IOCTL_BOSON_GET_AGC_MAX_GAIN = 0xB3, + OMV_CSI_IOCTL_BOSON_GET_AGC_DF = 0xB4, + OMV_CSI_IOCTL_BOSON_GET_AGC_GAMMA = 0xB5, + // Dynamic range control IOCTLs + OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_PARAMS = 0xB6, + OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH_HYST_TIME = 0xB7, + OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_HYST_TIME = 0xB8, + OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH_FRAME_THRESH = 0xB9, + OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_FRAME_THRESH = 0xBA, + OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_DESIRED = 0xBB, + // TLinear & spot meter stats mode IOCTLs + OMV_CSI_IOCTL_BOSON_SET_TLINEAR_ENABLE = 0xBC, + OMV_CSI_IOCTL_BOSON_GET_TLINEAR_ENABLE = 0xBD, + OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_STATS_MODE = 0xBE, + OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_STATS_MODE = 0xBF } omv_csi_ioctl_t; typedef enum { diff --git a/drivers/sensors/boson.c b/drivers/sensors/boson.c index 0425096ab8..8d6fef3ebe 100644 --- a/drivers/sensors/boson.c +++ b/drivers/sensors/boson.c @@ -153,6 +153,890 @@ static int post_process(omv_csi_t *csi, image_t *image, uint32_t flags) { return 0; } +static int ioctl(omv_csi_t *csi, int request, va_list ap) { + FSLP_set_csi(csi); + + switch (request) { + case OMV_CSI_IOCTL_BOSON_GET_FPA_TEMP: { + int16_t temp; + if (bosonlookupFPATempDegCx10(&temp) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)temp; + return 0; + } + case OMV_CSI_IOCTL_BOSON_RUN_FFC: { + if (bosonRunFFC() != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_STATUS: { + FLR_BOSON_FFCSTATUS_E status; + if (bosonGetFfcStatus(&status) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int) status; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_FFC_MODE: { + int mode = va_arg(ap, int); + if (bosonSetFFCMode((FLR_BOSON_FFCMODE_E) mode) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_GAIN_MODE: { + int mode = va_arg(ap, int); + if (bosonSetGainMode((FLR_BOSON_GAINMODE_E) mode) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_GAIN_MODE: { + FLR_BOSON_GAINMODE_E mode; + if (bosonGetGainMode(&mode) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)mode; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_AGC_PARAM: { + int param_id = va_arg(ap, int); + // va_arg promotes float to double + float value = (float)va_arg(ap, double); + FLR_RESULT ret; + switch (param_id) { + case 0: ret = agcSetLinearPercent(value); break; + case 1: ret = agcSetd2br(value); break; + case 2: ret = agcSetSigmaR(value); break; + case 3: ret = agcSetMaxGain(value); break; + case 4: ret = agcSetdf(value); break; + case 5: ret = agcSetGamma(value); break; + default: return -1; + } + return (ret == FLR_OK) ? 0 : -1; + } + case OMV_CSI_IOCTL_BOSON_GET_IMAGE_STATS: { + uint16_t mean, peak, base; + if (imageStatsGetImageStats(&mean, &peak, &base) != FLR_OK) { + return -1; + } + uint16_t *out_mean = va_arg(ap, uint16_t *); + uint16_t *out_peak = va_arg(ap, uint16_t *); + uint16_t *out_base = va_arg(ap, uint16_t *); + *out_mean = mean; + *out_peak = peak; + *out_base = base; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_STATS_ROI: { + FLR_ROI_T roi; + roi.rowStart = (uint16_t)va_arg(ap, int); + roi.rowStop = (uint16_t)va_arg(ap, int); + roi.colStart = (uint16_t)va_arg(ap, int); + roi.colStop = (uint16_t)va_arg(ap, int); + if (imageStatsSetROI(roi) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_ENABLE: { + int en = va_arg(ap, int); + if (isothermSetEnable(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_TEMPS: { + int table = va_arg(ap, int); + int32_t t1 = va_arg(ap, int32_t); + int32_t t2 = va_arg(ap, int32_t); + int32_t t3 = va_arg(ap, int32_t); + int32_t t4 = va_arg(ap, int32_t); + int32_t t5 = va_arg(ap, int32_t); + if (isothermSetTemps((FLR_ISOTHERM_GAIN_E)table, t1, t2, t3, t4, t5) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_UNIT: { + int unit = va_arg(ap, int); + if (isothermSetUnit((FLR_ISOTHERM_UNIT_E)unit) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH: { + FLR_BOSON_GAIN_SWITCH_PARAMS_T params; + params.pHighToLowPercent = (uint32_t)va_arg(ap, int); + params.cHighToLowPercent = (uint32_t)va_arg(ap, int); + params.pLowToHighPercent = (uint32_t)va_arg(ap, int); + params.hysteresisPercent = (uint32_t)va_arg(ap, int); + if (bosonSetGainSwitchParams(params) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SERIAL: { + uint32_t sn; + if (bosonGetCameraSN(&sn) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = sn; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_PART_NUMBER: { + // TODO: return the part number from top of file, use sizeof FLR_BOSON_PARTNUMBER_T + // instead of hardcoding 20 + + FLR_BOSON_PARTNUMBER_T pn; + if (bosonGetCameraPN(&pn) != FLR_OK) return -1; + char *out = va_arg(ap, char *); + memcpy(out, pn.value, sizeof(FLR_BOSON_PARTNUMBER_T)); + return 0; + } + // Image Stats & Spot Meter IOCTLs + case OMV_CSI_IOCTL_BOSON_GET_STATS_ROI: { + FLR_ROI_T roi; + if (imageStatsGetROI(&roi) != FLR_OK) { + return -1; + } + uint16_t *out_rs = va_arg(ap, uint16_t *); + uint16_t *out_re = va_arg(ap, uint16_t *); + uint16_t *out_cs = va_arg(ap, uint16_t *); + uint16_t *out_ce = va_arg(ap, uint16_t *); + *out_rs = roi.rowStart; + *out_re = roi.rowStop; + *out_cs = roi.colStart; + *out_ce = roi.colStop; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_ENABLE: { + int en = va_arg(ap, int); + if (spotMeterSetEnable(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ENABLE: { + FLR_ENABLE_E en; + if (spotMeterGetEnable(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_ROI: { + FLR_ROI_T roi; + roi.rowStart = (uint16_t)va_arg(ap, int); + roi.rowStop = (uint16_t)va_arg(ap, int); + roi.colStart = (uint16_t)va_arg(ap, int); + roi.colStop = (uint16_t)va_arg(ap, int); + if (spotMeterSetRoi(roi) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ROI: { + FLR_ROI_T roi; + if (spotMeterGetRoi(&roi) != FLR_OK) { + return -1; + } + uint16_t *out_rs = va_arg(ap, uint16_t *); + uint16_t *out_re = va_arg(ap, uint16_t *); + uint16_t *out_cs = va_arg(ap, uint16_t *); + uint16_t *out_ce = va_arg(ap, uint16_t *); + *out_rs = roi.rowStart; + *out_re = roi.rowStop; + *out_cs = roi.colStart; + *out_ce = roi.colStop; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_STATS: { + uint16_t mean, deviation; + FLR_SPOTMETER_SPOT_PARAM_T min_param, max_param; + if (spotMeterGetSpotStats(&mean, &deviation, &min_param, &max_param) != FLR_OK) { + return -1; + } + uint16_t *out_mean = va_arg(ap, uint16_t *); + uint16_t *out_dev = va_arg(ap, uint16_t *); + uint16_t *out_min_val = va_arg(ap, uint16_t *); + uint16_t *out_min_row = va_arg(ap, uint16_t *); + uint16_t *out_min_col = va_arg(ap, uint16_t *); + uint16_t *out_max_val = va_arg(ap, uint16_t *); + uint16_t *out_max_row = va_arg(ap, uint16_t *); + uint16_t *out_max_col = va_arg(ap, uint16_t *); + *out_mean = mean; + *out_dev = deviation; + *out_min_val = min_param.value; + *out_min_row = min_param.row; + *out_min_col = min_param.column; + *out_max_val = max_param.value; + *out_max_row = max_param.row; + *out_max_col = max_param.column; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_TEMP_STATS: { + float mean, deviation; + FLR_SPOTMETER_STAT_PARAM_TEMP_T min_param, max_param; + if (spotMeterGetTempStats(&mean, &deviation, &min_param, &max_param) != FLR_OK) { + return -1; + } + float *out_mean = va_arg(ap, float *); + float *out_dev = va_arg(ap, float *); + float *out_min_val = va_arg(ap, float *); + uint16_t *out_min_row = va_arg(ap, uint16_t *); + uint16_t *out_min_col = va_arg(ap, uint16_t *); + float *out_max_val = va_arg(ap, float *); + uint16_t *out_max_row = va_arg(ap, uint16_t *); + uint16_t *out_max_col = va_arg(ap, uint16_t *); + *out_mean = mean; + *out_dev = deviation; + *out_min_val = min_param.value; + *out_min_row = min_param.row; + *out_min_col = min_param.column; + *out_max_val = max_param.value; + *out_max_row = max_param.row; + *out_max_col = max_param.column; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ROI_MAX: { + uint16_t width, height; + if (spotMeterGetRoiMaxSize(&width, &height) != FLR_OK) { + return -1; + } + uint16_t *out_w = va_arg(ap, uint16_t *); + uint16_t *out_h = va_arg(ap, uint16_t *); + *out_w = width; + *out_h = height; + return 0; + } + // Isotherm Getters + case OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_ENABLE: { + FLR_ENABLE_E en; + if (isothermGetEnable(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_UNIT: { + FLR_ISOTHERM_UNIT_E unit; + if (isothermGetUnit(&unit) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)unit; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_TEMPS: { + int table = va_arg(ap, int); + int32_t t1, t2, t3, t4, t5; + if (isothermGetTemps((FLR_ISOTHERM_GAIN_E)table, &t1, &t2, &t3, &t4, &t5) != FLR_OK) { + return -1; + } + int32_t *out_t1 = va_arg(ap, int32_t *); + int32_t *out_t2 = va_arg(ap, int32_t *); + int32_t *out_t3 = va_arg(ap, int32_t *); + int32_t *out_t4 = va_arg(ap, int32_t *); + int32_t *out_t5 = va_arg(ap, int32_t *); + *out_t1 = t1; + *out_t2 = t2; + *out_t3 = t3; + *out_t4 = t4; + *out_t5 = t5; + return 0; + } + // Radiometry, Sensor Info & Overtemp + case OMV_CSI_IOCTL_BOSON_GET_RADIOMETRY_CAPABLE: { + FLR_ENABLE_E capable; + if (radiometryGetRadiometryCapable(&capable) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)capable; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_RADIOMETRY_ENABLE: { + int en = va_arg(ap, int); + if (radiometrySetTempStableEnable(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_RADIOMETRY_ENABLE: { + FLR_ENABLE_E en; + if (radiometryGetTempStableEnable(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_TLINEAR_ENABLE: { + int en = va_arg(ap, int); + if (TLinearSetControl(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_TLINEAR_ENABLE: { + FLR_ENABLE_E en; + if (TLinearGetControl(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_STATS_MODE: { + int mode = va_arg(ap, int); + if (spotMeterSetStatsMode((FLR_SPOTMETER_STATS_TEMP_MODE_E)mode) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_STATS_MODE: { + FLR_SPOTMETER_STATS_TEMP_MODE_E mode; + if (spotMeterGetStatsMode(&mode) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)mode; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_EMISSIVITY: { + // va_arg promotes float to double + float val = (float)va_arg(ap, double); + if (radiometrySetEmissivityTarget(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_EMISSIVITY: { + float val; + if (radiometryGetEmissivityTarget(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SOFTWARE_REV: { + uint32_t major, minor, patch; + if (bosonGetSoftwareRev(&major, &minor, &patch) != FLR_OK) { + return -1; + } + uint32_t *out_major = va_arg(ap, uint32_t *); + uint32_t *out_minor = va_arg(ap, uint32_t *); + uint32_t *out_patch = va_arg(ap, uint32_t *); + *out_major = major; + *out_minor = minor; + *out_patch = patch; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SENSOR_SN: { + uint32_t sn; + if (bosonGetSensorSN(&sn) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = sn; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_OVERTEMP_THRESHOLD: { + float temp; + if (bosonGetOverTempThreshold(&temp) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = temp; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_OVERTEMP_EVENT_COUNT: { + uint32_t count; + if (bosonGetOverTempEventCounter(&count) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = count; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_LOW_POWER_MODE: { + uint16_t mode; + if (bosonGetLowPowerMode(&mode) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)mode; + return 0; + } + // FFC control IOCTLs + case OMV_CSI_IOCTL_BOSON_GET_FFC_MODE: { + FLR_BOSON_FFCMODE_E mode; + if (bosonGetFFCMode(&mode) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)mode; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_FFC_TEMP_THRESHOLD: { + int val = va_arg(ap, int); + if (bosonSetFFCTempThreshold((uint16_t)val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_TEMP_THRESHOLD: { + uint16_t val; + if (bosonGetFFCTempThreshold(&val) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_FFC_FRAME_THRESHOLD: { + uint32_t val = (uint32_t)va_arg(ap, int); + if (bosonSetFFCFrameThreshold(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_FRAME_THRESHOLD: { + uint32_t val; + if (bosonGetFFCFrameThreshold(&val) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_FFC_TEMP_THRESHOLD_LG: { + int val = va_arg(ap, int); + if (bosonSetFFCTempThresholdLowGain((uint16_t)val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_TEMP_THRESHOLD_LG: { + uint16_t val; + if (bosonGetFFCTempThresholdLowGain(&val) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_FFC_FRAME_THRESHOLD_LG: { + uint32_t val = (uint32_t)va_arg(ap, int); + if (bosonSetFFCFrameThresholdLowGain(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_FRAME_THRESHOLD_LG: { + uint32_t val; + if (bosonGetFFCFrameThresholdLowGain(&val) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_FFC_WARN_TIME: { + int val = va_arg(ap, int); + if (bosonSetFFCWarnTimeInSecx10((uint16_t)val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_WARN_TIME: { + uint16_t val; + if (bosonGetFFCWarnTimeInSecx10(&val) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_DESIRED: { + uint32_t val; + if (bosonGetFfcDesired(&val) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_LAST_FFC_FRAME_COUNT: { + uint32_t val; + if (bosonGetLastFFCFrameCount(&val) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_LAST_FFC_TEMP: { + uint16_t val; + if (bosonGetLastFFCTempDegKx10(&val) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_STARTUP_FFC_PERIOD: { + uint32_t val = (uint32_t)va_arg(ap, int); + if (bosonSetTimeForQuickFFCsInSecs(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_STARTUP_FFC_PERIOD: { + uint32_t val; + if (bosonGetTimeForQuickFFCsInSecs(&val) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = val; + return 0; + } + // FFC correction pipeline IOCTLs + case OMV_CSI_IOCTL_BOSON_SET_SCNR_ENABLE: { + int en = va_arg(ap, int); + if (scnrSetEnableState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SCNR_ENABLE: { + FLR_ENABLE_E en; + if (scnrGetEnableState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_TF_ENABLE: { + int en = va_arg(ap, int); + if (tfSetEnableState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_TF_ENABLE: { + FLR_ENABLE_E en; + if (tfGetEnableState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_SPNR_ENABLE: { + int en = va_arg(ap, int); + if (spnrSetEnableState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SPNR_ENABLE: { + FLR_ENABLE_E en; + if (spnrGetEnableState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_BPR_ENABLE: { + int en = va_arg(ap, int); + if (bprSetState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_BPR_ENABLE: { + FLR_ENABLE_E en; + if (bprGetState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_LFSR_ENABLE: { + int en = va_arg(ap, int); + if (lfsrSetApplyOffsetEnableState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_LFSR_ENABLE: { + FLR_ENABLE_E en; + if (lfsrGetApplyOffsetEnableState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_SRNR_ENABLE: { + int en = va_arg(ap, int); + if (srnrSetEnableState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SRNR_ENABLE: { + FLR_ENABLE_E en; + if (srnrGetEnableState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_GAO_ENABLE: { + int en = va_arg(ap, int); + if (gaoSetAppliedClipEnable(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_GAO_ENABLE: { + FLR_ENABLE_E en; + if (gaoGetAppliedClipEnable(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_FFC_PIPE_STATE: { + int en = va_arg(ap, int); + if (gaoSetFfcState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_FFC_PIPE_STATE: { + FLR_ENABLE_E en; + if (gaoGetFfcState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_SFFC_STATE: { + int en = va_arg(ap, int); + if (gaoSetSffcState(en ? FLR_ENABLE : FLR_DISABLE) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_SFFC_STATE: { + FLR_ENABLE_E en; + if (gaoGetSffcState(&en) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)en; + return 0; + } + // AGC control IOCTLs + case OMV_CSI_IOCTL_BOSON_SET_AGC_MODE: { + int mode = va_arg(ap, int); + if (agcSetMode((FLR_AGC_MODE_E)mode) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_MODE: { + FLR_AGC_MODE_E mode; + if (agcGetMode(&mode) != FLR_OK) { + return -1; + } + int *out = va_arg(ap, int *); + *out = (int)mode; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_AGC_PERCENT_PER_BIN: { + float val = (float)va_arg(ap, double); + if (agcSetPercentPerBin(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_PERCENT_PER_BIN: { + float val; + if (agcGetPercentPerBin(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_AGC_OUTLIER_CUT: { + float val = (float)va_arg(ap, double); + if (agcSetOutlierCut(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_OUTLIER_CUT: { + float val; + if (agcGetOutlierCut(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_AGC_DETAIL_HEADROOM: { + float val = (float)va_arg(ap, double); + if (agcSetDetailHeadroom(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_DETAIL_HEADROOM: { + float val; + if (agcGetDetailHeadroom(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_LINEAR_PERCENT: { + float val; + if (agcGetLinearPercent(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_D2BR: { + float val; + if (agcGetd2br(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_SIGMA_R: { + float val; + if (agcGetSigmaR(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_MAX_GAIN: { + float val; + if (agcGetMaxGain(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_DF: { + float val; + if (agcGetdf(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_AGC_GAMMA: { + float val; + if (agcGetGamma(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + // Dynamic range control IOCTLs + case OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_PARAMS: { + FLR_BOSON_GAIN_SWITCH_PARAMS_T params; + if (bosonGetGainSwitchParams(¶ms) != FLR_OK) { + return -1; + } + uint32_t *out_ht = va_arg(ap, uint32_t *); + uint32_t *out_hp = va_arg(ap, uint32_t *); + uint32_t *out_lp = va_arg(ap, uint32_t *); + uint32_t *out_hy = va_arg(ap, uint32_t *); + *out_ht = params.pHighToLowPercent; + *out_hp = params.cHighToLowPercent; + *out_lp = params.pLowToHighPercent; + *out_hy = params.hysteresisPercent; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH_HYST_TIME: { + float val = (float)va_arg(ap, double); + if (bosonSetGainSwitchHysteresisTime(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_HYST_TIME: { + float val; + if (bosonGetGainSwitchHysteresisTime(&val) != FLR_OK) { + return -1; + } + float *out = va_arg(ap, float *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH_FRAME_THRESH: { + uint32_t val = (uint32_t)va_arg(ap, int); + if (bosonSetGainSwitchFrameThreshold(val) != FLR_OK) { + return -1; + } + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_FRAME_THRESH: { + uint32_t val; + if (bosonGetGainSwitchFrameThreshold(&val) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = val; + return 0; + } + case OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_DESIRED: { + uint32_t val; + if (bosonGetGainSwitchDesired(&val) != FLR_OK) { + return -1; + } + uint32_t *out = va_arg(ap, uint32_t *); + *out = val; + return 0; + } + default: + return -1; + } +} + int boson_init(omv_csi_t *csi) { // Initialize csi structure csi->reset = reset; @@ -160,6 +1044,7 @@ int boson_init(omv_csi_t *csi) { csi->set_framesize = set_framesize; csi->set_colorbar = set_colorbar; csi->post_process = post_process; + csi->ioctl = ioctl; // Set csi flags csi->vsync_pol = 0; diff --git a/modules/py_csi_ng.c b/modules/py_csi_ng.c index 43d636f1a7..3b765d2296 100644 --- a/modules/py_csi_ng.c +++ b/modules/py_csi_ng.c @@ -1426,6 +1426,1102 @@ static void py_csi_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kin mp_printf(print, " }\n}\n"); } +#if (OMV_BOSON_ENABLE == 1) +static mp_obj_t py_csi_boson_get_fpa_temp(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int temp; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FPA_TEMP, &temp); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(temp / 10.0f); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_fpa_temp_obj, py_csi_boson_get_fpa_temp); + +static mp_obj_t py_csi_boson_run_ffc(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_RUN_FFC); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_run_ffc_obj, py_csi_boson_run_ffc); + +static mp_obj_t py_csi_boson_get_ffc_status(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int status; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_STATUS, &status); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(status); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_status_obj, py_csi_boson_get_ffc_status); + +static mp_obj_t py_csi_boson_set_ffc_mode(mp_obj_t self_in, mp_obj_t mode_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_FFC_MODE, mp_obj_get_int(mode_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_ffc_mode_obj, py_csi_boson_set_ffc_mode); + +static mp_obj_t py_csi_boson_set_gain_mode(mp_obj_t self_in, mp_obj_t mode_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_GAIN_MODE, mp_obj_get_int(mode_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_gain_mode_obj, py_csi_boson_set_gain_mode); + +static mp_obj_t py_csi_boson_get_gain_mode(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int mode; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_GAIN_MODE, &mode); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(mode); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_gain_mode_obj, py_csi_boson_get_gain_mode); + +static mp_obj_t py_csi_boson_set_agc_param(mp_obj_t self_in, mp_obj_t id_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_AGC_PARAM, + mp_obj_get_int(id_in), (double)mp_obj_get_float(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_3(py_csi_boson_set_agc_param_obj, py_csi_boson_set_agc_param); + +static mp_obj_t py_csi_boson_get_image_stats(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint16_t mean, peak, base; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_IMAGE_STATS, &mean, &peak, &base); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(3, (mp_obj_t []) { + mp_obj_new_int(mean), mp_obj_new_int(peak), mp_obj_new_int(base) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_image_stats_obj, py_csi_boson_get_image_stats); + +static mp_obj_t py_csi_boson_set_stats_roi(size_t n_args, const mp_obj_t *args) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(args[0]); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_STATS_ROI, + mp_obj_get_int(args[1]), mp_obj_get_int(args[2]), + mp_obj_get_int(args[3]), mp_obj_get_int(args[4])); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(py_csi_boson_set_stats_roi_obj, 5, 5, py_csi_boson_set_stats_roi); + +static mp_obj_t py_csi_boson_set_isotherm_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_isotherm_enable_obj, py_csi_boson_set_isotherm_enable); + +static mp_obj_t py_csi_boson_set_isotherm_temps(size_t n_args, const mp_obj_t *args) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(args[0]); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_TEMPS, + mp_obj_get_int(args[1]), + (int32_t)mp_obj_get_int(args[2]), + (int32_t)mp_obj_get_int(args[3]), + (int32_t)mp_obj_get_int(args[4]), + (int32_t)mp_obj_get_int(args[5]), + (int32_t)mp_obj_get_int(args[6])); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(py_csi_boson_set_isotherm_temps_obj, 7, 7, py_csi_boson_set_isotherm_temps); + +static mp_obj_t py_csi_boson_set_isotherm_unit(mp_obj_t self_in, mp_obj_t unit_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_ISOTHERM_UNIT, mp_obj_get_int(unit_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_isotherm_unit_obj, py_csi_boson_set_isotherm_unit); + +static mp_obj_t py_csi_boson_set_gain_switch(size_t n_args, const mp_obj_t *args) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(args[0]); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH, + mp_obj_get_int(args[1]), mp_obj_get_int(args[2]), + mp_obj_get_int(args[3]), mp_obj_get_int(args[4])); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(py_csi_boson_set_gain_switch_obj, 5, 5, py_csi_boson_set_gain_switch); + +static mp_obj_t py_csi_boson_get_serial(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t sn; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SERIAL, &sn); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(sn); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_serial_obj, py_csi_boson_get_serial); + +static mp_obj_t py_csi_boson_get_part_number(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + char pn[20]; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_PART_NUMBER, pn); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_str(pn, strnlen(pn, 20)); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_part_number_obj, py_csi_boson_get_part_number); + +static mp_obj_t py_csi_boson_set_colorlut(mp_obj_t self_in, mp_obj_t id_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_COLORLUT, mp_obj_get_int(id_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_colorlut_obj, py_csi_boson_set_colorlut); + +static mp_obj_t py_csi_boson_set_zoom(size_t n_args, const mp_obj_t *args) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(args[0]); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SCALER_ZOOM, + mp_obj_get_int(args[1]), + (n_args > 2) ? mp_obj_get_int(args[2]) : 0, + (n_args > 3) ? mp_obj_get_int(args[3]) : 0); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(py_csi_boson_set_zoom_obj, 2, 4, py_csi_boson_set_zoom); + +static mp_obj_t py_csi_boson_get_zoom(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t zoom, x, y; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SCALER_ZOOM, &zoom, &x, &y); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(3, (mp_obj_t []) { + mp_obj_new_int(zoom), mp_obj_new_int(x), mp_obj_new_int(y) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_zoom_obj, py_csi_boson_get_zoom); + +// Image Stats ROI getter +static mp_obj_t py_csi_boson_get_stats_roi(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint16_t rs, re, cs, ce; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_STATS_ROI, &rs, &re, &cs, &ce); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(4, (mp_obj_t []) { + mp_obj_new_int(rs), mp_obj_new_int(re), mp_obj_new_int(cs), mp_obj_new_int(ce) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_stats_roi_obj, py_csi_boson_get_stats_roi); + +// Spot Meter enable set/get +static mp_obj_t py_csi_boson_set_spot_meter_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_spot_meter_enable_obj, py_csi_boson_set_spot_meter_enable); + +static mp_obj_t py_csi_boson_get_spot_meter_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int en; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ENABLE, &en); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(en); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_spot_meter_enable_obj, py_csi_boson_get_spot_meter_enable); + +// Spot Meter ROI set/get +static mp_obj_t py_csi_boson_set_spot_meter_roi(size_t n_args, const mp_obj_t *args) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(args[0]); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_ROI, + mp_obj_get_int(args[1]), mp_obj_get_int(args[2]), + mp_obj_get_int(args[3]), mp_obj_get_int(args[4])); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(py_csi_boson_set_spot_meter_roi_obj, 5, 5, py_csi_boson_set_spot_meter_roi); + +static mp_obj_t py_csi_boson_get_spot_meter_roi(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint16_t rs, re, cs, ce; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ROI, &rs, &re, &cs, &ce); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(4, (mp_obj_t []) { + mp_obj_new_int(rs), mp_obj_new_int(re), mp_obj_new_int(cs), mp_obj_new_int(ce) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_spot_meter_roi_obj, py_csi_boson_get_spot_meter_roi); + +// Spot Meter stats (raw values) +static mp_obj_t py_csi_boson_get_spot_meter_stats(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint16_t mean, dev, min_val, min_row, min_col, max_val, max_row, max_col; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_STATS, + &mean, &dev, &min_val, &min_row, &min_col, + &max_val, &max_row, &max_col); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(8, (mp_obj_t []) { + mp_obj_new_int(mean), mp_obj_new_int(dev), + mp_obj_new_int(min_val), mp_obj_new_int(min_row), mp_obj_new_int(min_col), + mp_obj_new_int(max_val), mp_obj_new_int(max_row), mp_obj_new_int(max_col) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_spot_meter_stats_obj, py_csi_boson_get_spot_meter_stats); + +// Spot Meter temp stats (float values, radiometric sensors only) +static mp_obj_t py_csi_boson_get_spot_meter_temp_stats(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float mean, dev, min_val, max_val; + uint16_t min_row, min_col, max_row, max_col; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_TEMP_STATS, + &mean, &dev, &min_val, &min_row, &min_col, + &max_val, &max_row, &max_col); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(8, (mp_obj_t []) { + mp_obj_new_float(mean), mp_obj_new_float(dev), + mp_obj_new_float(min_val), mp_obj_new_int(min_row), mp_obj_new_int(min_col), + mp_obj_new_float(max_val), mp_obj_new_int(max_row), mp_obj_new_int(max_col) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_spot_meter_temp_stats_obj, py_csi_boson_get_spot_meter_temp_stats); + +// Spot Meter ROI max size +static mp_obj_t py_csi_boson_get_spot_meter_roi_max(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint16_t width, height; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_ROI_MAX, &width, &height); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(2, (mp_obj_t []) { + mp_obj_new_int(width), mp_obj_new_int(height) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_spot_meter_roi_max_obj, py_csi_boson_get_spot_meter_roi_max); + +// Isotherm getters +static mp_obj_t py_csi_boson_get_isotherm_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int en; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_ENABLE, &en); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(en); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_isotherm_enable_obj, py_csi_boson_get_isotherm_enable); + +static mp_obj_t py_csi_boson_get_isotherm_unit(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int unit; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_UNIT, &unit); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(unit); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_isotherm_unit_obj, py_csi_boson_get_isotherm_unit); + +static mp_obj_t py_csi_boson_get_isotherm_temps(mp_obj_t self_in, mp_obj_t table_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int32_t t1, t2, t3, t4, t5; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_ISOTHERM_TEMPS, + mp_obj_get_int(table_in), &t1, &t2, &t3, &t4, &t5); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(5, (mp_obj_t []) { + mp_obj_new_int(t1), mp_obj_new_int(t2), mp_obj_new_int(t3), + mp_obj_new_int(t4), mp_obj_new_int(t5) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_get_isotherm_temps_obj, py_csi_boson_get_isotherm_temps); + +// Radiometry +static mp_obj_t py_csi_boson_get_radiometry_capable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int capable; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_RADIOMETRY_CAPABLE, &capable); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(capable); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_radiometry_capable_obj, py_csi_boson_get_radiometry_capable); + +static mp_obj_t py_csi_boson_set_radiometry_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_RADIOMETRY_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_radiometry_enable_obj, py_csi_boson_set_radiometry_enable); + +static mp_obj_t py_csi_boson_get_radiometry_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int en; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_RADIOMETRY_ENABLE, &en); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(en); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_radiometry_enable_obj, py_csi_boson_get_radiometry_enable); + +static mp_obj_t py_csi_boson_set_tlinear_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_TLINEAR_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_tlinear_enable_obj, py_csi_boson_set_tlinear_enable); + +static mp_obj_t py_csi_boson_get_tlinear_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int en; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_TLINEAR_ENABLE, &en); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(en); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_tlinear_enable_obj, py_csi_boson_get_tlinear_enable); + +static mp_obj_t py_csi_boson_set_spot_meter_stats_mode(mp_obj_t self_in, mp_obj_t mode_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SPOT_METER_STATS_MODE, mp_obj_get_int(mode_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_spot_meter_stats_mode_obj, py_csi_boson_set_spot_meter_stats_mode); + +static mp_obj_t py_csi_boson_get_spot_meter_stats_mode(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int mode; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SPOT_METER_STATS_MODE, &mode); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(mode); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_spot_meter_stats_mode_obj, py_csi_boson_get_spot_meter_stats_mode); + +static mp_obj_t py_csi_boson_set_emissivity(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_EMISSIVITY, (double)mp_obj_get_float(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_emissivity_obj, py_csi_boson_set_emissivity); + +static mp_obj_t py_csi_boson_get_emissivity(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_EMISSIVITY, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_emissivity_obj, py_csi_boson_get_emissivity); + +static mp_obj_t py_csi_boson_get_software_rev(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t major, minor, patch; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SOFTWARE_REV, &major, &minor, &patch); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(3, (mp_obj_t []) { + mp_obj_new_int_from_uint(major), mp_obj_new_int_from_uint(minor), mp_obj_new_int_from_uint(patch) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_software_rev_obj, py_csi_boson_get_software_rev); + +static mp_obj_t py_csi_boson_get_sensor_sn(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t sn; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SENSOR_SN, &sn); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(sn); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_sensor_sn_obj, py_csi_boson_get_sensor_sn); + +// Overtemp threshold is read-only (bosonSetOverTempThreshold does not exist in SDK) +static mp_obj_t py_csi_boson_get_overtemp_threshold(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float temp; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_OVERTEMP_THRESHOLD, &temp); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(temp); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_overtemp_threshold_obj, py_csi_boson_get_overtemp_threshold); + +static mp_obj_t py_csi_boson_get_overtemp_event_count(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t count; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_OVERTEMP_EVENT_COUNT, &count); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(count); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_overtemp_event_count_obj, py_csi_boson_get_overtemp_event_count); + +static mp_obj_t py_csi_boson_get_low_power_mode(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int mode; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_LOW_POWER_MODE, &mode); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(mode); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_low_power_mode_obj, py_csi_boson_get_low_power_mode); + +// FFC control IOCTLs +static mp_obj_t py_csi_boson_get_ffc_mode(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int mode; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_MODE, &mode); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(mode); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_mode_obj, py_csi_boson_get_ffc_mode); + +static mp_obj_t py_csi_boson_set_ffc_temp_threshold(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_FFC_TEMP_THRESHOLD, mp_obj_get_int(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_ffc_temp_threshold_obj, py_csi_boson_set_ffc_temp_threshold); + +static mp_obj_t py_csi_boson_get_ffc_temp_threshold(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_TEMP_THRESHOLD, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_temp_threshold_obj, py_csi_boson_get_ffc_temp_threshold); + +static mp_obj_t py_csi_boson_set_ffc_frame_threshold(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_FFC_FRAME_THRESHOLD, mp_obj_get_int(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_ffc_frame_threshold_obj, py_csi_boson_set_ffc_frame_threshold); + +static mp_obj_t py_csi_boson_get_ffc_frame_threshold(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_FRAME_THRESHOLD, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_frame_threshold_obj, py_csi_boson_get_ffc_frame_threshold); + +static mp_obj_t py_csi_boson_set_ffc_temp_threshold_lg(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_FFC_TEMP_THRESHOLD_LG, mp_obj_get_int(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_ffc_temp_threshold_lg_obj, py_csi_boson_set_ffc_temp_threshold_lg); + +static mp_obj_t py_csi_boson_get_ffc_temp_threshold_lg(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_TEMP_THRESHOLD_LG, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_temp_threshold_lg_obj, py_csi_boson_get_ffc_temp_threshold_lg); + +static mp_obj_t py_csi_boson_set_ffc_frame_threshold_lg(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_FFC_FRAME_THRESHOLD_LG, mp_obj_get_int(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_ffc_frame_threshold_lg_obj, py_csi_boson_set_ffc_frame_threshold_lg); + +static mp_obj_t py_csi_boson_get_ffc_frame_threshold_lg(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_FRAME_THRESHOLD_LG, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_frame_threshold_lg_obj, py_csi_boson_get_ffc_frame_threshold_lg); + +static mp_obj_t py_csi_boson_set_ffc_warn_time(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_FFC_WARN_TIME, mp_obj_get_int(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_ffc_warn_time_obj, py_csi_boson_set_ffc_warn_time); + +static mp_obj_t py_csi_boson_get_ffc_warn_time(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_WARN_TIME, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_warn_time_obj, py_csi_boson_get_ffc_warn_time); + +static mp_obj_t py_csi_boson_get_ffc_desired(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_DESIRED, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_desired_obj, py_csi_boson_get_ffc_desired); + +static mp_obj_t py_csi_boson_get_last_ffc_frame_count(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_LAST_FFC_FRAME_COUNT, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_last_ffc_frame_count_obj, py_csi_boson_get_last_ffc_frame_count); + +static mp_obj_t py_csi_boson_get_last_ffc_temp(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_LAST_FFC_TEMP, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_last_ffc_temp_obj, py_csi_boson_get_last_ffc_temp); + +static mp_obj_t py_csi_boson_set_startup_ffc_period(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_STARTUP_FFC_PERIOD, mp_obj_get_int(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_startup_ffc_period_obj, py_csi_boson_set_startup_ffc_period); + +static mp_obj_t py_csi_boson_get_startup_ffc_period(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_STARTUP_FFC_PERIOD, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_startup_ffc_period_obj, py_csi_boson_get_startup_ffc_period); + +// FFC correction pipeline IOCTLs +static mp_obj_t py_csi_boson_set_scnr_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SCNR_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_scnr_enable_obj, py_csi_boson_set_scnr_enable); + +static mp_obj_t py_csi_boson_get_scnr_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SCNR_ENABLE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_scnr_enable_obj, py_csi_boson_get_scnr_enable); + +static mp_obj_t py_csi_boson_set_tf_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_TF_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_tf_enable_obj, py_csi_boson_set_tf_enable); + +static mp_obj_t py_csi_boson_get_tf_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_TF_ENABLE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_tf_enable_obj, py_csi_boson_get_tf_enable); + +static mp_obj_t py_csi_boson_set_spnr_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SPNR_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_spnr_enable_obj, py_csi_boson_set_spnr_enable); + +static mp_obj_t py_csi_boson_get_spnr_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SPNR_ENABLE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_spnr_enable_obj, py_csi_boson_get_spnr_enable); + +static mp_obj_t py_csi_boson_set_bpr_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_BPR_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_bpr_enable_obj, py_csi_boson_set_bpr_enable); + +static mp_obj_t py_csi_boson_get_bpr_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_BPR_ENABLE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_bpr_enable_obj, py_csi_boson_get_bpr_enable); + +static mp_obj_t py_csi_boson_set_lfsr_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_LFSR_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_lfsr_enable_obj, py_csi_boson_set_lfsr_enable); + +static mp_obj_t py_csi_boson_get_lfsr_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_LFSR_ENABLE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_lfsr_enable_obj, py_csi_boson_get_lfsr_enable); + +static mp_obj_t py_csi_boson_set_srnr_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SRNR_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_srnr_enable_obj, py_csi_boson_set_srnr_enable); + +static mp_obj_t py_csi_boson_get_srnr_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SRNR_ENABLE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_srnr_enable_obj, py_csi_boson_get_srnr_enable); + +static mp_obj_t py_csi_boson_set_gao_enable(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_GAO_ENABLE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_gao_enable_obj, py_csi_boson_set_gao_enable); + +static mp_obj_t py_csi_boson_get_gao_enable(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_GAO_ENABLE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_gao_enable_obj, py_csi_boson_get_gao_enable); + +static mp_obj_t py_csi_boson_set_ffc_pipe_state(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_FFC_PIPE_STATE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_ffc_pipe_state_obj, py_csi_boson_set_ffc_pipe_state); + +static mp_obj_t py_csi_boson_get_ffc_pipe_state(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_FFC_PIPE_STATE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_ffc_pipe_state_obj, py_csi_boson_get_ffc_pipe_state); + +static mp_obj_t py_csi_boson_set_sffc_state(mp_obj_t self_in, mp_obj_t en_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_SFFC_STATE, mp_obj_is_true(en_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_sffc_state_obj, py_csi_boson_set_sffc_state); + +static mp_obj_t py_csi_boson_get_sffc_state(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_SFFC_STATE, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_bool(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_sffc_state_obj, py_csi_boson_get_sffc_state); + +// AGC control IOCTLs +static mp_obj_t py_csi_boson_set_agc_mode(mp_obj_t self_in, mp_obj_t mode_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_AGC_MODE, mp_obj_get_int(mode_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_agc_mode_obj, py_csi_boson_set_agc_mode); + +static mp_obj_t py_csi_boson_get_agc_mode(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int mode; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_MODE, &mode); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int(mode); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_mode_obj, py_csi_boson_get_agc_mode); + +static mp_obj_t py_csi_boson_set_agc_percent_per_bin(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_AGC_PERCENT_PER_BIN, + (double)mp_obj_get_float(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_agc_percent_per_bin_obj, py_csi_boson_set_agc_percent_per_bin); + +static mp_obj_t py_csi_boson_get_agc_percent_per_bin(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_PERCENT_PER_BIN, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_percent_per_bin_obj, py_csi_boson_get_agc_percent_per_bin); + +static mp_obj_t py_csi_boson_set_agc_outlier_cut(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_AGC_OUTLIER_CUT, + (double)mp_obj_get_float(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_agc_outlier_cut_obj, py_csi_boson_set_agc_outlier_cut); + +static mp_obj_t py_csi_boson_get_agc_outlier_cut(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_OUTLIER_CUT, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_outlier_cut_obj, py_csi_boson_get_agc_outlier_cut); + +static mp_obj_t py_csi_boson_set_agc_detail_headroom(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_AGC_DETAIL_HEADROOM, + (double)mp_obj_get_float(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_agc_detail_headroom_obj, py_csi_boson_set_agc_detail_headroom); + +static mp_obj_t py_csi_boson_get_agc_detail_headroom(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_DETAIL_HEADROOM, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_detail_headroom_obj, py_csi_boson_get_agc_detail_headroom); + +static mp_obj_t py_csi_boson_get_agc_linear_percent(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_LINEAR_PERCENT, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_linear_percent_obj, py_csi_boson_get_agc_linear_percent); + +static mp_obj_t py_csi_boson_get_agc_d2br(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_D2BR, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_d2br_obj, py_csi_boson_get_agc_d2br); + +static mp_obj_t py_csi_boson_get_agc_sigma_r(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_SIGMA_R, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_sigma_r_obj, py_csi_boson_get_agc_sigma_r); + +static mp_obj_t py_csi_boson_get_agc_max_gain(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_MAX_GAIN, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_max_gain_obj, py_csi_boson_get_agc_max_gain); + +static mp_obj_t py_csi_boson_get_agc_df(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_DF, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_df_obj, py_csi_boson_get_agc_df); + +static mp_obj_t py_csi_boson_get_agc_gamma(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_AGC_GAMMA, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_agc_gamma_obj, py_csi_boson_get_agc_gamma); + +// Dynamic range control IOCTLs +static mp_obj_t py_csi_boson_get_gain_switch_params(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t ht, hp, lp, hy; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_PARAMS, &ht, &hp, &lp, &hy); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_tuple(4, (mp_obj_t []) { + mp_obj_new_int(ht), mp_obj_new_int(hp), mp_obj_new_int(lp), mp_obj_new_int(hy) + }); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_gain_switch_params_obj, py_csi_boson_get_gain_switch_params); + +static mp_obj_t py_csi_boson_set_gain_switch_hyst_time(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH_HYST_TIME, + (double)mp_obj_get_float(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_gain_switch_hyst_time_obj, py_csi_boson_set_gain_switch_hyst_time); + +static mp_obj_t py_csi_boson_get_gain_switch_hyst_time(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + float val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_HYST_TIME, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_float(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_gain_switch_hyst_time_obj, py_csi_boson_get_gain_switch_hyst_time); + +static mp_obj_t py_csi_boson_set_gain_switch_frame_thresh(mp_obj_t self_in, mp_obj_t val_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_SET_GAIN_SWITCH_FRAME_THRESH, mp_obj_get_int(val_in)); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_const_none; +} +static MP_DEFINE_CONST_FUN_OBJ_2(py_csi_boson_set_gain_switch_frame_thresh_obj, py_csi_boson_set_gain_switch_frame_thresh); + +static mp_obj_t py_csi_boson_get_gain_switch_frame_thresh(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_FRAME_THRESH, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_gain_switch_frame_thresh_obj, py_csi_boson_get_gain_switch_frame_thresh); + +static mp_obj_t py_csi_boson_get_gain_switch_desired(mp_obj_t self_in) { + py_csi_obj_t *self = MP_OBJ_TO_PTR(self_in); + uint32_t val; + int error = omv_csi_ioctl(self->csi, OMV_CSI_IOCTL_BOSON_GET_GAIN_SWITCH_DESIRED, &val); + if (error != 0) { + omv_csi_raise_error(error); + } + return mp_obj_new_int_from_uint(val); +} +static MP_DEFINE_CONST_FUN_OBJ_1(py_csi_boson_get_gain_switch_desired_obj, py_csi_boson_get_gain_switch_desired); + +#endif // (OMV_BOSON_ENABLE == 1) + static const mp_rom_map_elem_t py_csi_locals_dict_table[] = { { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_CSI) }, { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&py_csi_deinit_obj) }, @@ -1469,6 +2565,112 @@ static const mp_rom_map_elem_t py_csi_locals_dict_table[] = { { MP_ROM_QSTR(MP_QSTR_color_palette), MP_ROM_PTR(&py_csi_color_palette_obj) }, { MP_ROM_QSTR(MP_QSTR___write_reg), MP_ROM_PTR(&py_csi_write_reg_obj) }, { MP_ROM_QSTR(MP_QSTR___read_reg), MP_ROM_PTR(&py_csi_read_reg_obj) }, + #if (OMV_BOSON_ENABLE == 1) + { MP_ROM_QSTR(MP_QSTR_boson_get_fpa_temp), MP_ROM_PTR(&py_csi_boson_get_fpa_temp_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_run_ffc), MP_ROM_PTR(&py_csi_boson_run_ffc_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_status), MP_ROM_PTR(&py_csi_boson_get_ffc_status_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_ffc_mode), MP_ROM_PTR(&py_csi_boson_set_ffc_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_gain_mode), MP_ROM_PTR(&py_csi_boson_set_gain_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_gain_mode), MP_ROM_PTR(&py_csi_boson_get_gain_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_agc_param), MP_ROM_PTR(&py_csi_boson_set_agc_param_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_image_stats), MP_ROM_PTR(&py_csi_boson_get_image_stats_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_stats_roi), MP_ROM_PTR(&py_csi_boson_set_stats_roi_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_isotherm_enable), MP_ROM_PTR(&py_csi_boson_set_isotherm_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_isotherm_temps), MP_ROM_PTR(&py_csi_boson_set_isotherm_temps_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_isotherm_unit), MP_ROM_PTR(&py_csi_boson_set_isotherm_unit_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_gain_switch), MP_ROM_PTR(&py_csi_boson_set_gain_switch_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_serial), MP_ROM_PTR(&py_csi_boson_get_serial_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_part_number), MP_ROM_PTR(&py_csi_boson_get_part_number_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_colorlut), MP_ROM_PTR(&py_csi_boson_set_colorlut_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_zoom), MP_ROM_PTR(&py_csi_boson_set_zoom_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_zoom), MP_ROM_PTR(&py_csi_boson_get_zoom_obj) }, + // Image Stats & Spot Meter + { MP_ROM_QSTR(MP_QSTR_boson_get_stats_roi), MP_ROM_PTR(&py_csi_boson_get_stats_roi_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_spot_meter_enable), MP_ROM_PTR(&py_csi_boson_set_spot_meter_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_spot_meter_enable), MP_ROM_PTR(&py_csi_boson_get_spot_meter_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_spot_meter_roi), MP_ROM_PTR(&py_csi_boson_set_spot_meter_roi_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_spot_meter_roi), MP_ROM_PTR(&py_csi_boson_get_spot_meter_roi_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_spot_meter_stats), MP_ROM_PTR(&py_csi_boson_get_spot_meter_stats_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_spot_meter_temp_stats), MP_ROM_PTR(&py_csi_boson_get_spot_meter_temp_stats_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_spot_meter_roi_max), MP_ROM_PTR(&py_csi_boson_get_spot_meter_roi_max_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_spot_meter_stats_mode), MP_ROM_PTR(&py_csi_boson_set_spot_meter_stats_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_spot_meter_stats_mode), MP_ROM_PTR(&py_csi_boson_get_spot_meter_stats_mode_obj) }, + // Isotherm Getters + { MP_ROM_QSTR(MP_QSTR_boson_get_isotherm_enable), MP_ROM_PTR(&py_csi_boson_get_isotherm_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_isotherm_unit), MP_ROM_PTR(&py_csi_boson_get_isotherm_unit_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_isotherm_temps), MP_ROM_PTR(&py_csi_boson_get_isotherm_temps_obj) }, + // Radiometry, Sensor Info & Overtemp + { MP_ROM_QSTR(MP_QSTR_boson_get_radiometry_capable), MP_ROM_PTR(&py_csi_boson_get_radiometry_capable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_radiometry_enable), MP_ROM_PTR(&py_csi_boson_set_radiometry_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_radiometry_enable), MP_ROM_PTR(&py_csi_boson_get_radiometry_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_tlinear_enable), MP_ROM_PTR(&py_csi_boson_set_tlinear_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_tlinear_enable), MP_ROM_PTR(&py_csi_boson_get_tlinear_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_emissivity), MP_ROM_PTR(&py_csi_boson_set_emissivity_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_emissivity), MP_ROM_PTR(&py_csi_boson_get_emissivity_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_sw_version), MP_ROM_PTR(&py_csi_boson_get_software_rev_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_sensor_sn), MP_ROM_PTR(&py_csi_boson_get_sensor_sn_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_overtemp_threshold), MP_ROM_PTR(&py_csi_boson_get_overtemp_threshold_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_overtemp_event_count), MP_ROM_PTR(&py_csi_boson_get_overtemp_event_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_low_power_mode), MP_ROM_PTR(&py_csi_boson_get_low_power_mode_obj) }, + // FFC control + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_mode), MP_ROM_PTR(&py_csi_boson_get_ffc_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_ffc_temp_threshold), MP_ROM_PTR(&py_csi_boson_set_ffc_temp_threshold_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_temp_threshold), MP_ROM_PTR(&py_csi_boson_get_ffc_temp_threshold_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_ffc_frame_threshold), MP_ROM_PTR(&py_csi_boson_set_ffc_frame_threshold_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_frame_threshold), MP_ROM_PTR(&py_csi_boson_get_ffc_frame_threshold_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_ffc_temp_threshold_lg), MP_ROM_PTR(&py_csi_boson_set_ffc_temp_threshold_lg_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_temp_threshold_lg), MP_ROM_PTR(&py_csi_boson_get_ffc_temp_threshold_lg_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_ffc_frame_threshold_lg), MP_ROM_PTR(&py_csi_boson_set_ffc_frame_threshold_lg_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_frame_threshold_lg), MP_ROM_PTR(&py_csi_boson_get_ffc_frame_threshold_lg_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_ffc_warn_time), MP_ROM_PTR(&py_csi_boson_set_ffc_warn_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_warn_time), MP_ROM_PTR(&py_csi_boson_get_ffc_warn_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_desired), MP_ROM_PTR(&py_csi_boson_get_ffc_desired_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_last_ffc_frame_count), MP_ROM_PTR(&py_csi_boson_get_last_ffc_frame_count_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_last_ffc_temp), MP_ROM_PTR(&py_csi_boson_get_last_ffc_temp_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_startup_ffc_period), MP_ROM_PTR(&py_csi_boson_set_startup_ffc_period_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_startup_ffc_period), MP_ROM_PTR(&py_csi_boson_get_startup_ffc_period_obj) }, + // FFC correction pipeline + { MP_ROM_QSTR(MP_QSTR_boson_set_scnr_enable), MP_ROM_PTR(&py_csi_boson_set_scnr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_scnr_enable), MP_ROM_PTR(&py_csi_boson_get_scnr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_tf_enable), MP_ROM_PTR(&py_csi_boson_set_tf_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_tf_enable), MP_ROM_PTR(&py_csi_boson_get_tf_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_spnr_enable), MP_ROM_PTR(&py_csi_boson_set_spnr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_spnr_enable), MP_ROM_PTR(&py_csi_boson_get_spnr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_bpr_enable), MP_ROM_PTR(&py_csi_boson_set_bpr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_bpr_enable), MP_ROM_PTR(&py_csi_boson_get_bpr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_lfsr_enable), MP_ROM_PTR(&py_csi_boson_set_lfsr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_lfsr_enable), MP_ROM_PTR(&py_csi_boson_get_lfsr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_srnr_enable), MP_ROM_PTR(&py_csi_boson_set_srnr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_srnr_enable), MP_ROM_PTR(&py_csi_boson_get_srnr_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_gao_enable), MP_ROM_PTR(&py_csi_boson_set_gao_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_gao_enable), MP_ROM_PTR(&py_csi_boson_get_gao_enable_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_ffc_pipe_state), MP_ROM_PTR(&py_csi_boson_set_ffc_pipe_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_ffc_pipe_state), MP_ROM_PTR(&py_csi_boson_get_ffc_pipe_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_sffc_state), MP_ROM_PTR(&py_csi_boson_set_sffc_state_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_sffc_state), MP_ROM_PTR(&py_csi_boson_get_sffc_state_obj) }, + // AGC control + { MP_ROM_QSTR(MP_QSTR_boson_set_agc_mode), MP_ROM_PTR(&py_csi_boson_set_agc_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_mode), MP_ROM_PTR(&py_csi_boson_get_agc_mode_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_agc_percent_per_bin), MP_ROM_PTR(&py_csi_boson_set_agc_percent_per_bin_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_percent_per_bin), MP_ROM_PTR(&py_csi_boson_get_agc_percent_per_bin_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_agc_outlier_cut), MP_ROM_PTR(&py_csi_boson_set_agc_outlier_cut_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_outlier_cut), MP_ROM_PTR(&py_csi_boson_get_agc_outlier_cut_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_agc_detail_headroom), MP_ROM_PTR(&py_csi_boson_set_agc_detail_headroom_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_detail_headroom), MP_ROM_PTR(&py_csi_boson_get_agc_detail_headroom_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_linear_percent), MP_ROM_PTR(&py_csi_boson_get_agc_linear_percent_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_d2br), MP_ROM_PTR(&py_csi_boson_get_agc_d2br_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_sigma_r), MP_ROM_PTR(&py_csi_boson_get_agc_sigma_r_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_max_gain), MP_ROM_PTR(&py_csi_boson_get_agc_max_gain_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_df), MP_ROM_PTR(&py_csi_boson_get_agc_df_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_agc_gamma), MP_ROM_PTR(&py_csi_boson_get_agc_gamma_obj) }, + // Dynamic range control + { MP_ROM_QSTR(MP_QSTR_boson_get_gain_switch_params), MP_ROM_PTR(&py_csi_boson_get_gain_switch_params_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_gain_switch_hyst_time), MP_ROM_PTR(&py_csi_boson_set_gain_switch_hyst_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_gain_switch_hyst_time), MP_ROM_PTR(&py_csi_boson_get_gain_switch_hyst_time_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_set_gain_switch_frame_thresh), MP_ROM_PTR(&py_csi_boson_set_gain_switch_frame_thresh_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_gain_switch_frame_thresh), MP_ROM_PTR(&py_csi_boson_get_gain_switch_frame_thresh_obj) }, + { MP_ROM_QSTR(MP_QSTR_boson_get_gain_switch_desired), MP_ROM_PTR(&py_csi_boson_get_gain_switch_desired_obj) }, + #endif }; MP_DEFINE_CONST_DICT(py_csi_locals_dict, py_csi_locals_dict_table); diff --git a/modules/py_image.c b/modules/py_image.c index 2795786af4..ffc01595da 100644 --- a/modules/py_image.c +++ b/modules/py_image.c @@ -1050,7 +1050,7 @@ static mp_obj_t py_image_to(pixformat_t pixfmt, mp_rom_obj_t default_color_palet if (temp_allocated) { temp.w = dst_img.w; temp.h = dst_img.h; - temp.pixfmt = src_img->is_color ? PIXFORMAT_RGB565 : PIXFORMAT_GRAYSCALE; + temp.pixfmt = (src_img->is_color || color_palette) ? PIXFORMAT_RGB565 : PIXFORMAT_GRAYSCALE; temp.size = 0; temp.data = uma_malloc(image_size(&temp), UMA_CACHE); imlib_draw_image(&temp, src_img, 0, 0, x_scale, y_scale, &roi,