def __init__(self,io): #Initialisation
Sensors.__init__(self, io )
self.X_difference = 0.0 #Reading difference of light sensors in X-axis
self.Y_difference = 0.0 #Reading difference of light sensors in X-axis
self.current_reading_of_light_sensors = [0.0, 0.0, 0.0, 0.0] #Variable for collecting current readings of Light sensors
self.X_diff_normalised = 0.0
self.Y_diff_normalised = 0.0
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 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,io):
Sensors.__init__(self, io )
#self.IO = io
self.BR = (0,0)
self.BL = (0,0)
self.button_1_pressed = False
self.button_2_pressed = False
self.button_3_pressed = False
class SensorsModule(threading.Thread):
"""Obtain data from the Sensors installed in the device."""
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 run(self):
global sensor_data
print('* Sensors module has started')
sys.stdout.flush()
sensor_data_aux = {}
# First measurement
self.lock.acquire()
sensor_data = self.sensors.getSensorData().copy()
self.lock.release()
while not self.shutdown_flag.is_set():
# Obtain data from sensors
self.pwm.start(
14
) # Generate a duty cycle capable of providing 1.4 volts to MQ-7
time.sleep(60) # Wait 60 seconds to obtain results
sensor_data_aux = self.sensors.getSensorData().copy()
# Apply smoothed average and copy the data into the global variable
self.lock.acquire()
for k, v in sensor_data_aux.items():
sensor_data[k] = ALPHA * v + (1 - ALPHA) * sensor_data[k]
self.lock.release()
self.pwm.start(
100
) # Generate a duty cycle capable of providing 1.4 volts to MQ-7
time.sleep(90)
print('* Sensors module has stopped')
sys.stdout.flush()
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()
class SensorsTest(unittest.TestCase):
def setUp(self):
self.sensors = Sensors()
def tearDown(self):
pass
def test_update(self):
self.sensors.discover()
self.assertEqual(len(self.sensors), 1)
before = self.sensors[0].getReadings()
self.sensors.update_environmental_data()
self.sensors.update_environmental_data()
after = self.sensors[0].getReadings()
self.assertEqual(after['counter']['value'], before['counter']['value']+1)
def slave(timeout=6):
nrf.listen = True # put radio into RX mode and power up
start_timer = time.monotonic() # used as a timeout
while (time.monotonic() - start_timer) < timeout:
humidity, temp = Sensors.readTempHumid()
if nrf.available():
length = nrf.any() # grab payload length info
pipe = nrf.pipe # grab pipe number info
received = nrf.read(length) # clears info from any() and nrf.pipe
question = received.decode('utf-8')
nrf.listen = False # put the radio in TX mode
result = False
ack_timeout = time.monotonic_ns() + 200000000
while not result and time.monotonic_ns() < ack_timeout:
# try to send reply for 200 milliseconds (at most)
answer = bytes(str(humidity), 'utf-8')
result = nrf.send(answer)
nrf.listen = True # put the radio back in RX mode
print(
"Received {} Sent: {}".format(
bytes(received).decode("utf-8"),
answer.decode('utf-8'),
),
end=" ", flush=True
)
print("", flush=True)
if not result:
print("Response failed or timed out", flush=True)
start_timer = time.monotonic() # reset timeout
# recommended behavior is to keep in TX mode when in idle
nrf.listen = False # put the nRF24L01 in TX mode + Standby-I power state
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 __init__(self, io):
Sensors.__init__(self, io)
# Collision to the left IR
self.LeftIRcollision = (0, 0)
# Collision to the right IR
self.RightIRcollision = (0, 0)
# Collision to the Sonar
self.SonarCollison = (0, 0)
# Thresholds of its sensor
self.left_IR_limit = 414 # 15 #480
self.right_IR_limit = 414
self.sonar_limit = 22 # 22
self.turn = 1
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 __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 listen(timeout=3):
nrf.listen = True # put radio into RX mode and power up
start_timer = time.monotonic() # used as a timeout
while (time.monotonic() - start_timer) < timeout:
if nrf.available():
length = nrf.any() # grab payload length info
question = nrf.read(length) # clears info from any() and nrf.pipe
nrf.listen = False # put the radio in TX mode
result = False
ack_timeout = time.monotonic_ns() + 200000000
while not result and time.monotonic_ns() < ack_timeout:
# try to send reply for 200 milliseconds (at most)
answer = bytes(Sensors.getAnswer(question),
'utf-8') #convert answer to bytes
result = nrf.send(answer)
nrf.listen = True # put the radio back in RX mode
if not result:
print("Response failed or timed out")
start_timer = time.monotonic() # reset timeout
nrf.listen = False # put the nRF24L01 in TX mode + Standby-I power state
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 #
from DHT import DHT from Sensors import Sensors from File import File from MySQL import * from MongoDB import * import sys newSQL = MySQL() newMongo = MongoDB() newSQL.Conexion() newMongo.mongoConexion() sensors = Sensors() sensorList = sensors.getAllInstance() print(sensorList) sensorList.returnData()
def setUp(self):
self.sensors = Sensors()
class Robot():
#"""Class for roboter movements."""
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 gyro_reset(self):
"""Method to reset the GyroSensor to 0"""
self.gy.mode = 'GYRO-RATE'
self.gy.mode = 'GYRO-ANG'
def steer_pair_l(self):
"""Method to initalise the steering to the right side with speed set to 100"""
self.steer_pair.on(steering=-100, speed=30)
def steer_pair_r(self):
"""Method to initalise the steering to the left side with speed set to 100"""
self.steer_pair.on(steering=100, speed=30)
def steer_pair_stop(self):
self.steer_pair.off(True)
def turn(self, direction, count):
"""Method to calculate the right degree to turn. LEGOlas can move in the directions Up, Down, LEft, Right. Count tells LEGOlas how many squares he schould move forward in the same direction"""
self.gyro_reset()
degrees_to_turn = self.direction - direction
#print('degrees_to_turn:', degrees_to_turn)
if degrees_to_turn == 0:
self.forward(self.cm_to_sec(count, 40), -1, count)
return
switcher = {
-3: self.turn_left, #reference to method turn_x (in this "switch" only references are allowed)
-2: self.turn_back,
-1: self.turn_right,
1: self.turn_left,
2: self.turn_back,
3: self.turn_right,
}
func = switcher.get(degrees_to_turn, "Invalid direction")
func(count)
self.direction = direction
#print(self.direction)
def turn_right(self, count):
"""Method to turn LEGOlas 90° to the right"""
lines_passed = 0
self.gyro_reset()
self.steer_pair_r()
while self.gy.value() < 90:
print("gy.value: " ,self.gy.value())
if self.zero_point < 20:
print("new")
sleep(0.1)
self.zero_point = ColorSensor().reflected_light_intensity
if self.s.offset == self.zero_point: #Überlegen wie man reichweite von +/- 2 machen kann
print(self.s.offset, self.zero_point)
sleep(0.25)
if lines_passed == 3:
sleep(0.05)
print("Ende vong 1 Drehen her")
self.steer_pair_stop()
break
lines_passed += 1
self.forward(self.cm_to_sec(count, 40), -1, count)
def turn_left(self, count):
"""Method to turn LEGOlas 90° to the left"""
lines_passed = 0
self.gyro_reset()
self.steer_pair_l()
while self.gy.value() > -100:
print("gy.value: " ,self.gy.value())
if self.zero_point < 20:
print("new")
sleep(0.1)
self.zero_point = ColorSensor().reflected_light_intensity
if self.s.offset == self.zero_point: #Überlegen wie man reichweite von +/- 2 machen kann
print(self.s.offset, self.zero_point)
sleep(0.25)
if lines_passed == 3:
sleep(0.05)
print("Ende vong 1 Drehen her")
self.steer_pair_stop()
break
lines_passed += 1
self.forward(self.cm_to_sec(count, 40), 1, count)
def turn_back(self, count):
"""Method to turn LEGOlas 180° around"""
lines_passed = 0
self.gyro_reset()
self.steer_pair_r()
while self.gy.value() < 200:
if self.zero_point < 20:
print("new")
sleep(0.1)
self.zero_point = ColorSensor().reflected_light_intensity
if self.s.offset == self.zero_point: #Überlegen wie man reichweite von +/- 2 machen kann
sleep(0.25)
if lines_passed == 3:
print("Ende vong 1 Drehen her")
sleep(0.05)
self.steer_pair_stop()
break
lines_passed += 1
self.forward(self.cm_to_sec(count, 40), 1, count)
def forward(self, x, y, count):
"""Method for driving the robot x seconds forward until LEGOlas reached a crossing"""
self.s.pid(x, y, count)
sleep(1)
def cm_to_sec(self, cm, speed):
"""Function to calculate how many seconds the roboter have to move with speed x to drive n cm"""
sec = 0.0
ref_sec = 2.925
ref_cm = 1
ref_speed = 1
sec = ref_sec * cm / speed
print('sec: ', sec)
return sec
#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
def setUpClass():
sensor = Sensors()
time.sleep(2)
t.run = False
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
mp = ALProxy('ALMotion', Config.nao_ip_port[0], Config.nao_ip_port[1])
#mp = ALProxy('ALMotion', '127.0.0.1', 9559)
# Set stiffness
pNames = "Body"
pStiffnessLists = 0.8
pTimeLists = 1.0
mp.stiffnessInterpolation(pNames, pStiffnessLists, pTimeLists)
t = Sensors()
t.start()
sleep(1)
RSRollOmejitve = (-1.6494, -0.0087)
RSPitchOmejitve = (-2.0857, 2.0857)
RERollOmejitve = (0.0087, 1.5621)
REYawOmejitve = (-2.0857, 2.0857)
RWYawOmejitve = (-1.8238, 1.8238)
i = 0
startTime = clock()
naoControll = False
dataI = t.forearm.i
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)
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 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)
question = nrf.read(length) # clears info from any() and nrf.pipe
nrf.listen = False # put the radio in TX mode
result = False
ack_timeout = time.monotonic_ns() + 200000000
while not result and time.monotonic_ns() < ack_timeout:
# try to send reply for 200 milliseconds (at most)
answer = bytes(Sensors.getAnswer(question),
'utf-8') #convert answer to bytes
result = nrf.send(answer)
nrf.listen = True # put the radio back in RX mode
if not result:
print("Response failed or timed out")
start_timer = time.monotonic() # reset timeout
nrf.listen = False # put the nRF24L01 in TX mode + Standby-I power state
Sensors = Sensors()
if __name__ == "__main__":
try:
while True:
Sensors.populateAnswers()
listen()
except KeyboardInterrupt:
print(" Keyboard Interrupt detected. Powering down radio...")
nrf.power = False
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)
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_init(self):
sensor = Sensors()
sensor.stop()
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()
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)
class CarControl:
"""
This class will be used to control the car.
"""
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 = ReddFollower()
def update_sensors(self):
"""
updates the sensors values
:return:
"""
self.sensor.update_sensors()
def drive(self, speed):
"""
Commands the car to drive.
:param speed: -2.0 to 2.0
:return: nothing
"""
self._send_command("!speed" + str(speed) + "\n")
def steer(self, degree):
"""
Commands the car to turn.
:param degree: -30.0 to 30.0
:return: nothing
"""
self._send_command("!steering" + str(degree) + "\n")
def _initialize_serial_communication(self):
"""
Initializes the serial communication.
:return: Object required for communication.
"""
print("Initializing Serial Communications")
ser = serial.Serial("/dev/ttyUSB0", 115200)
time.sleep(2) # must sleep for a bit while initializing
print("Flushing Input")
ser.flushInput()
time.sleep(1) # must sleep for a bit while initializing
return ser
def _send_command(self, command, addnewline=False):
"""
Sends a command to the car. Remember that every command must end with a new line.
Author: redd
"""
if addnewline:
command = command + "\n"
self.ser.write(command.encode())
def _initialize_car(self, pid_flag=True):
"""
Initializes the car. This must be run before we can control the car.
Author: redd
"""
print("Initializing Car")
self._send_command("!straight1430\n")
self._send_command("!kp0.01\n")
self._send_command("!kd0.01\n")
if pid_flag:
self._send_command("!pid1\n")
else:
self._send_command("!pid0\n")
self._send_command("!start1590\n")
self.drive(0.0)
print("Initialization Completed")
