def center_on_blob(b, res):
mapped_cx, mapped_cy = get_mapped_centroid(b)
# Switch to the res (if res was unchanged this does nothing).
sensor.set_framesize(res)
# Construct readout window. x/y are offsets from the center.
x = int(mapped_cx - (sensor_w / 2.0))
y = int(mapped_cy - (sensor_h / 2.0))
w = sensor.width()
h = sensor.height()
# Focus on the centroid.
sensor.ioctl(sensor.IOCTL_SET_READOUT_WINDOW, (x, y, w, h))
# See if we are hitting the edge.
new_x, new_y, w, h = sensor.ioctl(sensor.IOCTL_GET_READOUT_WINDOW)
# You can use these error values to drive servos to move the camera if you want.
x_error = x - new_x
y_error = y - new_y
if x_error < 0: print("-X Limit Reached ", end="")
if x_error > 0: print("+X Limit Reached ", end="")
if y_error < 0: print("-Y Limit Reached ", end="")
if y_error > 0: print("+Y Limit Reached ", end="")
def get_thermal_statistics(self):
string = ""
fpa_temp = sensor.ioctl(sensor.IOCTL_LEPTON_GET_FPA_TEMPERATURE)
aux_temp = sensor.ioctl(sensor.IOCTL_LEPTON_GET_AUX_TEMPERATURE)
string += "FPA {:.2f} AUX {:.2f}".format(fpa_temp, aux_temp)
string += "\n {:.2f} {:.2f} {:.2f}".format(self.temperature_mean,
self.temperature_max,
self.temperature_min)
return string
def get_mapped_centroid(b):
# By default the readout window is set the whole sensor pixel array with x/y==0.
# The resolution you see if produced by taking pixels from the readout window on
# the camera. The x/y location is relative to the sensor center.
x, y, w, h = sensor.ioctl(sensor.IOCTL_GET_READOUT_WINDOW)
# The camera driver will try to scale to fit whatever resolution you pass to max
# width/height that fit on the sensor while keeping the aspect ratio.
ratio = min(w / float(sensor.width()), h / float(sensor.height()))
# Reference cx() to the center of the viewport and then scale to the readout.
mapped_cx = (b.cx() - (sensor.width() / 2.0)) * ratio
# Since we are keeping the aspect ratio there might be an offset in x.
mapped_cx += (w - (sensor.width() * ratio)) / 2.0
# Add in our displacement from the sensor center
mapped_cx += x + (sensor_w / 2.0)
# Reference cy() to the center of the viewport and then scale to the readout.
mapped_cy = (b.cy() - (sensor.height() / 2.0)) * ratio
# Since we are keeping the aspect ratio there might be an offset in y.
mapped_cy += (h - (sensor.height() * ratio)) / 2.0
# Add in our displacement from the sensor center
mapped_cy += y + (sensor_h / 2.0)
return (mapped_cx, mapped_cy) # X/Y location on the sensor array.
def get_spotmeter_values(self):
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4ED0, 4)
radSpotmeterValue, radSpotmeterMaxValue, radSpotmeterMinValue, radSpotmeterPopulation = struct.unpack(
"<HHHH", data)
self.temperature_mean = self.tlinear2celcius(radSpotmeterValue)
self.temperature_max = self.tlinear2celcius(radSpotmeterMaxValue)
self.temperature_min = self.tlinear2celcius(radSpotmeterMinValue)
def receive_gain_mode(self):
# TODO switch modes
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x0248, 2)
self.gain_mode = struct.unpack("<I", data)[0]
#LEP_SYS_GAIN_MODE_HIGH = 0,
#LEP_SYS_GAIN_MODE_LOW,
#LEP_SYS_GAIN_MODE_AUTO,
self.logger.info("SYS Gain Mode", self.gain_mode)
def receive_flux_parameters(self):
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4EBC, 8)
self.sceneEmissivity, self.TBkgK, self.tauWindow, self.TWindowK, self.tauAtm, self.TAtmK, self.reflWindow, self.TReflK = struct.unpack(
"<HHHHHHHH", data)
self.logger.info(
"RAD Flux Linear Parameters:",
"\nsceneEmissivity",
self.sceneEmissivity,
"\nTBkgK",
self.TBkgK,
"\ntauWindow",
self.tauWindow,
"\nTWindowK",
self.TWindowK,
"\ntauAtm",
self.tauAtm,
"\nTAtmK",
self.TAtmK,
"\nreflWindow",
self.reflWindow,
"\nTReflK",
self.TReflK,
)
def setup():
# Color Tracking Thresholds (Grayscale Min, Grayscale Max)
global threshold_list
threshold_list = [(200, 255)]
# Set the target temp range here
min_temp_in_celsius = 0.0
max_temp_in_celsius = 64.0
print("Resetting Lepton...")
# These settings are applied on reset
sensor.reset()
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_MODE, True)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_RANGE,
min_temp_in_celsius, max_temp_in_celsius)
print("Lepton Res (%dx%d)" %
(sensor.ioctl(sensor.IOCTL_LEPTON_GET_WIDTH),
sensor.ioctl(sensor.IOCTL_LEPTON_GET_HEIGHT)))
print("Radiometry Available: " + (
"Yes" if sensor.ioctl(sensor.IOCTL_LEPTON_GET_RADIOMETRY) else "No"))
# FPS clock
global clock
clock = time.clock()
# Himax motion detection example.
import sensor, image, time, pyb
from pyb import Pin, ExtInt
sensor.reset()
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time=2000)
# The sensor is less noisy with lower FPS.
sensor.set_framerate(15)
# Configure and enable motion detection
sensor.ioctl(sensor.IOCTL_HIMAX_MD_THRESHOLD, 0x01)
sensor.ioctl(sensor.IOCTL_HIMAX_MD_WINDOW, (0, 0, 320, 240))
sensor.ioctl(sensor.IOCTL_HIMAX_MD_CLEAR)
sensor.ioctl(sensor.IOCTL_HIMAX_MD_ENABLE, True)
motion_detected = False
def on_motion(line):
global motion_detected
motion_detected = True
led = pyb.LED(3)
# Configure external interrupt pin. When motion is detected, this pin is pulled high
ext = ExtInt(Pin("PC15"), ExtInt.IRQ_RISING, Pin.PULL_DOWN, on_motion)
# This example shows off single color RGB565 tracking using the OpenMV Cam using the FLIR LEPTON.
# FLIR Lepton Shutter Note: FLIR Leptons with radiometry and a shutter will pause the video often
# as they heatup to re-calibrate. This will happen less and less often as the sensor temperature
# stablizes. You can force the re-calibration to not happen if you need to via the lepton API.
# However, it is not recommended because the image will degrade overtime.
import sensor, image, time, math
# Color Tracking Thresholds (L Min, L Max, A Min, A Max, B Min, B Max)
threshold_list = [( 70, 100, -30, 40, 20, 100)]
print("Resetting Lepton...")
# These settings are applied on reset
sensor.reset()
print("Lepton Res (%dx%d)" % (sensor.ioctl(sensor.IOCTL_LEPTON_GET_WIDTH),
sensor.ioctl(sensor.IOCTL_LEPTON_GET_HEIGHT)))
print("Radiometry Available: " + ("Yes" if sensor.ioctl(sensor.IOCTL_LEPTON_GET_RADIOMETRY) else "No"))
# Make the color palette cool
sensor.set_color_palette(sensor.PALETTE_IRONBOW)
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time=5000)
clock = time.clock()
# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are
# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the
# camera resolution. "merge=True" merges all overlapping blobs in the image.
while(True):
import sensor, image, time, math
# Color Tracking Thresholds (Grayscale Min, Grayscale Max)
threshold_list = [(100, 255)] # track very hot objects
# Set the target temp range here
# 500C is the maximum the Lepton 3.5 sensor can measure
# At room temperature it's max is ~380C
min_temp_in_celsius = 0.0
max_temp_in_celsius = 400.0
print("Resetting Lepton...")
# These settings are applied on reset
sensor.reset()
# Enable measurement mode with high temp
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_MODE, True, True)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_RANGE, min_temp_in_celsius,
max_temp_in_celsius)
print("Lepton Res (%dx%d)" % (sensor.ioctl(sensor.IOCTL_LEPTON_GET_WIDTH),
sensor.ioctl(sensor.IOCTL_LEPTON_GET_HEIGHT)))
print("Radiometry Available: " +
("Yes" if sensor.ioctl(sensor.IOCTL_LEPTON_GET_RADIOMETRY) else "No"))
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time=5000)
clock = time.clock()
# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are
# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the
# camera resolution. "merge=True" merges all overlapping blobs in the image.
# leptons don't have radiometry support or they don't activate their calibration process often
# enough to deal with temperature changes (FLIR 2.5).
import sensor, image, time, math
# Color Tracking Thresholds (Grayscale Min, Grayscale Max)
threshold_list = [(200, 255)]
# Set the target temp range here
min_temp_in_celsius = 25
max_temp_in_celsius = 42
print("Resetting Lepton...")
# These settings are applied on reset
sensor.reset()
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_MODE, True)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_RANGE, min_temp_in_celsius, max_temp_in_celsius)
print("Lepton Res (%dx%d)" % (sensor.ioctl(sensor.IOCTL_LEPTON_GET_WIDTH),
sensor.ioctl(sensor.IOCTL_LEPTON_GET_HEIGHT)))
print("Radiometry Available: " + ("Yes" if sensor.ioctl(sensor.IOCTL_LEPTON_GET_RADIOMETRY) else "No"))
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time=5000)
clock = time.clock()
# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are
# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the
# camera resolution. "merge=True" merges all overlapping blobs in the image.
i = 0
def thermal_fcc(self):
self.logger.info("SYS Run FFC Normalization")
sensor.ioctl(sensor.IOCTL_LEPTON_RUN_COMMAND, 0x0242)
self.logger.info("RAD FFC Normalization")
sensor.ioctl(sensor.IOCTL_LEPTON_RUN_COMMAND, 0x4E2E)
def send_gain_mode(self):
data = struct.pack("<I", self.gain_mode)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_ATTRIBUTE, 0x0249, data)
self.logger.info("Setting: SYS Gain Mode to ", self.gain_mode)
self.receive_gain_mode()
def send_flux_parameters(self):
data = struct.pack("<HHHHHHHH", self.sceneEmissivity, self.TBkgK,
self.tauWindow, self.TWindowK, self.tauAtm,
self.TAtmK, self.reflWindow, self.TReflK)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_ATTRIBUTE, 0x4EBD, data)
self.receive_flux_parameters()
# This example shows off single color grayscale tracking using the OpenMV Cam using the FLIR LEPTON.
# FLIR Lepton Shutter Note: FLIR Leptons with radiometry and a shutter will pause the video often
# as they heatup to re-calibrate. This will happen less and less often as the sensor temperature
# stablizes. You can force the re-calibration to not happen if you need to via the lepton API.
# However, it is not recommended because the image will degrade overtime.
import sensor, image, time, math, lcd
# Color Tracking Thresholds (Grayscale Min, Grayscale Max)
threshold_list = [(220, 255)]
print("Resetting Lepton...")
# These settings are applied on reset
sensor.reset()
print("Lepton Res (%dx%d)" % (sensor.ioctl(sensor.IOCTL_LEPTON_GET_WIDTH),
sensor.ioctl(sensor.IOCTL_LEPTON_GET_HEIGHT)))
print("Radiometry Available: " +
("Yes" if sensor.ioctl(sensor.IOCTL_LEPTON_GET_RADIOMETRY) else "No"))
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.LCD)
sensor.skip_frames(time=5000)
clock = time.clock()
lcd.init()
# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are
# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the
# camera resolution. "merge=True" merges all overlapping blobs in the image.
while (True):
# leptons don't have radiometry support or they don't activate their calibration process often
# enough to deal with temperature changes (FLIR 2.5).
import sensor, image, time, math
# Color Tracking Thresholds (Grayscale Min, Grayscale Max)
threshold_list = [(200, 255)]
# Set the target temp range here
min_temp_in_celsius = 20.0
max_temp_in_celsius = 35.0
print("Resetting Lepton...")
# These settings are applied on reset
sensor.reset()
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_MODE, True)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_RANGE, min_temp_in_celsius, max_temp_in_celsius)
print("Lepton Res (%dx%d)" % (sensor.ioctl(sensor.IOCTL_LEPTON_GET_WIDTH),
sensor.ioctl(sensor.IOCTL_LEPTON_GET_HEIGHT)))
print("Radiometry Available: " + ("Yes" if sensor.ioctl(sensor.IOCTL_LEPTON_GET_RADIOMETRY) else "No"))
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time=5000)
clock = time.clock()
# Only blobs that with more pixels than "pixel_threshold" and more area than "area_threshold" are
# returned by "find_blobs" below. Change "pixels_threshold" and "area_threshold" if you change the
# camera resolution. "merge=True" merges all overlapping blobs in the image.
def map_g_to_temp(g):
def send_thermal_static_range(self):
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_RANGE,
self.static_minimum, self.static_maximum)
# Global Shutter Triggered Mode Example
#
# This example shows off setting the global shutter camera into triggered mode. In triggered mode
# snapshot() controls EXACTLY when integration of the camera pixels start such that you can sync
# taking pictures to some external movement. Since the camera captures all pixels at the same time
# (as it is a global shutter camera versus a rolling shutter camera) movement in the image will
# only be captured for the integration time and not the integration time multipled by the number
# of rows in the image. Additionally, sensor noise is reduced in triggered mode as the camera will
# not read out rows until after exposing which results in a higher quality image.
#
# That said, your maximum frame rate will be reduced by 2 to 3 as camera are no longer generated
# continously by the camera and because you have to wait for the integration to finish before
# readout of the frame.
import sensor, image, time
sensor.reset() # Reset and initialize the sensor.
sensor.set_pixformat(sensor.GRAYSCALE) # Set pixel format to GRAYSCALE
sensor.set_framesize(sensor.VGA) # Set frame size to VGA (640x480)
sensor.skip_frames(time=2000) # Wait for settings take effect.
clock = time.clock() # Create a clock object to track the FPS.
sensor.ioctl(sensor.IOCTL_SET_TRIGGERED_MODE, True)
while (True):
clock.tick() # Update the FPS clock.
img = sensor.snapshot() # Take a picture and return the image.
print(
clock.fps()) # Note: OpenMV Cam runs about half as fast when connected
# to the IDE. The FPS should increase once disconnected.
def thermal_configure(self, static_range=None):
self.logger.info(
"##############################################################")
self.logger.info("SETTINGS")
if static_range is not None:
self.static_range = static_range
if self.static_range:
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_MODE, True)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_RANGE,
self.static_minimum, self.static_maximum)
else:
sensor.ioctl(sensor.IOCTL_LEPTON_SET_MEASUREMENT_MODE, False)
self.logger.info("Setting: AGC Enable and Disable (Enable)")
sensor.ioctl(sensor.IOCTL_LEPTON_SET_ATTRIBUTE, 0x0101,
struct.pack("<I", 1))
self.logger.info("Setting: RAD Radiometry Control Enable")
sensor.ioctl(sensor.IOCTL_LEPTON_SET_ATTRIBUTE, 0x4E11,
struct.pack("<I", 1))
self.logger.info(
"-------------------------------------------------------------")
self.logger.info("AGC:")
# TODO switch modes
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x0100, 2)
LEP_AGC_ENABLE_TAG = struct.unpack("<I", data)[0]
#LEP_AGC_DISABLE=0,
#LEP_AGC_ENABLE
self.logger.info("AGC Enable and Disable", LEP_AGC_ENABLE_TAG)
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x0148, 2)
LEP_AGC_ENABLE_TAG = struct.unpack("<I", data)[0]
#LEP_AGC_DISABLE=0,
#LEP_AGC_ENABLE
self.logger.info("AGC Calculation Enable State", LEP_AGC_ENABLE_TAG)
self.receive_gain_mode()
self.send_gain_mode()
#typedef struct LEP_SYS_GAIN_MODE_OBJ_T_TAG
#{
#FLR_SYS_GAIN_MODE_ROI_T sysGainModeROI; /* Specified ROI to use for Gain Mode switching */
#FLR_SYS_GAIN_MODE_THRESHOLDS_T sysGainModeThresholds; /* Set of threshold triggers */
#FLR_UINT16 sysGainRoiPopulation; /* Population size in pixels within the ROI */
#FLR_UINT16 sysGainModeTempEnabled; /* True if T-Linear is implemented */
#FLR_UINT16 sysGainModeFluxThresholdLowToHigh; /* calculated from desired temp */
#FLR_UINT16 sysGainModeFluxThresholdHighToLow; /* calculated from desired temp */
#}LEP_SYS_GAIN_MODE_OBJ_T, *LEP_SYS_GAIN_MODE_OBJ_T_PTR;
#typedef struct LEP_SYS_GAIN_MODE_ROI_T_TAG
#{
#LEP_UINT16 startCol;
#LEP_UINT16 startRow;
#LEP_UINT16 endCol;
#LEP_UINT16 endRow;
#}LEP_SYS_GAIN_MODE_ROI_T, *LEP_SYS_GAIN_MODE_ROI_T_PTR;
#/* Gain Mode Support
#*/
#typedef struct LEP_SYS_GAIN_MODE_THRESHOLDS_T_TAG
#{
#LEP_SYS_THRESHOLD_T sys_P_high_to_low; /* Range: [0 - 100], percent */
#LEP_SYS_THRESHOLD_T sys_P_low_to_high; /* Range: [0 - 100], percent */
#LEP_SYS_THRESHOLD_T sys_C_high_to_low; /* Range: [0 - 600], degrees C */
#LEP_SYS_THRESHOLD_T sys_C_low_to_high; /* Range: [0 - 600], degrees C */
#LEP_SYS_THRESHOLD_T sys_T_high_to_low; /* Range: [0 - 900], Kelvin */
#LEP_SYS_THRESHOLD_T sys_T_low_to_high; /* Range: [0 - 900], Kelvin */
#}LEP_SYS_GAIN_MODE_THRESHOLDS_T, *LEP_SYS_GAIN_MODE_THRESHOLDS_T_PTR;
#0x0250
###############################################################
# RADIOMETRY
self.logger.info(
"-------------------------------------------------------------")
self.logger.info("RADIOMETRY:")
self.thermal_fcc()
sensor.snapshot()
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4E24, 2)
FLR_RAD_TS_MODE_E_TAG = struct.unpack("<I", data)[0]
#FLR_RAD_TS_USER_MODE = 0
#FLR_RAD_TS_CAL_MODE = 1
#FLR_RAD_TS_FIXED_MODE = 2
#FLR_RAD_TS_END_TS_MODE = 3
self.logger.info("RAD TShutter Mode", FLR_RAD_TS_MODE_E_TAG)
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4E10, 2)
LEP_RAD_ENABLE_E_TAG = struct.unpack("<I", data)[0]
#LEP_RAD_DISABLE = 0,
#LEP_RAD_ENABLE,
self.logger.info("RAD Radiometry Control Enable", LEP_RAD_ENABLE_E_TAG)
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4E28, 1)
LEP_RAD_KELVIN_T = struct.unpack("<H", data)[0]
self.logger.info("RAD TShutter Temperature", LEP_RAD_KELVIN_T)
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4E30, 2)
LEP_RAD_STATUS_E = struct.unpack("<I", data)[0]
#LEP_RAD_STATUS_ERROR = -1,
#LEP_RAD_STATUS_READY = 0,
#LEP_RAD_STATUS_BUSY,
#LEP_RAD_FRAME_AVERAGE_COLLECTING_FRAMES
self.logger.info("RAD Run Status", LEP_RAD_STATUS_E)
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4EC0, 2)
LEP_RAD_ENABLE_E_TAG = struct.unpack("<I", data)[0]
#LEP_RAD_DISABLE = 0,
#LEP_RAD_ENABLE,
self.logger.info("RAD T-Linear Enable State", LEP_RAD_ENABLE_E_TAG)
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4EC8, 2)
LEP_RAD_ENABLE_E_TAG = struct.unpack("<I", data)[0]
#LEP_RAD_DISABLE = 0,
#LEP_RAD_ENABLE,
self.logger.info("RAD T-Linear Auto Resolution", LEP_RAD_ENABLE_E_TAG)
startRow = 0
startCol = 0
endRow = sensor.height() - 1
endCol = sensor.width() - 1
data = struct.pack("<HHHH", startRow, startCol, endRow, endCol)
sensor.ioctl(sensor.IOCTL_LEPTON_SET_ATTRIBUTE, 0x4ECD, data)
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4ECC, 4)
startRow_rx, startCol_rx, endRow_rx, endCol_rx = struct.unpack(
"<HHHH", data)
self.logger.info("Spotmeter {} {} {} {}".format(
startRow_rx, startCol_rx, endRow_rx, endCol_rx))
if startRow != startRow_rx or startCol != startCol_rx or endRow != endRow_rx or endCol != endCol_rx:
raise ValueError("Spotmeter wrong window")
data = sensor.ioctl(sensor.IOCTL_LEPTON_GET_ATTRIBUTE, 0x4EC4, 2)
self.thermal_tlinear_resolution = 0.01 if struct.unpack(
"<I", data)[0] else 0.1
self.logger.info("thermal_tlinear_resolution",
self.thermal_tlinear_resolution)
self.receive_flux_parameters()
self.send_flux_parameters()
self.logger.info(
"##############################################################")
TRACKING_PIXEL_THRESHOLD = TRACKING_AREA_THRESHOLD
TRACKING_EDGE_TOLERANCE = 0.05 # Blob can move 5% away from the center.
sensor.reset() # Reset and initialize the sensor.
sensor.set_pixformat(sensor.GRAYSCALE) # Set pixel format to GRAYSCALE
sensor.set_framesize(SEARCHING_RESOLUTION)
sensor.skip_frames(time = 1000) # Wait for settings take effect.
clock = time.clock() # Create a clock object to track the FPS.
sensor.set_auto_gain(False) # Turn off as it will oscillate.
sensor.set_auto_exposure(False, exposure_us=EXPOSURE_MICROSECONDS)
sensor.skip_frames(time = 1000)
# sensor_w and sensor_h are the image sensor raw pixels w/h (x/y are 0 initially).
x, y, sensor_w, sensor_h = sensor.ioctl(sensor.IOCTL_GET_READOUT_WINDOW)
while(True):
clock.tick()
img = sensor.snapshot()
# We need to find an IR object to track - it's likely to be really bright.
blobs = img.find_blobs(TRACKING_THRESHOLDS,
area_threshold=SEARCHING_AREA_THRESHOLD,
pixels_threshold=SEARCHING_PIXEL_THRESHOLD)
if len(blobs):
most_dense_blob = max(blobs, key = lambda x: x.density())
img.draw_rectangle(most_dense_blob.rect())
def get_mapped_centroid(b):
# Global Shutter Triggered Mode Example
#
# This example shows off setting the global shutter camera into triggered mode. In triggered mode
# snapshot() controls EXACTLY when integration of the camera pixels start such that you can sync
# taking pictures to some external movement. Since the camera captures all pixels at the same time
# (as it is a global shutter camera versus a rolling shutter camera) movement in the image will
# only be captured for the integration time and not the integration time multipled by the number
# of rows in the image. Additionally, sensor noise is reduced in triggered mode as the camera will
# not read out rows until after exposing which results in a higher quality image.
#
# That said, your maximum frame rate will be reduced by 2 to 3 as frames are no longer generated
# continously by the camera and because you have to wait for the integration to finish before
# readout of the frame.
import sensor, image, time
sensor.reset() # Reset and initialize the sensor.
sensor.set_pixformat(sensor.GRAYSCALE) # Set pixel format to GRAYSCALE
sensor.set_framesize(sensor.VGA) # Set frame size to VGA (640x480)
sensor.skip_frames(time = 2000) # Wait for settings take effect.
clock = time.clock() # Create a clock object to track the FPS.
sensor.ioctl(sensor.IOCTL_SET_TRIGGERED_MODE, True)
while(True):
clock.tick() # Update the FPS clock.
img = sensor.snapshot() # Take a picture and return the image.
print(clock.fps()) # Note: OpenMV Cam runs about half as fast when connected
# to the IDE. The FPS should increase once disconnected.
KEY = Pin('C13', Pin.IN, Pin.PULL_DOWN)
lcd.init(type=2, refresh=120)
clock = time.clock()
keycount = 0
while (True):
clock.tick()
img = sensor.snapshot()
print(clock.fps())
lcd.display(img)
if sensor.get_id() == sensor.OV5640:
if KEY.value() == 1:
while KEY.value() == 1:
blue_led.on()
sleep(0.05)
blue_led.off()
sleep(0.05)
keycount += 1
if keycount > 3:
sensor.ioctl(sensor.IOCTL_RESET_AUTO_FOCUS)
while KEY.value() == 1:
blue_led.on()
sleep(0.1)
blue_led.off()
sleep(0.1)
if keycount <= 3:
sensor.ioctl(sensor.IOCTL_TRIGGER_AUTO_FOCUS)
if keycount != 0:
sensor.ioctl(sensor.IOCTL_WAIT_ON_AUTO_FOCUS)
keycount = 0
# This examples shows how to use the Himax Motion Detection feature
# to wake up from low-power Stop Mode on motion detection interrupts.
import sensor, image, time, pyb, machine
from pyb import Pin, ExtInt
sensor.reset()
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QVGA)
sensor.set_framerate(15)
sensor.ioctl(sensor.IOCTL_HIMAX_MD_THRESHOLD, 10)
sensor.ioctl(sensor.IOCTL_HIMAX_MD_WINDOW, (0, 0, 320, 240))
sensor.ioctl(sensor.IOCTL_HIMAX_MD_CLEAR)
sensor.ioctl(sensor.IOCTL_HIMAX_MD_ENABLE, True)
def on_motion(line):
pass
led = pyb.LED(3)
ext = ExtInt(Pin("PC15"), ExtInt.IRQ_RISING, Pin.PULL_DOWN, on_motion)
while (True):
led.off()
sensor.ioctl(sensor.IOCTL_HIMAX_OSC_ENABLE, True) # Switch to internal OSC
sensor.ioctl(sensor.IOCTL_HIMAX_MD_CLEAR) # Clear MD flag
machine.sleep() # Enter low-power mode, will wake up on MD interrupt.
sensor.ioctl(sensor.IOCTL_HIMAX_OSC_ENABLE, False) # Switch back to MCLK
led.on()
