def test_specialMethods(self):
s1 = Sensor(name='a', temperatur=20)
s2 = Sensor(name='a', temperatur=-20)
s3 = Sensor(name='b', temperatur=20)
s4 = Sensor(name='a', temperatur=20, identifier='someID')
s4_2 = Sensor(name='a', temperatur=20, identifier='someID')
s5 = Sensor(name='a', temperatur=20, identifier='someID')
s6 = Sensor(name='b', temperatur=20, identifier='someID')
s7 = Sensor(name='a', temperatur=10, identifier='someID')
s8 = Sensor(name='a', temperatur=20, identifier='someotherID')
self.assertGreater(s3, s1)
self.assertNotEqual(s1, s2)
self.assertEqual(s4, s5)
s5._temperatur = 40
self.assertNotEqual(s4, s5)
self.assertNotEqual(s4, s6)
self.assertNotEqual(s4, s7)
s7._temperatur = 20
self.assertEqual(s4, s7)
self.assertNotEqual(s4, s8)
self.assertLess(s1, s3)
self.assertFalse(s1 == 25)
self.assertFalse(s1 == 'kack')
self.assertFalse(s1 == Sensor())
self.assertFalse(s1 == s3)
self.assertFalse(s1 == s2)
self.assertTrue(s4 == s4_2)
self.assertTrue(s4 != s5)
self.assertFalse(s1 > 25.456)
self.assertFalse(s1 > long(25.456))
self.assertTrue(s1 > None)
class Client:
def __init__(self, alert):
self.sensor = Sensor()
self.alert = alert
self.flag = True
self.client = mqtt.Client()
self.client.on_connect = self.on_connect
self.client.on_message = self.on_message
self.client.username_pw_set(USER, PASS)
self.client.connect(MQTT_REMOTE_SERVER, 1883, 60)
print("connected")
def on_connect(self, client, userdata, flags, rc):
print("External Comm: connected with result code " + str(rc))
client.subscribe(MQTT_PATH_RECV)
def start(self):
print("looping")
self.client.loop_forever()
def on_message(self, client, userdata, msg):
mensaje = str(msg.payload).split('b')[1]
print('payload:' + mensaje)
if (mensaje == "'-99'"):
self.alert.setState(True)
print("Iniciando")
elif (mensaje == "'-100'"):
self.alert.setState(False)
print("Finalizando")
else:
if (self.alert.getState() == False):
print('Encienda el dispositivo para enviar mensajes')
else:
self.sensor.message(mensaje)
def test_reset(self):
name1 = 'someName'
ID1 = 'someID'
s1 = Sensor(name='a', temperatur=20, identifier=ID1)
emptySensor = Sensor(name=name1)
s1.reset()
self.assertTrue(s1, emptySensor)
def __getTempAlerts(self, sensor: Sensor):
# temp alert is collected per sensor
tempXY = [{
'id': sensor.getId(),
'tempAlert': sensor.getTempAlert()
}]
return tempXY
def fusSensors2(Sensors):
R_Sensors = np.array([Sensors[0].createR(),Sensors[1].createR(),Sensors[2].createR(),Sensors[3].createR(),Sensors[4].createR()])
def createRfromSensors(R_Sensors):
R2 = R_Sensors.copy()
R2 = [la.inv(matrix) for matrix in R2]
R2 = sum(R2)
R2 = la.inv(R2)
return R2
R= createRfromSensors(R_Sensors)
newSensorWithR = Sensor(movingObject)
newSensorWithR.R = R
newFilter = Filter(newSensorWithR)
newTrajectory = np.zeros(Trajectory.T.shape)
for i in range(m):
for j in range(5):
newTrajectory[i] += la.inv(R_Sensors[j]) @ Z_Sensors[j].T[i]
newTrajectory[i] = R @ newTrajectory[i]
newTrajectory = newTrajectory.T
X_2ndStrategy = np.zeros((6,1))
allX_2ndStrategy= np.zeros((m,6,1)) # save Xs
P_2ndStrategy = sensor.createPo(10)
for i in range(m):
centerPredicted, pPredicted = newFilter.Predict(X_2ndStrategy,P_2ndStrategy)
X_2ndStrategy,P_2ndStrategy = newFilter.Filter(centerPredicted,pPredicted,(newTrajectory.T)[i])
allX_2ndStrategy[i]=X_2ndStrategy
rx_2ndStrategy_f = list(allX[:,0,:1].T.flat)
ry_2ndStrategy_f = list(allX[:,1,:2].T.flat)
plt.scatter(rx_2ndStrategy_f,ry_2ndStrategy_f) # print filtered predictions
def __init__(self):
self.physio = dict(
{"eat": 100.0, "sleep": 100.0, "play": 10.0, "obs": 0.0, "stan": 0.0, "warn": 0.0}) # すべて0-1
self.p_decay = dict(
{"sleep": 2.0, "eat": 6.0, "play": 3.0, "obs": 20.0, "stan": 0.0, "warn": 0.0})
self.modules = {"reflector": Reflect(), "sleeper": Sleep(), "eater": Eat(), "observer": Observe(), "player": Interact()} # [0]が一番優先度高い
self.belief = {"food": 0}
print("======= installed modules")
for i in range(len(self.modules)):
print("•" + str(list(self.modules.keys())[len(self.modules) - i - 1]))
print("\n\n======= it got birth\n\n")
self.max_pos = 87.0
self.border_pos = 25.0
self.sensor = Sensor(self.max_pos, self.border_pos)
self.sensor_info = {"food": 0, "sound": deque([0], maxlen=30), "touch": deque([[0, 0, 0]], maxlen=20),
"torque": deque([0], maxlen=100), "pos": 0, "pos_log": deque([0], maxlen=50), "velo_log": deque([0], maxlen=50)} # 外からはreadonly
for k in self.modules.keys():
self.modules[k].s = self.sensor_info
self.modules[k].p = self.physio
self.modules[k].b = self.belief
#self.food = 0 # binary
#self.touch = [0,0,0] # 頭,胸,腹 だいたいで正規化して1-10にする
#self.torque = 0 # だいたいで正規化して1-10にする
self.action_log = {"none": 0, "sleeper": 0, "eater": 0, "player": 0}
self.motor_init()
def sensor_register_dev(mac):
'''
Sensors send a registration request at startup and periodic hellos
Registration includes the mac for id as well as ip and the states for the ports
Returns the sensor_id from the database for reference
Returns the desired states for all the ports
'''
sensor_ip = request.args.get('ip')
sensor_type = request.args.get('sensortype')
port_types = request.args.getlist('porttype')
states = request.args.getlist('state')
ports = zip(port_types, states)
try:
s = Sensor(mac, sensor_ip, sensor_type, port_types, states, ports)
response_text = str(s.sensor_id) + "?"
for i, port in enumerate(s.desired_states()):
response_text += str(port[0]) + "=" + str(port[1])
if i < len(s.ports) - 1:
response_text += "&"
response_text += "\n"
#print response_text
#resp = make_response(str(s.sensor_id) + '\n')
resp = make_response(response_text)
return resp
except:
resp = make_response("Error")
return resp
class IMUCalibrateScreen(BaseScreen):
offset = NumericProperty()
real_angle = NumericProperty()
adc_angle = NumericProperty()
def on_pre_enter(self):
self.event = Clock.schedule_interval(self.update_data, ONE_SEC / 2)
self.sensor = Sensor()
self.config_data = config.get('sensors', {})
if 'IMU Angle' in self.config_data:
self.offset = self.config_data['IMU Angle']['offset']
else:
self.offset = 0
def set_to_zero(self):
sensor_data = self.sensor.get_sensor_data(1)
self.offset = sensor_data['IMU Angle']
def update_data(self, obj):
sensor_data = self.sensor.get_sensor_data(1)
self.adc_angle = sensor_data['IMU Angle']
self.real_angle = sensor_data['IMU Angle'] - self.offset
def save(self):
self.config_data['IMU Angle'] = {'offset': self.offset}
config.set('sensors', self.config_data)
self.event.cancel()
return True
def __init__(self):
self._mongo = Mongo()
self._sensor = Sensor()
self._adafruit = Adafruit()
self._lcd = lcd_ecologic()
self._led = LED()
self._firebase = Firebase()
def on_pre_enter(self):
self.test_time = 0
self.temperature = 0
self.humidity = 0
self.location = 0
self.x_load = 0
self.y_load = 0
self.pot_angle = 0
self.imu_angle = 0
self.data_rate = 0
self.second_counter = 0
self.double_counter = 0
self.start_time = datetime.datetime.now()
self.datasets = []
self.x_max1 = 5
self.y_max1 = 100
self.y_max2 = 5
self.x_major = int(self.x_max / 5)
self.y_major1 = int(self.y_max1 / 5)
self.y_major2 = int(self.y_max2 / 5)
self.datasets = []
self.test_sensor = Sensor()
self.plot1 = MeshLinePlot(color=[1, 1, 1, 1])
self.plot2 = MeshLinePlot(color=[1, 1, 1, 1])
self.event = Clock.schedule_interval(self.update_dataset, INTERVAL)
def captureImage(self):
try:
def decdeg2dms(dd):
dd = abs(dd)
minutes,seconds = divmod(dd*3600,60)
degrees,minutes = divmod(minutes,60)
return (degrees,minutes,seconds)
sensor = Sensor()
sensor.get_header_data()
sensor_data = sensor.get_sensor_data()
location = [sensor_data["Location"][0], sensor_data["Location"][1]]
latdms = decdeg2dms(location[0])
londms = decdeg2dms(location[1])
except:
# print('Location Data not found')
location = [0, 0]
try:
self.camera.exif_tags['GPS.GPSLatitudeRef'] = 'N' if location[0] > 0 else 'S'
self.camera.exif_tags['GPS.GPSLongitudeRef'] = 'E' if location[1] > 0 else 'W'
self.camera.exif_tags['GPS.GPSLatitude'] = '%d/1,%d/1,%d/100' % (latdms[0], latdms[1], latdms[2])
self.camera.exif_tags['GPS.GPSLongitude'] = '%d/1,%d/1,%d/100' % (londms[0], londms[1], londms[2])
except:
pass # print('Location Data not added')
try:
dt = datetime.datetime.now()
filename = 'Images/Stalk_' + dt.strftime('%Y_%m_%d_%H_%M_%S') + '.jpg'
self.camera.capture(filename)
except:
pass # print('Taking Imaginary Picture')
def test_setTemperatur(self):
ID1 = 'someID'
temperatur = 85
newTemperatur = 40
s1 = Sensor(name='a', temperatur=temperatur, identifier=ID1)
s1.setTemperatur(newTemperatur)
self.assertEqual(s1.getTemperatur(), newTemperatur)
def __init__(self, token):
self.APIServer = '13.209.66.217'
self.port = 3000
self.Sensor = Sensor(self)
self.token = token
self.gid = -1
self.gname = 'default gateway name'
self.SocketIO = SocketIO(
self.APIServer, self.port,
headers = {'x-access-token': self.token},
)
self.Socket = self.SocketIO.define(BaseNamespace, '/gateway')
self.IRSerial = IRSerial(self)
self.IRSerialTemp = []
self._setOnListener()
# Check Setting backfile
if os.path.isfile('setting.json'):
settings = json.loads(open('setting.json').read())
self.gid = settings['gid']
self.gname = settings['gname']
self._emit_notifyGid()
else:
self.macAddr = self._getMAC('wlan0')
self._emit_gatewayInit()
def __start_connection_rfid(self, data):
sensor = Sensor(self, data['serial'], data['baudrate'], data['region'],
data['protocol'], data['antenna'], data['frequency'])
sensor.run()
if self.sensor != None:
print(
f"{bcolors.GREEN}Conexão com RFID iniciado... {bcolors.COLOR_OFF}"
)
def test_isLinked(self):
slaveList = getSlaveList()
for identifier in slaveList:
sensor = Sensor(identifier=identifier)
self.assertTrue(sensor.isLinked())
s2 = Sensor(identifier='kaswurscht')
self.assertFalse(s2.isLinked())
def on_pre_enter(self):
self.event = Clock.schedule_interval(self.update_data, ONE_SEC / 2)
self.sensor = Sensor()
self.config_data = config.get('sensors', {})
if 'IMU Angle' in self.config_data:
self.offset = self.config_data['IMU Angle']['offset']
else:
self.offset = 0
def iothub_client_run():
try:
client = iothub_client_init()
if client.protocol == IoTHubTransportProvider.MQTT:
print("IoTHubClient is reporting state")
reported_state = "{\"newState\":\"standBy\"}"
client.send_reported_state(reported_state, len(reported_state),
send_reported_state_callback,
SEND_REPORTED_STATE_CONTEXT)
if not config.SIMULATED_DATA:
sensor = Sensor(DEVICE_FILE)
else:
sensor = SensorSimulator()
telemetry.send_telemetry_data(parse_iot_hub_name(), EVENT_SUCCESS,
"IoT hub connection is established")
before_temperature = 0
while True:
global MESSAGE_COUNT, MESSAGE_SWITCH
if MESSAGE_SWITCH:
# send a few messages every minute
print("IoTHubClient sending %d messages" % MESSAGE_COUNT)
temperature = sensor.read_temperature()
msg_txt_formatted = MSG_TXT % (DEVICE_NAME, temperature,
before_temperature)
print(msg_txt_formatted)
message = IoTHubMessage(msg_txt_formatted)
# optional: assign ids
message.message_id = "message_%d" % MESSAGE_COUNT
message.correlation_id = "correlation_%d" % MESSAGE_COUNT
# optional: assign properties
prop_map = message.properties()
client.send_event_async(message, send_confirmation_callback,
MESSAGE_COUNT)
print(
"IoTHubClient.send_event_async accepted message [%d] for transmission to IoT Hub."
% MESSAGE_COUNT)
status = client.get_send_status()
print("Send status: %s" % status)
before_temperature = temperature
MESSAGE_COUNT += 1
time.sleep(config.MESSAGE_TIMESPAN / 1000.0)
except IoTHubError as iothub_error:
print("Unexpected error %s from IoTHub" % iothub_error)
telemetry.send_telemetry_data(
parse_iot_hub_name(), EVENT_FAILED,
"Unexpected error %s from IoTHub" % iothub_error)
return
except KeyboardInterrupt:
print("IoTHubClient sample stopped")
print_last_message_time(client)
def get_adc(self, obj):
vals = []
adc_input = self.ids['adc']
sensor = Sensor()
for i in range(100):
sensor_data = sensor.get_sensor_data(1)
vals.append(sensor_data[self.sensor_name])
med_val = median(vals)
adc_input.text = str(med_val)
def test_get_avaiable_targets():
sen = Sensor(2, 2, Point(8, 9))
a = build_scheduler(sen=[sen], tar=[])
targets = a.get_avaiable_targets()
assert len(targets) == 4
assert len(a.get_avaiable_targets()) == 4
sen.active = False
assert len(a.get_avaiable_targets()) == 3
def on_pre_enter(self):
sensor = Sensor()
sensor.clear_gps_memory()
# Get notes from config file
notes = config.get('notes', {"posttest": []})
# Set the data
self.ids['posttest'].list_data = notes["posttest"]
def __init__(self, left_device=[25, 27], right_device=[5, 6]):
self.current_detection = None
self.sensor_left = Sensor(trigger_channel=left_device[0],
echo_channel=left_device[1])
self.sensor_right = Sensor(trigger_channel=right_device[0],
echo_channel=right_device[1])
print('DirectionDetector initialized')
self.setup()
def __init__(self, alert):
self.sensor = Sensor()
self.alert = alert
self.flag = True
self.client = mqtt.Client()
self.client.on_connect = self.on_connect
self.client.on_message = self.on_message
self.client.username_pw_set(USER, PASS)
self.client.connect(MQTT_REMOTE_SERVER, 1883, 60)
print("connected")
def main():
#---------------------------------------------------------------------------#
# Logging - Rotate log file at midnight and keep for 7 days
#---------------------------------------------------------------------------#
handler = logging.handlers.TimedRotatingFileHandler(Config.Log_Filename, when="midnight", interval=1, backupCount=7)
handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
logger = logging.getLogger('cr-smart-home')
logger.addHandler(handler)
logger.setLevel(Config.Log_Level)
log = Log()
log.info('Server', 'Starting CR Smart Home %s...' % Config.Version)
#---------------------------------------------------------------------------#
# Upgrade
#---------------------------------------------------------------------------#
upgrade = Upgrade()
upgrade.Upgrade()
#---------------------------------------------------------------------------#
# Startup
#---------------------------------------------------------------------------#
weather = Weather()
sun = Sun()
lamp = Lamp()
sensor = Sensor()
log.info('Server', 'System is running in %s (Lat=%f, Long=%f)' % (weather.city, sun.latitude, sun.longitude))
bStartUp = True
#---------------------------------------------------------------------------#
# Run program
#---------------------------------------------------------------------------#
while True:
# Update current weather on startup or every 30 minutes
if (datetime.now().minute == 0 or datetime.now().minute == 30 or bStartUp == True):
weather.UpdateCurrentWeather();
# Update sun to database every hour
if (datetime.now().minute == 0 or bStartUp == True):
sun.UpdateDb()
# Lamp schedule
lamp.Schedule()
# Sensors
if (datetime.now().minute % 10 == 0 or bStartUp):
sensor.readAll()
#Reset startup bool
bStartUp = False
#Sleep one minute
time.sleep(60 - datetime.now().second)
def __init__(self, temp, scale):
"""
__value: from Sensor class
__scale: from Sensor class
:param temp: to associate with this temperature data instance
:param scale: to associate with this scale data instance
"""
#Using the Sensor class initialiser
Sensor.__init__(self, temp, scale)
def test_get_percent_observed_targets():
sen1 = Sensor(2, 2, Point(0, 0))
sen2 = Sensor(2, 2, Point(1, 0))
tar1 = Target(Point(1, 1))
tar2 = Target(Point(4, 4))
tar4 = Target(Point(5, 5))
tar3 = Target(Point(3, 0))
sensor_list = [sen1, sen2]
targest_list = [tar1, tar2, tar3, tar4]
a = Scheduler(sensor_list, targest_list, 2, 2)
assert a.get_percent_observed_targets() == 50
def __init__(self,ip="192.168.0.154",port= 301):
self.ip = ip
self.port = port
try:
self.s = Sensor(self.ip, self.port)
except OSError:
print("Could not connect to device with IP %s" % (arguments.sensorip))
sys.exit(1)
self.raw = self.read_raw()
self.data = []
self.globalc = 0
def connect_sensor2(self, values):
self.sensor2 = Sensor(comport=values['port'],
baudrate=values['baudrate'],
databits=values['databits'],
parity=values['paritybits'],
stopbits=values['stopbits'],
dataHeader=values['header'])
self.sensor2Timer = QTimer()
self.sensor2Timer.setInterval(
float(self.sensor2SampleIntervalEdit.text()) * 1000 * 60)
self.sensor2Timer.timeout.connect(self.sensor2_get_data)
self.sensor2Timer.start()
def __getXYFromSensor(self, sensor: Sensor):
tempXY = []
# return the x, y, id and heatmaps for each sensor
for i in range(0, len(sensor.getX())):
tempXY.append({
'x': sensor.getX()[i],
'y': sensor.getY()[i],
'id': sensor.getId(),
'heatmaps': sensor.getHeatmaps()[i]
})
return tempXY
class Alert:
root=None
def __init__(self):
self.state = False
self.sensor=Sensor()
def getState(self):
return self.state
def setState(self, state):
self.state = state
def run(self):
ruido = []
tiempo=0
contador=0
num=10
while True:
#time.sleep(1)
if(self.getState()==True):
#tiempo=tiempo+1
#if(tiempo<num):
#print(tiempo)
#time.sleep(1)
self.sound, self.tempe,self.humi= self.sensor.sensor()
self.data="dev1"+"/"+str(self.sound)+"/"+str(self.tempe)+"/"+str(self.humi)+"/"+"32"+"/"+"1"
print(self.data)
ruido.append(self.sound)
print("max: "+str(np.max(ruido))+" Min:"+str(np.min(ruido))+" Mean: "+ str(np.mean(ruido)))
print(self.data)
print(self.getState())
if self.sound >= 1500:
contador=contador+1
sendData(self.sound,self.tempe,self.humi)
else:
contador=0
sendData(self.sound,self.tempe,self.humi)
print("paso")
#elif(tiempo==num):
#tiempo=0
if(contador>=5):
#sendData2(self.sound,self.tempe,self.humi)##Enviar al front
self.sensor.alert()
print("ALERTAAA")
contador=0
else:
print("un no")
#contador=0
else:
print("Dispositivo apagado")
def __init__(self, humidity, scale):
"""
Initialiser- instance variable:
__value: from Sensor class
__scale: from Sensor class
:param humidity: to associate with this humidity data instance
:param scale: to associate with this scale data instance
"""
#Using the Sensor class initialiser
Sensor.__init__(self,humidity,scale)
def build_scheduler(sen, tar):
sen1 = Sensor(2, 2, Point(0, 0))
sen2 = Sensor(2, 2, Point(1, 0))
tar1 = Target(Point(1, 1))
tar4 = Target(Point(0, 1))
tar2 = Target(Point(2.5, 0))
tar3 = Target(Point(8, 8))
target_list = [tar1, tar2, tar3, tar4]
sensor_list = [sen1, sen2]
for sensor in sen:
sensor_list.append(sensor)
for target in tar:
sensor_list.append(target)
a = Scheduler(sensor_list, target_list, 2, 2)
return a
def readFile(self):
file = open('/home/hoang/datasets/data2.txt', 'r')
while True:
line = file.readline()
if not line:
break
line = line.rstrip('\n')
result = line.split(',')
result = [int(x) for x in result]
sensor = Sensor()
sensor.index = result[2]
sensor.coordinate.x = result[0]
sensor.coordinate.y = result[1]
self.sensorList.append(sensor)
file.close()
def test_build_fields_list():
sen1 = Sensor(2, 2, Point(0, 0))
sen2 = Sensor(2, 2, Point(1, 0))
tar1 = Target(Point(1, 1))
tar4 = Target(Point(0, 1))
tar2 = Target(Point(2.5, 0))
tar3 = Target(Point(8, 8))
target_list = [tar1, tar2, tar3, tar4]
sensor_list = [sen1, sen2]
a = Scheduler(sensor_list, target_list, 2, 2)
assert len(a.fields_list) == 2
assert len(sen1.fields) == 1
assert len(sen2.fields) == 2
assert len(sen1.fields[0].targets) == 2
def getValuesList(self):
result = Sensor.getValuesList(self)
if (self.__battery):
result.append(SensorValue(self.getUUID(), self.VALUE_BATTERY, self.__battery))
return result
def __init__(self, env, slam, control, sensor, pose, robot_id, v=0.0, color="yellow"):
self._env = env
self._slam = slam
self._control = control
self._sensor = sensor
self._pose = pose
self._id = robot_id
self._v = v
self._color = color
# Radius is 6% of env height
self._r = int(self._env.h() * 0.06)
# Create a control, if none was given
if not self._control:
noise = (0.3, 0.3, 0.05) # (x, y, theta) noise
self._control = Control(env, v, noise)
# Create a sensor, if none was given
if not self._sensor:
sensor_range = self._r * 4.0
noise = ((sensor_range * 0.05, 0.01), np.matrix([[0.70, 0.0], [0.0, 0.70]]))
self._sensor = Sensor(self._env, sensor_range=sensor_range, noise=noise, width=2.0*self._r)
# Create a SLAM algorithm object, if none was given
if not self._slam:
M = 20 # number of particles
self._slam = FastSLAM(self._control, self._sensor, pose, M, self._env.get_landmark_count())
class Gui:
root = None
def __init__(self):
self.state = False
self.sensor = Sensor()
def verde(self):
self.root.configure(background="green")
def rojo(self):
self.root.configure(background="red")
def setState(self, state):
self.state = state
def getState(self):
return self.state
def run(self):
tiempo = 0
contador = 0
num = 15
while True:
tiempo = tiempo + 1
if (tiempo < num):
time.sleep(1)
self.value = self.sensor.sensor()
print(self.value)
#state
print(self.getState())
if (self.getState() == True):
if self.value >= 1000:
contador = contador + 1
print("Hola")
sendSound(self.value)
#self.rojo()
else:
#self.amarillo()
sendSound(self.value)
else:
print("Dispositivo apagado")
elif (tiempo == num):
tiempo = 0
if (contador >= 7):
sendSound2(self.value)
self.rojo()
print("Conte mas de 7")
else:
self.verde()
contador = 0
def startGui(self):
self.root = Tk()
self.root.title('NIVEL DE SONIDO')
self.panel = Label(self.root, anchor="center")
self.panel.grid(row=10, columnspan=20)
self.root.attributes('-fullscreen', True)
mainloop()
def addRegistro(self, colection, sensor):
query = self.verRegistros(sensor.nombre)
registros = query if query else []
registros.append(Sensor(sensor.nombre, sensor.valor, sensor.fecha))
fichero = open(sensor.nombre + ".pckl", 'wb')
pickle.dump(registros, fichero)
fichero.close()
class BFG_Queue:
__queue = deque()
__isEmpty = True
__location = None
__ID = None
__signal = None
__sensor = -1
def __init__(self,location,ID):
print "initializing queue"
self.__location = location
self.__ID = ID
self.__sensor = Sensor(ID, location)
def push(self, Signal):
print "pushing: " + Signal
self.__queue.append(Signal)
self.setEmptyFlag(False)
def flushQueue(self):
print "flush queue"
newDeque = deque()
for signal in self.__queue:
newDeque.append(signal)
self.__queue.clear()
self.setEmptyFlag(True)
return newDeque
def printQueue(self):
for signal in self.__queue:
print signal
def setEmptyFlag(self, empty):
self.__isEmpty = empty
#doing queue things
def getEmptyFlag(self):
self.__sensor.listenSignal()
if not self.__sensor.isEmpty():
self.push(self.__sensor.getSignal())
self.setEmptyFlag(False)
return self.__isEmpty
def initSensor(self):
__sensor = Sensor()
def __init__(self, retriever, rtimer, displayer): """ @retriever : function that retrieves data @type retriever: callable, returns True when new data available. @rtimer : function that return a sleep duration @type rtimer : callable. Returns int > 0. @displayer : function that displays data @type displayer : callable On config changed, only @displayer is called. @retriever lives is life, polling data and calling @displayer when needed. That's the best we can do with these old deprecated Sensor. """ Sensor.__init__(self) self.__retriever = retriever self.__rtimer = rtimer self.__displayer = displayer self.__retriever_event = threading.Event() self.__displayer_event = threading.Event() self.watch_stop( self.__on_stop ) self.watch_config( self.__on_update ) def once(): self.add_thread( self.__retriever_thread ) self.add_thread( self.__displayer_thread ) self._start = None self._start = once
def test_measure(self):
s1 = Sensor(identifier='28-00044c86c8ff')
s2 = Sensor('kaswurscht')
s1.measure()
s2.measure()
if type(s1._temperatur) is str:
print ('Warnung: Sensor in test_measure nicht ansprechbar!')
self.assertIsInstance(s1._temperatur, str)
else:
self.assertIsInstance(s1._temperatur, float)
self.assertEqual(s2._temperatur, SENSOR_OFFLINE)
def test__memoryInsert(self):
s1 = Sensor(name="s1", identifier='someID1', memorysize=0)
s2 = Sensor(name="s2", identifier='someID2', memorysize=5)
s3 = Sensor(name="s3", identifier='someID3', memorysize=500)
s4 = Sensor(name="s4", identifier='someID4', memorysize=-1)
testTemperatur1 = 25
testTemperatur2 = -25
testTemperatur3 = 500
for i in range(s1._memorysize + 2):
s1.memoryInsert(testTemperatur1)
for i in range(s2._memorysize + 2):
s2.memoryInsert(testTemperatur1)
s2.memoryInsert(testTemperatur2)
s2.memoryInsert(testTemperatur3)
for i in range(s3._memorysize + 2):
s3.memoryInsert(testTemperatur1)
s3.memoryInsert(testTemperatur2)
s3.memoryInsert(testTemperatur3)
s4.memoryInsert(testTemperatur1)
s4.memoryInsert(testTemperatur2)
s4.memoryInsert(testTemperatur3)
self.assertEqual(len(s1.memory), s1._memorysize)
self.assertEqual(len(s2.memory), s2._memorysize)
self.assertEqual(len(s3.memory), s3._memorysize)
self.assertEqual(len(s4.memory), 0)
for i in range(s1._memorysize):
self.assertEqual(s1.memory[i][0], testTemperatur1)
for i in range(s2._memorysize,2,3):
self.assertEqual(s2.memory[i-2][0], testTemperatur1)
self.assertEqual(s2.memory[i-1][0], testTemperatur2)
self.assertEqual(s2.memory[i][0], testTemperatur3)
for i in range(s3._memorysize,2,3):
self.assertEqual(s3.memory[i-2][0], testTemperatur1)
self.assertEqual(s3.memory[i-1][0], testTemperatur2)
self.assertEqual(s3.memory[i][0], testTemperatur3)
for i in range(s4._memorysize):
self.assertEqual(s1.memory[i][0], testTemperatur1)
s2.memoryInsert(5)
self.assertEqual(s2.memory[0][0],5)
s3.memoryInsert(5)
self.assertEqual(s3.memory[0][0],5)
def __init__(self):
Sensor.__init__(self)
ServerThread().start()
def __init__(self, frecuencia, pins):
Sensor.__init__(self, frecuencia)
self.pins = pins # ubicacion es un arreglo que contiene el numero de los pines en modo BCM
import abc
from Sensor import Sensor
import RPi.GPIO as GPIO
class GPIOSensor(Sensor):
__metaclass__ = abc.ABCMeta
def __init__(self, frecuencia, pins):
Sensor.__init__(self, frecuencia)
self.pins = pins # ubicacion es un arreglo que contiene el numero de los pines en modo BCM
def clearSensor(self):
GPIO.cleanup()
def getGPIOpins(self):
return self.ubicacion
@abc.abstractmethod
def setGPIOpins(self):
""" Establece los pines del sensor """
pass
Sensor.register(GPIOSensor)
def __init__(self, disk, min, max): Sensor.__init__(self, 'Disk %s' % disk, min, max) self.__disk = disk self.__time = -1 self.setInterval(300)
def __init__(self,ubicacion, frecuencia): Sensor.__init__(self, ubicacion, frecuencia) self.tipo = "HUMEDAD Y TEMPERATURA" GPIO.setmode(GPIO.BCM) # Usa el sistema de nombramiento BCM - la otra alternatica es BOARD
params.addParam('WAIT_TIME', 2, 'How many seconds in between exploration steps')
# Add Tuning Parameters
params.addParam('DISTANCE_WEIGHT', [0.1, 0.1, 0.2],
'Weighting of [X, Y, Theta] each when determining distance metric')
# Add Motor Parameters
params.addParam('SEC_PER_TURN', 2.8, 'Seconds required to turn 1 unit')
params.addParam('SEC_PER_MOVE', 1.0, 'Seconds required to move 1 unit')
params.addParam('DIST_PER_MOVE', 10.0, 'Centimeters in 1 move unit')
params.addParam('DEG_PER_TURN', 2*math.pi, 'Radians in 1 turn unit')
params.addParam('MOTOR_DEFAULT_PWM_DC', 30, 'Default duty cycle for the motor PWM (0 - 100)')
params.addParam('MOTOR_DEFAULT_PWM_FREQ', 357, 'Default frequency for the motor PWM')
# Create Sensor object
sensors = Sensor()
# Add sensors to sensor dictionary
# 'Name', number, weight (higher is more important), location
sensors.addSensor('HC-SR04', 1, 2, [0, 8.5, 0, math.pi / 2])
sensors.addSensor('HC-SR04', 2, 2, [7.36, 4.25, 0, math.pi / 6])
sensors.addSensor('HC-SR04', 3, 2, [7.36, -4.25, 0, -math.pi / 6])
sensors.addSensor('HC-SR04', 4, 2, [0, -8.5, 0, -math.pi / 2])
sensors.addSensor('HC-SR04', 5, 2, [-7.36, -4.25, 0, -5 * (math.pi / 6)])
sensors.addSensor('HC-SR04', 6, 2, [-7.36, 4.25, 0, 5 * (math.pi / 6)])
sensors.addSensor('TSL2561', 1, 1, [7.36, 4.25, 0, math.pi / 6])
sensors.addSensor('TSL2561', 2, 1, [0, -8.5, 0, -math.pi / 2])
sensors.addSensor('TSL2561', 3, 1, [-7.36, 4.25, 0, 5 * (math.pi / 6)])
# Create PinMaster object
pins = PinMaster()
class Robot(object):
# Constructor
# @param env The Robot's Environment
# @param slam SLAM algorithm
# @param control A Control object
# @param sensor A Sensor object
# @param pose Initial pose
# @param v Translational velocity
# @param color Color of the robot (black by default)
def __init__(self, env, slam, control, sensor, pose, robot_id, v=0.0, color="yellow"):
self._env = env
self._slam = slam
self._control = control
self._sensor = sensor
self._pose = pose
self._id = robot_id
self._v = v
self._color = color
# Radius is 6% of env height
self._r = int(self._env.h() * 0.06)
# Create a control, if none was given
if not self._control:
noise = (0.3, 0.3, 0.05) # (x, y, theta) noise
self._control = Control(env, v, noise)
# Create a sensor, if none was given
if not self._sensor:
sensor_range = self._r * 4.0
noise = ((sensor_range * 0.05, 0.01), np.matrix([[0.70, 0.0], [0.0, 0.70]]))
self._sensor = Sensor(self._env, sensor_range=sensor_range, noise=noise, width=2.0*self._r)
# Create a SLAM algorithm object, if none was given
if not self._slam:
M = 20 # number of particles
self._slam = FastSLAM(self._control, self._sensor, pose, M, self._env.get_landmark_count())
def slam(self): return self._slam
def pose(self): return self._pose
# Draw the robot at its current pose
# @param canvas The canvas onto which to draw the robot
def draw(self, canvas):
(x, y, theta) = self._pose
# Lest we forgot to render the sensor "beam"...
self._sensor.draw(canvas, self._pose)
# Draw the circle, which is the body of the robot
canvas.create_oval(
x - self._r,
y + self._r,
x + self._r,
y - self._r,
outline="black",
fill=self._color,
width=1,
tags=('robot', 'body'))
# Next, wheel axis
canvas.create_line(
x - int(self._r * sin(theta)),
y + int(self._r * cos(theta)),
x + int(self._r * sin(theta)),
y - int(self._r * cos(theta)),
fill="black",
tags=('robot', 'wheelaxis'))
# Now comes the wheels
# TODO (not strictly necessary)
# Finally, draw the arrow indicating robot direction perpendicular
# to the wheel axis
canvas.create_line(
x,
y,
x + self._r * cos(theta),
y + self._r * sin(theta),
arrow=LAST,
arrowshape=(3,5,3),
fill="black",
tags=('robot', 'direction'))
# Update the Robot's pose
# @param dt Time delta
def update(self, dt):
(x, y, theta) = self._pose
# Make the move (might be undone in case of collision)
(new_x, new_y, _) = self._control.move(self._pose, dt)
# Take a sensor reading, see if there are any impending collisions
measurements = self._sensor.sense((new_x, new_y, theta))
sensed_collision = False
if len(measurements) > 0:
# Taking this move will lead to a collision, so stay where we are
new_x, new_y = x, y
sensed_collision = True
# Query the control for the new heading
self._pose = (new_x, new_y, self._control.action(sensed_collision, theta))
# Finally, run the SLAM algorithm
self._slam._x = self._pose
self._slam.run(measurements, dt)
return self
def __init__(self, name, id, min, max): Sensor.__init__(self, name, min, max) self.__id = id
def test_getID(self):
ID1 = 'someID'
s1 = Sensor(name='a', temperatur=20, identifier=ID1)
self.assertEqual(s1.getID(), ID1)
def test_Sensor(self):
sensor = Sensor()
sensor.DHT(1, Adafruit_DHT.DHT22, 9)
sensor.DS(2, W1ThermSensor.THERM_SENSOR_DS18B20, "0000072f3122")
sensor.readAll()
sensor.SQLQuery("INSERT INTO ha_data (DataId, DataName, DataText, DataStatus, DataLastUpdated) VALUES (9999, 'Test', 'Test', 200, NOW()) ON DUPLICATE KEY UPDATE DataText = VALUES(DataText), DataStatus = VALUES(DataStatus), DataLastUpdated = VALUES(DataLastUpdated)")
def __init__(self, callback):
Sensor.__init__(self)
self.callback = callback
GPIO.add_event_detect(PIN_PIR, GPIO.FALLING, callback=lambda channel: self.trigger(channel))
def __init__(self, location):
Sensor.__init__(self, location)
# print crc except: print "ERR_RANGE" exit(0) Humidity = self.bin2dec(HumidityBit) Temperature = self.bin2dec(TemperatureBit) if int(Humidity) + int(Temperature) - int(self.bin2dec(crc)) == 0: print "Humidity:"+ Humidity +"%" print "Temperature:"+ Temperature +"C" else: print "ERR_CRC" def bin2dec(self, string_num): return str(int(string_num, 2)) def clearSensor(self): GPIO.cleanup() def getPosition(self): print 'OUT = ', self.OUT print self.ubicacion def getTipo(self): print self.tipo Sensor.register(HumidityTemperature)
def test_setID(self):
ID1 = 'someID'
s1 = Sensor(name='a', temperatur=20, identifier=ID1)
newID = 'someNewId'
s1.setID(newID)
self.assertEqual(s1.getID(), newID)
def test_getTemperatur(self):
temperatur = 85
ID1 = 'someID'
s1 = Sensor(name='a', temperatur=temperatur, identifier=ID1)
self.assertEqual(s1.getTemperatur(), temperatur)
def __init__(self,location,ID):
print "initializing queue"
self.__location = location
self.__ID = ID
self.__sensor = Sensor(ID, location)
except KeyboardInterrupt:
print('Interrupted by keyboard \nBye')
print("Unexpected error:", sys.exc_info()[0])
return
except:
print('Other exceptions')
print("Unexpected error:", sys.exc_info()[0])
return
finally:
GPIO.cleanup()
return
growroom = Main()
#start growroom logic here
pump1 = Actuator(23, 'water_pump',3)
pump2 = Actuator(24, 'water_pump',1)
hygrometer1 = Sensor(17,'hygrometer',pump1.turnOn)
hygrometer2 = Sensor(22,'hygrometer',pump2.turnOn)
#growroom.run()
while True:
time.sleep(1)
hygrometer1.getStatus()
hygrometer2.getStatus()
def __init__(self):
Sensor.__init__(self)
APIThread().start()
def test_getName(self):
name1 = 'someName'
ID1 = 'someID'
s1 = Sensor(name='a', temperatur=20, identifier=ID1)
self.assertTrue(s1.getName(), name1)
