def __init__(self):
"""Constructor for the internal state of the robot, e.g. in which direction he is
currently looking"""
self.direction = Directions.up
self.gy = GyroSensor()
self.steer_pair = MoveSteering(OUTPUT_A, OUTPUT_D, motor_class= LargeMotor)
self.zero_point = ColorSensor().reflected_light_intensity
self.s = Sensors()
def __init__(self):
self._state = {}
GPIO.setmode(GPIO.BCM)
self._gpio = GPIO
self._driver = Driver.Driver(self._gpio)
self._sensors = Sensors.Sensors(self._gpio)
self._vision = Vision.Vision((640, 480))
self._laser = Laser.Laser(self._gpio, 25)
def test_start(self):
sensor = Sensors()
sensor.stop()
self.assertEqual(sensor.isRunning(), False)
sensor.start()
self.assertEqual(sensor.isRunning(), True)
sensor.stop()
self.assertEqual(sensor.isRunning(), False)
def read(self):
if (self.curr_val_char is None):
print ("ERROR: Devices are not connected.")
sys.exit(1)
rawdata = self.curr_val_char.read()
rawdata = struct.unpack('BBBBHHHHHHHH', rawdata)
sensors = Sensors()
sensors.set(rawdata)
return sensors
def __init__(self):
self.ser = self._initialize_serial_communication() # establish serial communication
self._initialize_car() # initialize the car
self.sensor = Sensors() # initialize sensors
# first few frames of camera feed are low quality
for i in range(0, 10):
self.update_sensors()
self.action = CarActions(self) # allows us to perform hard-coded actions in the car
self.rf = NewFollower()
def __init__(self, buddy_configuration, logger):
"""
Initialize the object.
"""
self.__configuration__ = buddy_configuration
self.__logger__ = logger
self.__lcd__ = None
self.__lcd_status_id__ = 0
self.__initialize_lcd__()
self.__is_gas_detected__ = False
self.__system_start_time__ = datetime.datetime.now()
self.__sensors__ = Sensors(buddy_configuration)
serial_connection = self.__initialize_modem__()
if serial_connection is None and not local_debug.is_debug():
self.__logger__.log_warning_message(
"Unable to initialize serial connection, quiting.")
sys.exit()
self.__fona_manager__ = FonaManager(
self.__logger__, serial_connection,
self.__configuration__.cell_power_status_pin,
self.__configuration__.cell_ring_indicator_pin,
self.__configuration__.utc_offset)
# create heater relay instance
self.__relay_controller__ = RelayManager(
buddy_configuration, logger, self.__heater_turned_on_callback__,
self.__heater_turned_off_callback__,
self.__heater_max_time_off_callback__)
self.__gas_sensor_queue__ = MPQueue()
self.__logger__.log_info_message(
"Starting SMS monitoring and heater service")
self.__clear_existing_messages__()
self.__logger__.log_info_message("Begin monitoring for SMS messages")
self.__queue_message_to_all_numbers__(
"HangarBuddy monitoring started." + "\n" +
self.__get_help_status__())
self.__queue_message_to_all_numbers__(self.__get_full_status__())
self.__lcd__.clear()
self.__lcd__.write(0, 0, "Ready")
def __init__(self, lock):
threading.Thread.__init__(self)
self.shutdown_flag = threading.Event()
self.lock = lock
#Set GPIO interface
GPIO.setwarnings(False)
GPIO.cleanup() # Clean up previous configuration
GPIO.setmode(GPIO.BCM) # Specify the pin numbering system
# Set PWM cycle to generate 1.4 volts for MQ-7 sensors
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(16, GPIO.OUT)
self.pwm = GPIO.PWM(16, 100)
self.pwm.start(
14) # Generate a duty cycle capable of providing 1.4 volts
self.sensors = Sensors(MQ7_Ro, MQ2_Ro)
def test_init(self):
sensor = Sensors()
sensor.stop()
def test_isRaspPi(self):
sensor = Sensors()
self.assertEqual(sensor.isRaspberryPi, False)
sensor.stop()
self.assertEqual(sensor.isRunning(), False)
def test_door(self):
sensor = Sensors()
self.assertEqual(isinstance(sensor.doorIsOpen(), bool), True)
sensor.stop()
self.assertEqual(sensor.isRunning(), False)
import time
from datetime import datetime
import paho.mqtt.client as client
import paho.mqtt.publish as publish
from Sensors import Sensors
from getmac import get_mac_address
from pytz import timezone
# Author: Gary A. Stafford
# Date: 10/11/2020
# Usage: python3 sensor_data_to_mosquitto.py \
# --host "192.168.1.12" --port 1883 \
# --topic "sensor/output" --frequency 10
sensors = Sensors()
logger = logging.getLogger(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
def main():
args = parse_args()
publish_message_to_db(args)
def get_readings():
sensors.led_state(0)
# Retrieve sensor readings
payload_dht = sensors.get_sensor_data_dht()
def test_Temperature(self):
sensor = Sensors()
self.assertEqual(isinstance(sensor.getTemp(), int), True)
self.assertEqual(sensor.getTemp() > 0, True)
sensor.stop()
self.assertEqual(sensor.isRunning(), False)
def setUpClass():
sensor = Sensors()
time.sleep(2)
def do_GET(self):
sensors = Sensors()
# content_length = int (self.headers['Content-Length']) # <--- Gets the size of data
# post_data = self.rfile.read (content_length) # <--- Gets the data itself
response = BytesIO()
if (self.path == '/soil_humidity'):
s_h = sensors.get_soil_humidity()
print(s_h)
self._set_headers()
jsonString = JSONEncoder().encode({
"soil_humidity": s_h,
"time": time.asctime()
})
print(jsonString)
self.wfile.write(bytes(jsonString, "utf-8"))
elif (self.path == '/temperature'):
te = sensors.get_temperature()
print(te)
self._set_headers()
jsonString = JSONEncoder().encode({
"temperature": te,
"time": time.asctime()
})
print(jsonString)
self.wfile.write(bytes(jsonString, "utf-8"))
elif (self.path == '/rain'):
rain = sensors.get_rain()
print(rain)
self._set_headers()
jsonString = JSONEncoder().encode({
"rain": rain[0],
"rain_verbose": rain[1],
"time": time.asctime()
})
print(jsonString)
self.wfile.write(bytes(jsonString, "utf-8"))
elif (self.path == '/light'):
li = sensors.get_light()
print(li)
self._set_headers()
jsonString = JSONEncoder().encode({
"light": li[0],
"condition": li[1],
"time": time.asctime()
})
print(jsonString)
self.wfile.write(bytes(jsonString, "utf-8"))
else:
self.send_response(422)
self.send_header('Content-type', 'application/json')
self.end_headers()
#Author: Jack Clarke
from flask import Flask
from Sensors import Sensors
app = Flask(__name__)
sensor = Sensors()
@app.route("/temp")
def getTemp():
item = {"temp": sensor.getTemp()}
return item
@app.route("/door")
def doorOpen():
item = {"doorIsOpen": sensor.doorIsOpen()}
return item
@app.route("/brightness")
def getBrightness():
item = {"brightness": sensor.getBrightness()}
return item
@app.route("/humidity")
def getHumidity():
item = {"humidity": sensor.getHumidity()}
return item
udp_sender.join()
sensors.stop()
sensors.join()
Log("Application stopped")
sys.exit(0)
###############################################################################
## main #######################################################################
if __name__ == "__main__":
shutdown_application = Shutdown(shutdown_func=shutdown_application)
data = Sensordata()
display = Display(data)
udp_sender = UDP_Sender(data)
udp_sender.start()
sensors = Sensors(data, update_display=display.print)
sensors.start()
scheduler = Scheduler(data)
scheduler.start()
control = Control(data, scheduler)
control.start()
app.run(host="0.0.0.0")
# eof #
def test_Humidity(self):
sensor = Sensors()
self.assertEqual(isinstance(sensor.getHumidity(), int), True)
self.assertEqual(sensor.getHumidity() > 0, True)
sensor.stop()
self.assertEqual(sensor.isRunning(), False)
def test_Brightness(self):
sensor = Sensors()
self.assertEqual(isinstance(sensor.getBrightness(), int), True)
self.assertEqual(sensor.getBrightness() > 0, True)
sensor.stop()
self.assertEqual(sensor.isRunning(), False)
def setUp(self):
self.sensors = Sensors()
