def start(core_queue: "mproc.Queue[str]", config_file: str) -> None:
def check_import(name: str) -> bool:
try:
lib = import_module(name)
del lib
except ModuleNotFoundError:
log.error("Missing import: %s", name)
return False
else:
return True
missing_imports = 0
for name in ["yaml", "yamlloader", "mprop", "adafruit_platformdetect", "periphery"]:
missing_imports += int(not check_import(name))
if missing_imports > 0:
log.error("Please see the wiki for instructions on how to install requirements")
core_queue.put_nowait(__name__)
else:
import gpio
gpio.init()
if _load_modules(config_file, core_queue):
_start_modules()
bus.start()
else:
core_queue.put_nowait(__name__)
def init():
global slip_driver
logger.info("Starting up EPP...")
try:
#init everything heretup here
gpio.init()
slip_driver = sliplib.Driver()
#raise
logger.info("Everything inited...")
except:
logger.error("Error while initing...")
def __init__(self, photo_storage_path, video_storage_path):
try:
self.pi_camera_pres = True
import pi_camera
except:
print("WARN : no pi camera library detected !")
self.pi_camera_pres = False
try:
self.gphoto_lib_pres = True
import gphoto
except:
print("WARN : no gphoto library detected !")
self.gphoto_lib_pres = False
# Display warning for deprecated Picamera functions (since v1.8)
warnings.filterwarnings('default', category=DeprecationWarning)
# Init pygame
pygame.init()
# GPIO
self.gpio = gpio.init(self.gpio_callback_func)
# Storage init
self.photo_storage = storage.init(photo_storage_path)
self.video_storage = storage.init(video_storage_path)
# Intialize gphoto library
if self.gphoto_lib_pres:
self.gp = gphoto.gphoto();
# Picamera object / objet Picamera
if self.pi_camera_pres:
self.pi_camera = pi_camera.camera()
# Start camera preview / Demarre affichage en direct
if self.pi_camera_pres:
self.pi_camera.start()
# Create interface
self.ihm = interface.init(pygame, self.pi_camera, "../images/fond.png", "../sounds/snapshot.wav")
self.capture = capture.init(self.photo_storage, self.video_storage, self.pi_camera)
# Initialize dubsmash
self.dubsmash = dubsmash.init(pygame, self.ihm, self.pi_camera, self.capture)
# Internal flag
self.led_garland_process_started = False
self.protect_gpio_double_press = False
def run_server():
# Initial GPIO
gpio.init()
# Enable custom Paste access logging
log_format = (
'[%(time)s] REQUES %(REQUEST_METHOD)s %(status)s %(REQUEST_URI)s '
'(%(REMOTE_ADDR)s) %(bytes)s')
app_logged = RaspiTransLogger(app, format=log_format)
# Mount the WSGI callable object (app) on the root directory
cherrypy.tree.graft(app_logged, '/')
# Set the configuration of the web server
cherrypy.config.update({
'engine.autoreload_on': True,
'log.screen': True,
'server.socket_port': 5002,
'server.socket_host': '0.0.0.0'
})
# Start the CherryPy WSGI web server
cherrypy.engine.start()
cherrypy.engine.block()
from action import *
import motion
import motordriver
from I2C_bus import I2C_bus #from libAX12/pythonBinding
import gpio
from threading import Thread
import sys, traceback
from robot import Robot
try:
I2C_bus.init(115200)
except Exception as e:
print("[-] Unable to start I2C communication (", str(e), "), exiting")
exit()
gpio.init()
robot = Robot()
robot.setPosition(500, 500)
robot.set_heading(0)
main = Sequence("main")
main.add_actions([
MoveToAction(robot, 700, 500).wait(),
MoveToAction(robot, 700, 700).wait()
])
main.wait().exec()
def main():
global ds1820
# config
config = configparser.ConfigParser()
config.read('/usr/local/etc/serialmon_01.ini')
try:
mail_oad = config["EMAIL"]["SEND_ONCE_A_DAY"]
mail_int = config["EMAIL"]["SEND_INTERVAL"]
log_int = config["LOGGING"]["INTERVAL"]
ds_val = config["LOGGING"]["DS1820"]
except KeyError:
mail_oad = ""
mail_int = ""
log_int = ""
ds_val = ""
log.info("main", "serialmon_01.ini not filled")
if ds_val.upper() == "YES":
ds1820 = 1
if ds_val.upper() == "ONLY":
ds1820 = 2
# init
readlval()
GPIO.init()
sensors.start()
webserver.start(gethtmltable, relstate, relupdate, GPIO.tcp_status)
try:
if mail_oad != "":
log.info("main", "email: once a day at {:s}".format(mail_oad))
schedule.every().day.at(mail_oad).do(once_a_day, 1)
if mail_int == "1":
log.info("main", "email: every hour")
schedule.every().hour.do(once_a_day, 1)
elif mail_int != "":
log.info("main", "email: every {:s} hours".format(mail_int))
schedule.every(int(mail_int)).hours.do(once_a_day, 1)
if log_int == "1":
log.info("main", "logging: every hour")
schedule.every().hour.do(once_a_hour)
elif log_int != "":
log.info("main", "logging: every {:s} hours".format(log_int))
schedule.every(int(log_int)).hours.do(once_a_hour)
except Exception as e:
log.info("main", "serialmon_01.ini: " + str(e))
# --------------------arguments---Debug or Fakeval-----
checkarguments()
# ---------------------running
ser = None
while True:
if ser == None:
ser = serial_init()
else:
if not ser.isOpen():
ser = serial_init()
else:
newline = str(ser.readline(), "utf-8")
analyze(newline)
GPIO.usb_blink(1)
if relstate() == 1:
if (time.time() - reltimer()) >= 60 * 60:
relupdate(0)
schedule.run_pending()
def init():
initialize("../Libs/libCrystalBase_RPi.so")
pSpecCore = initialize_core_api("../Libs/libCrystalCore_RPi.so")
pSpecDevice = initialize_device_api("../Libs/libCrystalPort_RPi.so")
initialize_color_api(pSpecCore)
connectReturn = connect_device(
pSpecDevice) # return total num of devices connected with system
if connectReturn > 0:
(ret, sensorID) = get_sensor_id_device(pSpecDevice)
create_core_object(pSpecCore)
if sys.platform == 'win32':
csInit_Return = load_sensor_file(
pSpecCore, b"..\config\sensor_" + sensorID + b".dat")
else:
csInit_Return = load_sensor_file(
pSpecCore, b"../config/sensor_" + sensorID + b".dat")
(ret, sensorID) = get_sensor_id_file(pSpecCore)
get_sensor_parameters_from_device(pSpecDevice)
(adcGain,
adcRange) = get_sensor_parameters_from_calibration_file(pSpecCore)
settingReturn = set_sensor_parameters_to_device(
pSpecDevice, adcGain, adcRange)
total_num_of_sensors = total_sensors_connected(pSpecDevice)
get_capacity_sensor_data_list(pSpecCore)
for index in range(total_num_of_sensors):
#activate a specific device(sensor)
activatingReturn = index_activation(pSpecDevice, index)
#get sensor id of currently activated device(sensor)
(ret, sensorID) = get_sensor_id_device(pSpecDevice)
#get and set shutter speed of device(sensor)
get_shutter_speed(pSpecDevice)
set_shutter_speed(pSpecDevice, 1)
#get one filter output (sensor data)
filterData = get_filter_data(pSpecDevice, 20)
#set background data
set_background_data(pSpecCore, filterData)
#get and set shutter speed of device(sensor)
get_shutter_speed(pSpecDevice)
valid_filters_num = get_num_of_valid_filters(pSpecCore)
valid_filters = get_valid_filters(pSpecCore)
#Get shutter speed with AE
# newSS = get_optimal_shutter_speed(pSpecDevice,valid_filters_num,valid_filters)
# print ("newSS" + str(newSS))
# Fix shutter speed at 100
newSS = 100
set_shutter_speed(pSpecDevice, newSS)
#convert shutter speed to exposure time (ms) for your reference
ss_to_exposure_time(pSpecDevice, 5, newSS)
gpio.init()
while (True):
main_loop(pSpecCore, pSpecDevice, newSS)
# main_loop(pSpecCore, pSpecDevice, newSS);
else:
print(
"**********************************************************************"
)
print(
"[PrismError]Device Not Connected. Please connect Device and try again."
)
print(
"**********************************************************************"
)
close_color_api(pSpecCore)
close_core_object(pSpecCore)
disconnect_device(pSpecDevice)