def test_sensor_ge(self):
sensor_1 = Sensor('atsr-en', Period((2007, 1, 1), (2008, 1, 1)))
sensor_2 = Sensor('atsr-e2', Period((2008, 1, 1), (2009, 1, 1)))
self.assertTrue(sensor_1 >= sensor_2)
sensor_3 = Sensor('atsr-e2', Period((2009, 1, 1), (2010, 1, 1)))
self.assertTrue(sensor_2 >= sensor_3)
self.assertTrue(sensor_3 >= sensor_2)
def test_sensor_pair_construction_with_production_period_invalid(self):
sensor_1 = Sensor('avhrr-n12', Period((2007, 1, 1), (2008, 1, 1)))
sensor_2 = Sensor('avhrr-n13', Period((2007, 7, 1), (2008, 7, 1)))
try:
SensorPair(sensor_1, sensor_2, Period((2000, 8, 1), (2000, 9, 1)))
self.fail("ValueError exoected")
except ValueError:
pass
def test_sensor_pair_inequality(self):
sensor_1 = Sensor('atsr-en', Period((2007, 1, 1), (2008, 1, 1)))
sensor_2 = Sensor('atsr-e2', Period((2007, 7, 1), (2008, 7, 1)))
sensor_3 = Sensor('atsr-e1', Period((2008, 1, 1), (2009, 1, 1)))
sensor_pair_1 = SensorPair(sensor_1, sensor_2)
sensor_pair_2 = SensorPair(sensor_2, sensor_3)
self.assertTrue(sensor_pair_1 != sensor_pair_2)
self.assertTrue(sensor_pair_2 != sensor_pair_1)
def __init__(self, entity_list):
BmcEntity.__init__(self, 'board_a', entity_list)
self.eeprom = I2CEeprom('board_eeprom', 2, 0x40, 'eeprom16bit')
print(' ', self.name, 'has EEPROM content:', self.eeprom.get_content())
# init MUXes
self.i2c_mux = []
self.i2c_mux.append(I2CMux('pcie_i2c_mux_0', 6, 0x70, 'apc9456'))
self.i2c_mux.append(I2CMux('pcie_i2c_mux_1', 7, 0x70, 'apc9456'))
i2c_children = self.i2c_mux[0].get_channels() + \
self.i2c_mux[1].get_channels()
self.vr = XAM2734('vdd_0r70', 2, 0x58)
self.sensor_vr_voltage = Sensor('vdd_0r70', 'voltage')
self.sensors.append(self.sensor_vr_voltage)
self.sensor_vr_current = Sensor('vdd_0r70', 'current')
self.sensors.append(self.sensor_vr_current)
# init PCIe cards
for i in range(8):
eeprom = I2CEeprom('possible_eeprom', i2c_children[i], 0x52,
'eeprom8bit')
if eeprom.get_content() == 'card_g':
card_g = CardExampleG(entity_list, i, i2c_children[i])
card_g.eeprom = eeprom
self.children.append(card_g)
continue
elif eeprom.get_content() == 'card_v':
card_v = CardExampleV(entity_list, i2c_children[i])
card_v.eeprom = eeprom
self.children.append(card_v)
continue
eeprom.delete()
# The other supported card may have its eeprom behind the channel 2
# of its I2C MUX. Try applying MUX first, if it is the card,
# hand over the MUX to the card.
card_c_mux = I2CMux('possible_card_c_mux', i2c_children[i], 0x71,
'apc9456')
eeprom = I2CEeprom('possible_eeprom',
card_c_mux.get_channels()[2], 0x54,
'eeprom8bit')
if eeprom.get_content() == 'card_c':
card_c = CardExampleC(entity_list, i, i2c_children[i],
card_c_mux)
card_c.eeprom = eeprom
self.children.append(card_c)
continue
# no valid card recognized
print("No card detected at slot %d" % i)
eeprom.delete()
card_c_mux.delete()
def test_sensor_pair_ge(self):
sensor_1 = Sensor('atsr-en', Period((2007, 1, 1), (2008, 1, 1)))
sensor_2 = Sensor('atsr-e2', Period((2007, 7, 1), (2008, 7, 1)))
sensor_3 = Sensor('atsr-e1', Period((2007, 10, 1), (2008, 10, 1)))
sensor_pair_1 = SensorPair(sensor_1, sensor_2)
sensor_pair_2 = SensorPair(sensor_2, sensor_3)
sensor_pair_3 = SensorPair(sensor_1, sensor_3)
self.assertTrue(sensor_pair_1 >= sensor_pair_2)
self.assertTrue(sensor_pair_1 >= sensor_pair_3)
def test_get_sensor(self):
"""get by id first the use the name for testing get by name"""
pw_db = Ponicwatch_db("sqlite3")
sensor1 = Sensor(pw_db, id=1)
self.assertEqual(sensor1["sensor_id"], 1)
print("[{}] has the id: {}".format(sensor1, sensor1["sensor_id"]))
name = sensor1["name"]
sensor1 = Sensor(pw_db, name=name)
self.assertEqual(sensor1["sensor_id"], 1)
print("Last update on:", sensor1["updated_on"],
type(sensor1["updated_on"]))
def test_moveBack_yp(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 0, 2)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (0, -1))
self.assertEqual((sensor2.x, sensor2.y), (0, 3))
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (0, 0))
def test_add_get_primary_sensors_multiple(self):
w = Workflow('test', 5)
w.add_primary_sensor('atsr-e2', '1995-06-01', '1996-01-01')
w.add_primary_sensor('atsr-e1', '1991-06-01', '1995-01-01')
w.add_primary_sensor('atsr-en', '1996-01-01', '1998-01-01')
sensors = w._get_primary_sensors()
self.assertEqual([
Sensor('atsr-en', Period((1996, 1, 1), (1998, 1, 1))),
Sensor('atsr-e2', Period((1995, 6, 1), (1996, 1, 1))),
Sensor('atsr-e1', Period((1991, 6, 1), (1995, 1, 1)))
], sensors)
def test_add_get_secondary_sensors_multiple(self):
w = Workflow('test', 9)
w.add_secondary_sensor('atsr-e2', '1996-06-01', '1997-01-01')
w.add_secondary_sensor('atsr-e1', '1992-06-01', '1996-01-01')
w.add_secondary_sensor('atsr-en', '1997-01-01', '1999-01-01')
sensors = w._get_secondary_sensors()
self.assertEqual([
Sensor('atsr-en', Period((1997, 1, 1), (1999, 1, 1))),
Sensor('atsr-e2', Period((1996, 6, 1), (1997, 1, 1))),
Sensor('atsr-e1', Period((1992, 6, 1), (1996, 1, 1)))
], sensors)
def test_count_boundaries(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 3, 3)
sensor3 = Sensor(3, 1, 50, -3, -3)
sensor4 = Sensor(3, 1, 50, -3, 3)
sensor5 = Sensor(3, 1, 50, 3, -3)
grid.add(sensor1)
grid.add(sensor2)
grid.add(sensor3)
grid.add(sensor4)
grid.add(sensor5)
self.assertEqual(sensor1.countSensors(grid, -3, -3, 6, 6), 5)
def test_neighbours_eight_border(self):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
for i in range(8):
angle = i / 4.0 * math.pi
x = 2.999 * math.cos(angle)
y = 2.999 * math.sin(angle)
print(x, y)
sensor = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, x, y)
grid.add(sensor)
grid.add(sensor1)
grid.iterate()
self.assertEqual(len(sensor1.neighbours), 8)
def add_primary_sensor(self, name, start_date, end_date, version=''):
"""
:type name: str
"""
period = Period(start_date, end_date)
for sensor in self._get_primary_sensors():
if sensor.get_name() == name and sensor.get_period().is_intersecting(period):
raise ValueError("Periods of sensor '" + name + "' must not intersect.")
if version == '':
self.primary_sensors.add(Sensor(name, period))
else:
self.primary_sensors.add(Sensor(name, period, version))
def demoMode():
contractAddress0 = '0x4eF37F30b9F3aB31092d320C0D94b1ce15a1EBa6'
contractAddress1 = '0x15Db0fbA4fe7DCb94F4b93f0ecc07FBb7EE52131'
contract0 = et.web3.eth.contract(address=contractAddress0,
abi=et.readAbi("sensor.json"))
contract1 = et.web3.eth.contract(address=contractAddress1,
abi=et.readAbi("sensor.json"))
sensors.append(
Sensor(contract0, '98:D3:91:FD:BC:1D', 0,
connectToSensor('98:D3:91:FD:BC:1D', 1)))
sensors.append(
Sensor(contract1, '98:D3:51:FD:F9:E9', 1,
connectToSensor('98:D3:51:FD:F9:E9', 2)))
initEvents()
def test_sensor_pair_construction_invalid(self):
sensor_1 = Sensor('avhrr-n14', Period((2007, 1, 1), (2008, 1, 1)))
sensor_2 = Sensor('avhrr-n15', Period((2008, 1, 1), (2009, 1, 1)))
try:
SensorPair(sensor_1, sensor_2)
self.fail()
except exceptions.ValueError:
pass
try:
SensorPair(sensor_2, sensor_1)
except exceptions.ValueError:
pass
def test_f_cover_many(self):
for i in range(8):
grid = Grid()
sensor1 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, 0, 0)
angle = i / 4.0 * math.pi
x = 1 * math.cos(angle)
y = 1 * math.sin(angle)
grid.add(sensor1)
sensor2 = Sensor(3, 1, kcover, kdegree, damp, cdistance, 50, x, y)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual(len(sensor1.neighbours), 1)
self.assertEqual(sensor1.fcover, -kcover)
def test_moveBack_xn(self):
grid = Grid()
sensor1 = Sensor(3, 1, 50, 0, 0)
sensor2 = Sensor(3, 1, 50, 2, 0)
grid.add(sensor1)
grid.add(sensor2)
grid.iterate()
self.assertEqual((sensor1.x, sensor1.y), (-1, 0))
self.assertEqual((sensor2.x, sensor2.y), (3, 0))
sensor1.moveBack(grid)
self.assertEqual(sensor1.xlast, -1)
self.assertTrue(sensor1.isEmptyX(grid, 3, -1))
self.assertTrue(sensor1.xmoveback)
grid.iterate()
self.assertEqual((sensor2.x, sensor2.y), (2, 0))
def run(self):
self.logger.info('Bootstrapping...')
self.connector.remove(self.cfg.data_collection)
self.connector.remove(self.cfg.config_collection)
key_dict = {
'date': 'date_time',
'pm10': 'pm10',
'wind direction': 'wind_direction',
'wind strength': 'wind',
'temp': 'temperature',
'humidity': 'humidity',
'dew point': 'dew_point',
'air pres.': 'pressure'
}
from bootstrap.bootstrap import get_data_from_csv
data = get_data_from_csv(key_dict=key_dict)
sensor = Sensor(fields=list(data[0].keys()), vendor='bootstrap', vendor_id=0,
datetime_col='date_time', predict='pm10')
sensor.save()
[d.update({'sensor_id': sensor.id}) for d in data]
saved_data = self.connector.save(data, self.cfg.data_collection).inserted_ids
self.logger.info('Saved data count: {}'.format(len(saved_data)))
def test_module(self):
"""
Go through various sensor.measure and pump.get_state values to verify
the compatibility of decider and controller.
"""
dec = Decider(100, .05)
control = Controller(
Sensor("127.0.0.1", "8000"),
Pump("127.0.0.1", "8000"),
dec
)
control.pump.set_state = MagicMock(return_value=True)
levels = [110, 90, 99]
for pump_act in control.actions.values():
control.pump.get_state = MagicMock(return_value=pump_act)
for water_h in levels:
control.sensor.measure = MagicMock(return_value=water_h)
control.tick()
control.pump.get_state = MagicMock(
return_value=dec.decide(
control.sensor.measure(),
control.pump.get_state(),
control.actions
)
)
def test_decide(self):
"""
Method to test decide function
"""
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=True)
decider = Decider(10., 0.05)
controller = Controller(sensor, pump, decider)
self.assertEqual(decider.decide(1.0, int(0), controller.actions),
controller.actions['PUMP_IN'])
self.assertEqual(decider.decide(20.0, int(0), controller.actions),
controller.actions['PUMP_OUT'])
self.assertEqual(decider.decide(10.0, int(0), controller.actions),
controller.actions['PUMP_OFF'])
self.assertEqual(decider.decide(20.0, int(1), controller.actions),
controller.actions['PUMP_OFF'])
self.assertEqual(decider.decide(1.0, int(1), controller.actions),
controller.actions['PUMP_IN'])
self.assertEqual(decider.decide(1.0, int(-1), controller.actions),
controller.actions['PUMP_OFF'])
self.assertEqual(decider.decide(20.0, int(-1), controller.actions),
controller.actions['PUMP_OUT'])
with self.assertRaises(ValueError):
decider.decide(10., 2.5, controller.actions)
def __init__(self, entity_list, index, i2c_bus, mux):
BmcEntity.__init__(self, 'card_c_%d' % index, entity_list)
self.index = index
self.i2c_bus = i2c_bus
self.i2c_mux = mux
self.temp_device = I2CHwmonDevice('temp_sensor',
mux.get_channels()[0], 0x30,
'xam3170')
self.sensor_board_1 = Sensor('board_pos_1', 'temperature')
self.sensor_board_2 = Sensor('board_pos_2', 'temperature')
self.sensor_asic = Sensor('asic', 'temperature')
self.sensors += [
self.sensor_board_1, self.sensor_board_2, self.sensor_asic
]
def __init__ (self, mode="idle", head=0, h=1, w=1): # h is long dimension
# mode is idle initially
self.robotMode = mode
# 0,1,2,3 represent N,E,S,W respectively
self.robotHead = head
# initialize starting point
self.robotCenterH = h
self.robotCenterW = w
self.sensors = []
sensors = parse_robot_config("./robot.conf")
for sensor in sensors["sensors"]:
self.sensors.append(Sensor(sensor["max_range"], sensor["position"], sensor["orientation"]))
# self.sensor.append(Sensor(3, 1, 0))
# 3 cells of level 0 to the right with respect to each direction
self.rightCells = {0:[[1,2],[0,2],[-1,2]],
1:[[-2,1],[-2,0],[-2,-1]],
2:[[-1,-2],[0,-2],[1,-2]],
3:[[2,-1],[2,0],[2,1]]
}
# 3 cells of level 0 in front with respect to each direction
self.frontCells = {0:[[2,-1],[2,0],[2,1]],
1:[[1,2],[0,2],[-1,2]],
2:[[-2,1],[-2,0],[-2,-1]],
3:[[-1,-2],[0,-2],[1,-2]]
}
self.directionString = {
0: "north",
1: "east",
2: "south",
3: "west"
}[self.robotHead]
def next_move(self, sensors):
"""Selects the move randomly, but avoids walls. He's sick of banging his head.
Arguments:
sensors -- a tuple of left, front and right sensor readings.
reached_goal -- a boolean indicating True if the goal has been reached.
Returns:
rot -- the next rotation in degrees.
move -- an integer for the next move.
"""
# A certain percentage of the time we should try to reset.
p = 0.05
reset = np.random.choice([0, 1], p=[(1 - p), p])
if reset:
return 'RESET', 'RESET'
# Get indexes where readings are non-zero.
non_zero_idx = np.where(np.array(sensors) > 0)[0]
# If all sensors are blank, back up the truck.
if len(non_zero_idx) == 0:
return Rotation.NONE, np.random.choice(range(-3, 0))
# Choose a rotation randomly from those directions.
idx = random.choice(non_zero_idx)
rot = Sensor(idx).rotation()
# Choose a random move in the forward direction.
max_move = min([sensors[idx], self.MAX_MOVE])
move = random.choice(range(1, max_move + 1))
return rot, move
def start():
print("\n")
i2c = I2C(-1, scl=Pin(5), sda=Pin(4))
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c)
splash_screen(oled)
wifi = wifi_connect(wc.SSID, wc.PASSWORD)
aqi = AQI()
sensor = Sensor(i2c)
mqtt = MQTTData(wc.IO_URL, wc.IO_USERNAME, wc.IO_KEY, wc.SNAME)
display = Display(oled, aqi, sensor)
gc.collect()
loop = asyncio.get_event_loop()
loop.create_task(mqtt.run(sensor))
loop.create_task(aqi.run())
loop.create_task(display.run())
loop.create_task(heartbeat())
gc.collect()
try:
loop.run_forever()
except KeyboardInterrupt:
oled.fill(0)
oled.text('Sensor', 44, 7)
oled.text('Shutdown', 35, 21)
oled.show()
except OSError as exc:
print(exc)
def procedure_00(self, robot, sound):
''' padrão '''
sn = Sensor()
pygame.mixer.music.load(f'./isa/audio/message/{sound}.mp3')
pygame.mixer.music.play()
robot.drive_straight(distance_mm(2850),
speed_mmps(220)).wait_for_completed()
while sn.notComplete('machine'):
robot.drive_straight(distance_mm(20),
speed_mmps(100)).wait_for_completed()
robot.move_lift(1)
sleep(2)
robot.turn_in_place(degrees(180), False, 0,
degrees(30)).wait_for_completed()
robot.move_lift(-1)
robot.drive_straight(distance_mm(2700),
speed_mmps(220)).wait_for_completed()
while sn.notComplete('base'):
robot.drive_straight(distance_mm(20),
speed_mmps(100)).wait_for_completed()
robot.move_lift(1)
sleep(2)
robot.turn_in_place(degrees(180), False, 0,
degrees(30)).wait_for_completed()
robot.move_lift(-1)
robot.drive_straight(distance_mm(-150),
speed_mmps(220)).wait_for_completed()
async def main():
module_client = IoTHubModuleClient.create_from_edge_environment()
await module_client.connect()
sensor = Sensor()
async def message_listener(module_client):
while True:
message = await module_client.receive_message_on_input("input1") # blocking call
print("the data in the message received was ")
print(message.data)
print("custom properties are")
print(message.custom_properties)
asyncio.create_task(message_listener(module_client))
while True:
try:
telemetry = await sensor.readSensor()
if telemetry is not None:
print(telemetry)
data = json.dumps(telemetry)
await module_client.send_message_to_output(data, "output1")
await asyncio.sleep(10)
except:
print("Unexpected error:", sys.exc_info()[0])
await module_client.disconnect()
def test_module(self):
"""
Test the waterregulation module
"""
sensor = Sensor('127.0.0.1', '3080')
pump = Pump('127.0.0.1', '4080')
decider = Decider(100, .10)
controller = Controller(sensor, pump, decider)
controller.pump.set_state = MagicMock(return_value=True)
levels = range(89, 112)
for action in controller.actions.values():
for liquid_height in levels:
controller.sensor.measure = MagicMock(
return_value=liquid_height
)
controller.pump.get_state = MagicMock(
return_value=decider.decide(
liquid_height, action, controller.actions
)
)
controller.tick()
def test_sensor_pair_construction(self):
sensor_1 = Sensor('avhrr-n12', Period((2007, 1, 1), (2008, 1, 1)))
sensor_2 = Sensor('avhrr-n13', Period((2007, 7, 1), (2008, 7, 1)))
sensor_3 = Sensor('avhrr-n14', Period((2008, 1, 1), (2009, 1, 1)))
sensor_pair = SensorPair(sensor_1, sensor_2)
self.assertEqual('avhrr-n12', sensor_pair.get_primary_name())
self.assertEqual('avhrr-n13', sensor_pair.get_secondary_name())
self.assertEqual(Period((2007, 7, 1), (2008, 1, 1)),
sensor_pair.get_period())
sensor_pair = SensorPair(sensor_3, sensor_2)
self.assertEqual('avhrr-n14', sensor_pair.get_primary_name())
self.assertEqual('avhrr-n13', sensor_pair.get_secondary_name())
self.assertEqual(Period((2008, 1, 1), (2008, 7, 1)),
sensor_pair.get_period())
def setUp(self):
self.sensor = Sensor('http://localhost', '8080')
self.pump = Pump('http://localhost', '8080')
self.decider = Decider(10, .1)
self.controller = Controller(self.sensor, self.pump, self.decider)
self.pump.set_state = MagicMock(return_value=True)
self.decider.decide = MagicMock(return_value='PUMP_IN')
def setUp(self):
""" setup """
self.pump = Pump('127.0.0.1', 8000)
self.decider = Decider(100, 0.05)
self.sensor = Sensor('127.0.0.1', '8001')
self.controller = Controller(self.sensor, self.pump, self.decider)
self.actions = self.controller.actions
def test_add_get_primary_sensors_version(self):
w = Workflow('test', 5)
w.add_primary_sensor('atsr-e2', '1995-06-01', '1996-01-01',
'version_5')
self.assertEqual([
Sensor('atsr-e2', Period((1995, 6, 1), (1996, 1, 1)), 'version_5')
], w._get_primary_sensors())
