def __init__(self):
self.__vcgencmd = Vcgencmd()
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(11, GPIO.IN, pull_up_down=GPIO.PUD_UP) #PIR data
GPIO.setup(15, GPIO.IN, pull_up_down=GPIO.PUD_UP) #View change button
GPIO.setup(13, GPIO.IN,
pull_up_down=GPIO.PUD_UP) #Display on/off button
GPIO.setup(5, GPIO.IN, pull_up_down=GPIO.PUD_UP) #power up/down button
self.__pwm = pigpio.pi()
GPIO.add_event_detect(15,
GPIO.FALLING,
callback=self.viewChange,
bouncetime=250)
GPIO.add_event_detect(13,
GPIO.FALLING,
callback=self.displayToggle,
bouncetime=500)
GPIO.add_event_detect(5,
GPIO.FALLING,
callback=self.shutdown,
bouncetime=2000)
def __init__(self):
#login or not login
self.login = False
self.userName = None
#Get hw sensor
self.lis3mdl = LIS3MDL()
self.lis3mdl.enable()
self.lps25h = LPS25H()
self.lps25h.enable()
self.lsm6ds33 = LSM6DS33()
self.lsm6ds33.enable()
self.vcgm = Vcgencmd()
self.next_call = time.time()
#init MQTT Client
self.client = paho.Client()
self.client.connect(host='localhost', port=1883)
self.client.on_subscribe = self.on_subscribe
self.client.message_callback_add(constants.local_com2_car_topic,
self.on_com2car)
self.client.message_callback_add(constants.local_RFID_topic,
self.on_RFID)
self.client.subscribe(constants.local_subscription)
self.client.loop_start()
#init some sensor values
self.humidity = 40
self.speed = 0
self.steeringAngle = 0
self.LIDAR = 10
self.userLoginLogout()
def getPiThrottled():
vcgm = Vcgencmd()
thrott_state = vcgm.get_throttled()
# print("Get Throttled = ", thrott_state)
return thrott_state
def gpu():
vcgm = Vcgencmd()
return {
'temp': vcgm.measure_temp(),
'clockSpeed': '{0:.0f} MHz'.format(vcgm.measure_clock('core') / 1e+6),
'volts': '{0} V'.format(vcgm.measure_volts('core')),
}
def detect(self):
vcgm = Vcgencmd()
status = vcgm.get_camera()
detected = status['detected']
if detected == 1:
return True
else:
return False
def main():
global test_msg, send_static_test_msg, test_gui_and_comm_task
def on_publish(client, userdata, result):
print("data published")
def on_message(client, userdata, msg):
dict = json.loads(msg.payload.decode('utf-8'))
print(dict)
#signal Handler (Ctrl+C)
def signalHandler(sig, frame):
client.loop_stop()
print("user stopped process")
sys.exit(0)
if test_gui_and_comm_task:
host = 'localhost'
port = 1883
else:
host = '192.168.200.165'
port = 8883
qos = 2
topic = '/SysArch/V3/sensor'
#register signalHandler
signal.signal(signal.SIGINT, signalHandler)
# cpu temperature
vcgm = Vcgencmd()
#init MQTT Client
client = paho.Client()
# username and password
client.username_pw_set(username="******", password="******")
# connect to broker
client.connect(host=host, port=port, keepalive=60)
client.on_publish = on_publish
client.on_message = on_message
# subscribe
client.subscribe(topic, qos=qos)
client.loop_start() # for qos 1, 2 and subscription
#measurement Loop
while True:
temperature = str(vcgm.measure_temp())
timestamp = str(time.time())
if send_static_test_msg:
dict = test_msg
else:
dict = {'timestamp': timestamp, 'temperature': temperature}
# publish
if test_gui_and_comm_task:
client.publish("/SysArch/V3/com2/car", json.dumps(dict), qos=2)
client.publish("local/com2/web", json.dumps(dict), qos=2)
client.publish("local/sensor", json.dumps(dict), qos=0)
else:
client.publish(topic, json.dumps(dict), qos=qos)
time.sleep(0.5)
def main():
fan = PWMLED(18)
while True:
vcgm = Vcgencmd()
temp = vcgm.measure_temp()
if temp >= 40:
fan.on()
elif temp <= 35:
fan.off()
time.sleep(1)
def initialize_status():
global motion_active
global start_motion_time
global last_motion_time
vcgm = Vcgencmd()
output = vcgm.display_power_state(screen_id)
if output == 'on':
start_motion_time = last_motion_time = time.time()
motion_active = True
message = 'Initializing screen state as {}'.format(motion_active)
notify_screen_state(message)
def __init__(self):
self.__vcgencmd = Vcgencmd()
self.__pwm = pigpio.pi()
self.__valChange = ["None", "None", "None"]
self.__fonts = [0] * 8
self.__cSize = 0
self.__scheduler = BackgroundScheduler()
self.__scheduler.start()
self.__sleepF1 = True
self.__sleepF2 = True
self.__stayOffFlag = False
controls_config = config['smartchime']['controls']
fonts_config = oled_config['fonts'][0]
# Enable or disable major functions and provide that state to the state tracker.
state_tracker.oled_enabled = oled_config['enabled']
state_tracker.amoled_enabled = amoled_config['enabled']
state_tracker.doorbell_enabled = doorbell_config['enabled']
state_tracker.controls_enabled = controls_config['enabled']
state_tracker.mqtt_enabled = mqtt_config['enabled']
# Set up the AMOLED display.
if state_tracker.amoled_enabled:
print("[main] initializing AMOLED display")
state_tracker.amoled_always_on = amoled_config['always_on']
state_tracker.amoled_display_id = amoled_config['display_id']
state_tracker.amoled = Vcgencmd()
if state_tracker.amoled_always_on:
state_tracker.amoled.display_power_on(
state_tracker.amoled_display_id)
# Initialize the OLED display.
if state_tracker.oled_enabled:
print("[main] Initializing OLED display")
device = get_device()
image_composition = ImageComposition(device)
state_tracker.oled_default_font = make_font(
fonts_config['font_large'][0]['name'],
fonts_config['font_large'][0]['size'])
state_tracker.oled_small_font = make_font(
fonts_config['font_small'][0]['name'],
import argparse
from flask import Flask, jsonify
import os
import logging
from vcgencmd import Vcgencmd
#import app_config
#HDMI steuern
#https://pypi.org/project/vcgencmd/#:~:text='vcgencmd'%20is%20a%20command%20line,a%20binding%20to%20that%20tool.
#vcgencmd display_power 0
app = Flask(__name__)
hdmi = Vcgencmd()
@app.route('/api/hdmi/on')
def hdmiOn():
#os.system("vcgencmd display_power 1")
hdmi.display_power_on(2)
return "on"
@app.route('/api/hdmi/off')
def hdmiOff():
#os.system("vcgencmd display_power 0")
hdmi.display_power_off(2)
return "off"
@app.route('/api/hdmi/status')
# commit to drive
csvfile.flush()
except Exception as e:
print("not logged: " + str(e))
def get_date():
now_date = datetime.datetime.now()
datetime_string = now_date.strftime("%H:%M:%S")
return datetime_string
def get_datetime():
now_date = datetime.datetime.now()
datetime_string = now_date.strftime("%b %d %Y %H:%M:%S")
return datetime_string
vcgm = Vcgencmd()
try:
interval = float(sys.argv[1])
print("running at an interval of " + str(interval) + " seconds.")
except Exception as e:
print(str(e))
print("note: you can pass the loop interval as a value in seconds, e.g. voltage_check.py 0.5")
interval = 1
num_errors = 0
last_error = ""
while True:
status = []
row = [get_date(),0,0,0,0,0,0,0,0]
sum_bits = 0
def __init__(self, node):
"""Init selftest with node."""
self.node = node
self.lcd_driver = self.node.create_publisher(Lcd, "lcd", 1)
# Wait for subscribers
while self.lcd_driver.get_subscription_count() < 1:
sleep(1)
self.__write__(0) # Report selftest init
if "aarch64" not in machine():
return
self.__write__(0x10) # Started Hardware tests
# Testing for CPU Throttling
vcgm = Vcgencmd()
self.__write__(0x11)
if int(vcgm.get_throttled().get("raw_data"), 16) != 0:
return
# Testing devices on sensors I2C Bus
addrs_vlx = []
if node.name == "obelix":
addrs_vlx = [0x30, 0x31, 0x32, 0x35, 0x36, 0x37]
try:
bus = SMBus(4)
for addr in addrs_vlx:
self.__write__(addr)
bus.read_byte(addr)
except BaseException:
return
# Testing devices on actuators I2C Bus
code = 0x40
self.__write__(code)
try:
bus = SMBus(3)
for addr in self.node.actuators.pump_addr:
code += 1
self.__write__(code)
bus.read_byte(addr)
"""
if node.name == "obelix":
addr_slider = 0x12
self.__write__(addr_slider)
bus.read_byte(addr_slider)
"""
except BaseException:
return
# NOTE : Testing devices on accessories bus (I2C6 is not relevant)
# due to the LCD being present
# Testing dynamixels connection
code = 0x50
if node.name == "obelix":
self.__write__(code)
for dyna in self.node.actuators.DYNAMIXELS:
code += 1
self.__write__(code)
if self.node.actuators.arbotix.getPosition(dyna) == -1:
return
for servo in self.node.actuators.SERVOS:
servo = self.node.actuators.SERVOS.get(servo)
code += 1
self.__write__(code)
if self.node.actuators.arbotix.getPosition(servo.get("addr")) == -1:
return
self.__write__(0xFF)
def __init__(self, logFile):
# Initialize
self.logDir = path.dirname(__file__) # Setup log file
self.logFile = logFile
Path(path.join(self.logDir, self.logFile)).touch(exist_ok = True)
self.vcgm = Vcgencmd() # Create vcgm object
def turn_on_screen():
print('turning on screen')
vcgm = Vcgencmd()
output = vcgm.display_power_on(screen_id)
def voltage(self) -> float:
v = Vcgencmd().measure_volts("sdram_p")
if isinstance(v, float):
return v
return 0.00
def turn_on_screen():
vcgm = Vcgencmd()
output = vcgm.display_power_on(screen_id)
logging.info('Turning on screen')
notify_screen_state('Turning on screen')