def __init__(self,
arduino=None,
android=None,
fakeRun=False,
fakeMap=None,
stepsPerSec=1,
**kwargs):
"""
Constructor. Accepts attributes as kwargs.
Args:
fakeRun: set True if running simulation. Remember to give fake map as input. I.e: fakeMap = fakemap
fakeMap: set simulation map. If left empty, creates an empty arena.
pos: a 15x20 array. Contains None, 0 or 1 as values.
orientation: Centre of 3x3 start area. Default = [1,1]
map: Map object. Refer to Map.py
sensors: Sensors object. Refer to sensors.py
coordinator: Coordinator object. Refer to coordinator.py
"""
if fakeRun:
self.fakeRun = True
from sensors_fake import Sensors
self.sensors = Sensors(self, fakeMap) #fake sensors for simulation
self.coordinator.fakeRun = True
self.coordinator.stepsPerSec = stepsPerSec
self.imagefinder = Imagefinder(fakeRun=True)
elif arduino is None:
raise Exception("Real run requires arduino to be present")
elif android is None:
raise Exception("Real run requires arduino to be present")
else:
from sensors import Sensors
self.android = android
self.sensors = Sensors(self, arduino)
self.coordinator.arduino = arduino
self.imagefinder = Imagefinder()
#update map
self.updatemap()
goalTiles = [ #set goal as explored
[12, 19],
[13, 19],
[14, 19],
[12, 18],
[13, 18],
[14, 18],
[12, 17],
[13, 17],
[14, 17],
]
valuelist = [0] * len(goalTiles)
self.map.setTiles(goalTiles, valuelist)
#initialise pathfinder
self.pathfinder = Pathfinder(self.map)
#initialise explorer
self.explorer = Explorer(self)
def main():
# Conexão com bd
connection = DbConnector(
cnn['host'],
cnn['port'],
cnn['database']
)
db = connection.connect()
sensor_db = db.sensores
# Criando lista de sensores
sensores_list = [
Sensors("Sensor 01"),
Sensors("Sensor 02"),
Sensors("Sensor 03")
]
# Definição das threads
thread01 = threading.Thread(
target=change_temp,
args=(
sensores_list[0],
2,
sensor_db
)
)
thread02 = threading.Thread(
target=change_temp,
args=(
sensores_list[1],
2,
sensor_db
)
)
thread03 = threading.Thread(
target=change_temp,
args=(
sensores_list[2],
2,
sensor_db
)
)
# Iniciando threads
thread01.start()
thread02.start()
thread03.start()
def __init__(self, gps=False, servo_port=SERVO_PORT):
# devices
self._gps = gps
self.windsensor = WindSensor(I2C(WINDSENSOR_I2C_ADDRESS))
self.compass = Compass(I2C(COMPASS_I2C_ADDRESS),
I2C(ACCELEROMETER_I2C_ADDRESS))
self.red_led = GpioWriter(17, os)
self.green_led = GpioWriter(18, os)
# Navigation
self.globe = Globe()
self.timer = Timer()
self.application_logger = self._rotating_logger(APPLICATION_NAME)
self.position_logger = self._rotating_logger("position")
self.exchange = Exchange(self.application_logger)
self.timeshift = TimeShift(self.exchange, self.timer.time)
self.event_source = EventSource(self.exchange, self.timer,
self.application_logger,
CONFIG['event source'])
self.sensors = Sensors(self.gps, self.windsensor, self.compass,
self.timer.time, self.exchange,
self.position_logger, CONFIG['sensors'])
self.gps_console_writer = GpsConsoleWriter(self.gps)
self.rudder_servo = Servo(serial.Serial(servo_port),
RUDDER_SERVO_CHANNEL, RUDDER_MIN_PULSE,
RUDDER_MIN_ANGLE, RUDDER_MAX_PULSE,
RUDDER_MAX_ANGLE)
self.steerer = Steerer(self.rudder_servo, self.application_logger,
CONFIG['steerer'])
self.helm = Helm(self.exchange, self.sensors, self.steerer,
self.application_logger, CONFIG['helm'])
self.course_steerer = CourseSteerer(self.sensors, self.helm,
self.timer,
CONFIG['course steerer'])
self.navigator = Navigator(self.sensors, self.globe, self.exchange,
self.application_logger,
CONFIG['navigator'])
self.self_test = SelfTest(self.red_led, self.green_led, self.timer,
self.rudder_servo, RUDDER_MIN_ANGLE,
RUDDER_MAX_ANGLE)
# Tracking
self.tracking_logger = self._rotating_logger("track")
self.tracking_sensors = Sensors(self.gps, self.windsensor,
self.compass, self.timer.time,
self.exchange, self.tracking_logger,
CONFIG['sensors'])
self.tracker = Tracker(self.tracking_logger, self.tracking_sensors,
self.timer)
def test_should_pass_through_wind_drection(self):
mock_angle = PropertyMock(return_value=10.0)
windsensor = Mock()
type(windsensor).angle = mock_angle
sensors = Sensors(StubGPS(), windsensor, self.compass, self.mock_time,
self.exchange, self.logger, DEFAULT_CONFIG)
self.assertEqual(sensors.wind_direction_relative_instant, 10.0)
def __init__(self):
self.filename = "config.txt"
with open(self.filename) as f:
config = f.read()
self.config_list = [
y for y in (x.strip() for x in config.splitlines()) if y
]
if self.find("onetouch") == "True":
self.onetouch = True
else:
self.onetouch = False
self.mysens = Sensors()
self.mouse = Plattform()
self.recived_data = None
self.count = [0, 0, 0, 0, 0]
self.controlboard = []
self.oldtouch = [False, False, False, False, False]
self.touch = [False, False, False, False, False]
self.sensibility = 0
self.actived = True
self.oldx = None
self.oldy = None
self.AS = [None, None, None] #X,Y,Z
self.AA = [None, None, None] # X,Y,Z
self.GS = [None, None, None] # X,Y,Z
self.GA = [None, None, None] # X,Y,Z
self.mysens.setGyroscopeAngolData(X=0.0, Y=0.0, Z=0.0)
self.mysens.setGyroscopeScalledData(X=0.0, Y=0.0, Z=0.0)
def __init__(self):
self.w = wheels.wheels()
self.s = Sensors()
self.config = configuration.config()
self.w.setConfig(self.config)
self.s.setConfig(self.config)
self.s.calibration = True
def main_loop(self):
while (self.game.count <= self.game.max_games):
#reseting game
self.game.reset()
self.init_distance()
self.sensors = Sensors(self.game.grid, self.game.player)
# game loop
while self.game.player.alive:
# give input to game
action = self.generate_action()
#action = 0
self.game.step(self.sensors, action)
# get observation
observation = [
self.sensors.obstacle_forward(),
self.sensors.obstacle_left(),
self.sensors.obstacle_right(),
self.get_food_distance(),
self.get_reward(), action
]
#training_data.append(observation)
##ANN
artificial_neural_network.train(observation)
# print("forward ", " left ", " right ", " food ", " action ", " reward ")
# print(observation)
#print(training_data)
#end of game loop
self.game.count = self.game.count + 1
def main():
for i in range(len(sys.argv)):
if sys.argv[i] == '-t':
if len(sys.argv) < i + 3:
print 'device and baud needed for option -t'
exit(1)
test(sys.argv[i + 1], int(sys.argv[i + 2]))
print 'Servo Server'
server = SignalKServer()
from sensors import Sensors
sensors = Sensors(server)
servo = Servo(server, sensors)
servo.max_current.set(10)
period = .1
start = lastt = time.time()
while True:
servo.poll()
sensors.poll()
if servo.controller.value != 'none':
print 'voltage:', servo.voltage.value, 'current', servo.current.value, 'ctrl temp', servo.controller_temp.value, 'motor temp', servo.motor_temp.value, 'rudder pos', sensors.rudder.angle.value, 'flags', servo.flags.strvalue(
)
#print servo.command.value, servo.speed.value, servo.windup
pass
server.HandleRequests()
dt = period - time.time() + lastt
if dt > 0 and dt < period:
time.sleep(dt)
lastt += period
else:
lastt = time.time()
def __init__(self):
self.drive = new Nomad()
self.oi = new OI()
self.ds = DriverStation.getInstance()
self.infont = NetworkTables.getTable('info')
self.sensors = new Sensors()
def __init__(self):
super(Main, self).__init__()
## initialize sensors
self.sensorThread = False
self.radioThread = False
self.cameraThread = False
try:
self.sensorThread = Sensors()
except:
print("error initing sensor thread")
try:
pass
#self.cameraThread = Camera('Mini')
except:
print("error initializing camera thread")
try:
self.radioThread = Radio(self)
except:
print("error initing radio thread")
#self.numberGen = RandomThread()
self.daemon = True
self.fileLocation = str(os.getcwd()) + '/'
self.data_file = self.fileLocation + str(datetime.now().replace(microsecond=0))
print("initialized")
print(self.data_file)
def __init__():
sensors = None # type: Sensors
while True:
print("""
[1] Sensors - Create/Recreate
[2] Sensors - Apply Configuration
[3] Sensors - Reset Configuration
[4] Sensors - Calibrate
[5] Sampling - Start
[6] Sampling - Stop
[7] Sampling - View Current
[0] Exit
""")
option = input("Choice: ")
if option == "0":
if not (sensors is None) and sensors.running:
sensors.stop()
print("Exiting")
break
elif option == "1":
sensors = Sensors()
print("Sensors created")
elif sensors is None:
print("Not created sensors")
elif option == "2":
sensors.configure()
print("Configuration applied to sensors")
elif option == "3":
sensors.reset()
print("Sensor configurations reseted")
elif option == "4":
sensors.calibrate()
print("Calibrated sensors")
elif option == "5":
sensors.start()
print("Sampling started")
elif option == "6":
sensors.stop()
print("Sampling stoped")
elif option == "7":
sensors.showCurrent()
else:
print("Invalid Choice.")
def __init__(self, car):
self.sensors = Sensors()
self.references = [-1, -1, -1, -1, -1]
self.car = car
if not self.is_calibrated():
self.calibration()
else:
self.load_calibration()
def __init__(self):
config = configparser.ConfigParser()
config_file = os.path.join(os.path.dirname(__file__), 'config.ini')
config.read(config_file)
client = InfluxDBClient.from_config_file(config_file)
self.write_api = client.write_api()
self.bucket = config['ha']['influx_bucket']
self.sensors = Sensors()
def setup(self):
self.timer = Timer()
self.utils = Utils(time.time(), 180) #start time, total game time
self.sensors = Sensors(self.tamp)
self.actuators = Actuators(self.tamp)
self.motorController = MotorController(self.sensors, self.actuators)
self.myState = startState(self.sensors, self.actuators,
self.motorController, self.timer, self.utils)
def setup(self):
self.logger.info("--------------------------------------")
self.logger.info(" Balloon Mission Computer V4.01 ")
self.logger.info("--------------------------------------")
self.logger.debug("setup")
# setup
with open('data/config.json') as fin:
self.config = json.load(fin)
self.images_dir = self.config["directories"][
"images"] if "directories" in self.config and "images" in self.config[
"directories"] else "./images"
self.tmp_dir = self.config["directories"][
"tmp"] if "directories" in self.config and "tmp" in self.config[
"directories"] else "./tmp"
if not os.path.exists(self.tmp_dir):
os.makedirs(self.tmp_dir)
if not os.path.exists(self.images_dir):
os.makedirs(self.images_dir)
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM) # Broadcom pin-numbering scheme
GPIO.setup(self.config['pins']['BUZZER'], GPIO.OUT)
GPIO.setup(self.config['pins']['LED1'], GPIO.OUT)
GPIO.setup(self.config['pins']['LED2'], GPIO.OUT)
GPIO.output(self.config['pins']['LED1'], GPIO.HIGH)
self.aprs = APRS(self.config['callsign'], self.config['ssid'],
"idoroseman.com")
self.modem = AFSK()
self.gps = Ublox()
self.gps.start()
self.radio = Dorji(self.config['pins'])
self.radio.init()
self.radio_q = queue.Queue()
self.radio_thread = threading.Thread(target=self.radio_worker)
self.radio_thread.start()
self.timers = Timers(self.config['timers'])
self.sensors = Sensors()
self.cam = Camera()
self.ssdv = SSDV(self.config['callsign'], self.config['ssid'])
self.sstv = SSTV()
self.webserver = WebServer()
self.radio_queue(self.config['frequencies']['APRS'],
'data/boatswain_whistle.wav')
for item in ["APRS", "APRS-META", "Imaging", 'Capture']:
self.timers.handle({item: self.config['timers'][item] > 0}, [])
self.timers.handle({"Buzzer": False}, [])
self.ledState = 1
self.imaging_counter = 1
self.state = "init"
self.min_alt = sys.maxsize
self.max_alt = 0
self.prev_alt = 0
self.send_bulltin()
GPIO.output(self.config['pins']['LED1'], GPIO.LOW)
def __init__(self, url, flightname, device_id=None, jwt_token=None):
self.url = '{}/flight/{}/telemetry?authorization={}'.format(
url, flightname, jwt_token)
self.timeout_seconds = 10
self.coords = []
self.imei = device_id
self.momsn = None
self.import_coordinates_list()
self.sensors = Sensors(self.coords)
def main():
'''
Main Function of the program
'''
#print("Scarecrow starting...")
#print("Loading Sensors")
source = Sensors()
sigfox = SerialConnection()
time.sleep(0.1)
print("Loading AIModel")
img_handler = ImgProcessing(camera=0, debug=False)
print("AI Model loaded")
while (True):
try:
sigfox.open_conn()
data = source.get_temp_n_hum()
temperature = data[0]
humidity = data[1]
luminosity = source.get_lum()
if luminosity >= 20000:
luminosity = 0
elif luminosity >= 10000:
luminosity = 1
elif luminosity >= 5000:
luminosity = 2
else:
luminosity = 3
rain = source.get_rain()
if rain >= 5000:
rain = 1
else:
rain = 0
soil = source.get_soil()
if soil >= 20000:
soil = 0
elif soil >= 17000:
soil = 1
elif soil >= 100:
soil = 2
bugs = img_handler.process_image(source)
print(bugs)
data = [
int(temperature),
int(humidity), 100, luminosity, bugs, rain, soil
]
print(data)
send_message(data, sigfox)
sigfox.close_conn()
source.blueLed()
img_handler.capture.release()
except KeyboardInterrupt:
print("flw")
GPIO.cleanup()
time.sleep(5)
GPIO.cleanup()
def sensor_function(sensor_bus, delay): ''' create a sensor class, read the sensor values and write them in a loop :param: sensor_bus :param: timer delay ''' sensor = Sensors() lock = Lock() while True: with lock
def testCalculator_adds_and_gets_data(self):
sensors = Sensors()
data = sensors.poll()
calculator = server.Calculator()
calculator.add_datum(data)
self.assertIn(
"PEEP",
calculator.get_datum()["patient-0"],
"Fails to add data to and then get data from "
"the calculator.")
def __initVars(self):
"""Subscribers vars initialisation"""
self.sensors = Sensors()
self.trans_listener = tf.TransformListener()
self.sensors.add("trans", None)
self.old_trans = None
self.sensors.add("rot", None)
self.rate_pub_enabled = False
self.messager = mav_msgs.RateThrust()
self.collision = False
def run_sensors(gapps, user_options):
"""
Utility method to publish to the gridappsdmock instead of going through
the gridappsd service process.
:param gapps:
:param user_options:
"""
sensors = Sensors(gapps, "read", "write", user_options)
for data in next_line():
sensors.on_simulation_message({}, deepcopy(data))
def initialize_threads(self):
""" Initializes io threads"""
super().initialize_threads()
self.dashboard_interval = int(self.ping_interval * 2)
self.topic_fastclock_pub = self.publish_topics[Global.FASTCLOCK]
self.topic_dashboard_pub = self.publish_topics[Global.DASHBOARD]
self.topic_node_pub = self.publish_topics[Global.NODE]
self.topic_ping_sub = self.subscribed_topics[Global.PING]
# print("!!! ping sub: "+self.topic_ping_sub)
self.topic_sensor_sub = self.subscribed_topics[Global.SENSOR]
self.topic_backup_sub = self.subscribed_topics[Global.BACKUP]
# print("!!! backup sub: "+self.topic_backup_sub)
if Global.CONFIG in self.config:
if Global.OPTIONS in self.config[Global.CONFIG]:
if Global.TIME in self.config[Global.CONFIG][Global.OPTIONS]:
if Global.FAST in self.config[Global.CONFIG][
Global.OPTIONS][Global.TIME]:
if Global.RATIO in self.config[Global.CONFIG][
Global.OPTIONS][Global.TIME][Global.FAST]:
self.fast_ratio = int(
self.config[Global.CONFIG][Global.OPTIONS][
Global.TIME][Global.FAST][Global.RATIO])
if Global.INTERVAL in self.config[Global.CONFIG][
Global.OPTIONS][Global.TIME][Global.FAST]:
self.fast_interval = int(
self.config[Global.CONFIG][Global.OPTIONS][
Global.TIME][Global.FAST][Global.INTERVAL])
if Global.PING in self.config[Global.CONFIG][Global.OPTIONS]:
self.ping_interval = self.config[Global.CONFIG][
Global.OPTIONS][Global.PING]
if Global.BACKUP in self.config[Global.CONFIG][Global.OPTIONS]:
self.backup_path = self.config[Global.CONFIG][
Global.OPTIONS][Global.BACKUP]
self.roster = Roster(self.log_queue,
file_path=Global.DATA + "/" + Global.ROSTER +
".json")
self.switches = Switches(self.log_queue,
file_path=Global.DATA + "/" +
Global.SWITCHES + ".json")
self.warrants = Warrants(self.log_queue,
file_path=Global.DATA + "/" +
Global.WARRANTS + ".json")
self.signals = Signals(self.log_queue,
file_path=Global.DATA + "/" + Global.SIGNALS +
".json")
self.layout = Layout(self.log_queue,
file_path=Global.DATA + "/" + Global.LAYOUT +
".json")
self.dashboard = Dashboard(self.log_queue,
file_path=Global.DATA + "/" +
Global.DASHBOARD + ".json")
self.sensors = Sensors(self.log_queue,
file_path=Global.DATA + "/" + Global.SENSORS +
".json")
def __init__(self, x=0, y=0, theta=0):
self.x = x
self.y = y
self.theta = radians(theta)
self.velLin = 0
self.velAng = 0
self.distFront = 0
self.distRight = 0
self.distLeft = 0
self.sensors = Sensors()
self.control = False
def test_should_return_wind_relative_average_after_several_update_averages_events(
self):
mock_angle = PropertyMock(side_effect=[10.0, 20.0])
windsensor = Mock()
type(windsensor).angle = mock_angle
sensors = Sensors(StubGPS(), windsensor, self.compass, self.mock_time,
self.exchange, self.logger, DEFAULT_CONFIG)
self.exchange.publish(Event(EventName.update_averages))
self.exchange.publish(Event(EventName.update_averages))
self.assertEqual(sensors.wind_direction_relative_average,
round(((0.0 + 10) / 2 + 20) / 2), 0)
def test_should_register_logging_according_to_config(self):
self.listen(EventName.every)
config = DEFAULT_CONFIG
config['log interval'] = 15
sensors = Sensors(self.gps, self.windsensor, self.compass,
self.mock_time, self.exchange, self.logger, config)
every_event = self.events[EventName.every][0]
self.assertEqual(every_event.seconds, 15)
self.assertEqual(every_event.next_event.name, EventName.log_position)
def test_should_provide_a_rounded_average_for_values_either_side_of_zero(
self):
mock_angle = PropertyMock(side_effect=[350.0, 0.0, 10.0])
windsensor = Mock()
type(windsensor).angle = mock_angle
sensors = Sensors(StubGPS(), windsensor, self.compass, self.mock_time,
self.exchange, self.logger, DEFAULT_CONFIG)
self.exchange.publish(Event(EventName.update_averages))
self.exchange.publish(Event(EventName.update_averages))
self.exchange.publish(Event(EventName.update_averages))
self.assertEqual(sensors.wind_direction_relative_average, 4.0)
def main(self):
start_time = time.time()
cpu_usage = psutil.cpu_percent()
if getattr(sys, 'frozen', False):
configFile = Path(os.path.dirname(sys.executable) + "/config.yaml")
else:
configFile = Path(
os.path.dirname(os.path.abspath(__file__)) + "/config.yaml")
with open(str(configFile), 'r') as stream:
try:
config = yaml.load(stream)
except yaml.YAMLError as exc:
print(exc)
self.URL = "http://" + str(config['server']['host']) + ":" + str(
config['server']['port'])
self.apikey = self.getApiKey()
textStorage = TextStorage(self.URL)
sensors = Sensors()
sensors.initializeSensors()
# Continuously loop
while True:
# Construct our weatherdata json object
cpu_usage = psutil.cpu_percent()
ram = psutil.virtual_memory()
ram_usage = ram.percent
weatherdata = sensors.getSensorData(self.apikey, cpu_usage,
ram_usage)
#Previous semester Posting Method
#time.sleep(4)
#try:
#r = requests.post(self.URL + '/api/weather', data = serv1)
#if (r.status_code == 200):
# textStorage.sendWeather()
# print("Sent: " + json.dumps(serv1))
# elif (r.status_code == 400):
# print("Invalid API key")
# Exception if unable to connect to server for the post request
#except (requests.exceptions.ConnectionError):
#print("Lost connection to server...storing data locally.")
# textStorage.storeWeather(serv1)
# pass
#The above commented code is the way previous semester posted to the server. We no longer need that because each individual Pi will not be posting anymore, and only Master will post.
#Because of that, each Pi needs to store their data locally and broadcast via LoRa to Master.
print("Lost connection to server...storing data locally.")
textStorage.storeWeather(weatherdata)
# Wait 3 seconds before restarting the loop
time.sleep(self.WAIT_TIME)
def __init__(self, safety_level=0):
Motion.__init__(self)
self._logger = Logger("SafeMotion")
# set up sensor module
self.sensors = Sensors()
# set avoidance state
self.avoiding = False
# set motion modification based on safety level
self._motionModifier = self._avoid if safety_level > 0 else self._safetyStop
def __init__(self):
pygame.init()
pygame.display.set_caption("AI Car game")
width = 1200
height = 900
self.screen = pygame.display.set_mode((width, height))
self.clock = pygame.time.Clock()
self.pad_group = pygame.sprite.RenderPlain(*pads2)
self.car = CarSprite('images/car.png', (100, 730))
self.sensors = Sensors(self.car.position, self.car.direction, self.pad_group)
self.ticks = 60
self.font = pygame.font.Font(None, 75)
self.exit = False
def main():
GPIO.setmode(GPIO.BOARD) #refference by pin number
GPIO.setwarnings(False)
#test_left_engine()
#test_right_engine()
#test_pwm()
sensors = Sensors()
while True:
print(sensors.check_sensors_state())
sleep(0.5)
pass
GPIO.cleanup()
