def ReadFlowerCare(address): try: requester = GATTRequester(address) except: return 'error', 0, 0, 0, 0, 0 try: # Read battery and firmware version attribute data = requester.read_by_handle(0x0038)[0] battery, version = unpack('<B6s', data) version = filter(lambda x: x in string.printable, version) except: return 'error', 0, 0, 0, 0, 0 try: # Enable real-time data reading requester.write_by_handle(0x0033, str(bytearray([0xa0, 0x1f]))) except: return 'error', 0, 0, 0, 0, 0 try: # Read plant data data = requester.read_by_handle(0x0035)[0] except: return 'error', 0, 0, 0, 0, 0 try: temperature, sunlight, moisture, fertility = unpack( '<hxIBHxxxxxx', data) return version, battery, temperature, sunlight, moisture, fertility except: return 'error', 0, 0, 0, 0, 0
def write_data(self, DEVICE, service, data): req = GATTRequester(DEVICE) try: req.write_by_handle(service, str(data)) print("Data was written") except: print("Write error")
class MagicBlue: def __init__(self, mac_address): self.mac_address = mac_address self._connection = None def connect(self): """ Connect to device :return: True if connection succeed, False otherwise """ self._connection = GATTRequester(self.mac_address, False) try: self._connection.connect(True, "random") except RuntimeError as e: logger.error('Connection failed : {}'.format(e)) return False return True def disconnect(self): """ Disconnect from device """ self._connection.disconnect() def is_connected(self): """ :return: True if connection succeed, False otherwise """ return self._connection.is_connected() def set_color(self, rgb_color): """ Change bulb's color :param rgb_color: color as a list of 3 values between 0 and 255 """ self._connection.write_by_handle(HANDLE_CHANGE_COLOR, bytes(bytearray([MAGIC_CHANGE_COLOR] + list(rgb_color)))) def set_random_color(self): """ Change bulb's color with a random color """ self.set_color([random.randint(1, 255) for i in range(3)]) def turn_off(self): """ Turn off the light by setting color to black (rgb(0,0,0)) """ self.set_color([0, 0, 0]) def turn_on(self, brightness=1.0): """ Set white color on the light :param brightness: a float value between 0.0 and 1.0 defining the brightness """ self.set_color([int(255 * brightness) for i in range(3)])
def OnGSRButtonClick(self): req = GATTRequester("98:4F:EE:0F:59:D6") temp = [] f = open("gsr.csv", 'a') writer = csv.writer(f) writer.writerow( ('timestamp', 'gsr') ) flagTemp = 0; flagBP = 1; flagGSR = 0; req.write_by_handle(0x000e,str(bytearray([01]))) tt = req.read_by_handle(0x0010)[0]
class Reader(object): def __init__(self, address): self.requester = GATTRequester(address , False) self.connect() self.send_data() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def send_data(self): self.requester.write_by_handle(0xb, str(bytearray([1]))) # You can find the bluetooth handle using
class Reader(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.send_data() def connect(self): print("Connecting...", end=" ") sys.stdout.flush() self.requester.connect(True) print("OK!") def send_data(self): self.requester.write_by_handle(0x2E, str(bytearray([2])))
class Reader(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.connect() self.send_data() def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def send_data(self): self.requester.write_by_handle(0x2e, str(bytearray([2])))
def OnBPButtonClick(self): f = open("bp.csv", 'wt') writer = csv.writer(f) writer.writerow( ('sys', 'dia','pulse') ) req = GATTRequester("98:4F:EE:0F:59:D6") req.write_by_handle(0x000e,str(bytearray([02]))) tt = req.read_by_handle(0x0010)[0] pp = [] for c in tt: pp.append(ord(c)) print pp if(pp[1] == 2): while(1): try: tt = req.read_by_handle(0x0010)[0] pp = [] for c in tt: pp.append(ord(c)) if(pp[0] == 3): break except Exception,e: print e try: name = req.read_by_uuid("2A40")[0] #steps = (req.read_by_handle(0x0009)[0]) print type(name) value = [] for c in name: value.append((c)) print value print "sys :"+value[1]+value[2]+value[3]+"\n" print "dia :"+value[6]+value[7]+value[8]+"\n" print "sys :"+value[11]+value[12]+value[13]+"\n" writer.writerow((value[1]+value[2]+value[3],value[6]+value[7]+value[8],value[11]+value[12]+value[13])) except Exception,e: #name = False print e
class RoboRoach: ####################### # API Constants ####################### ROBOROACH_FREQUENCY_HANDLE = 0x002A ROBOROACH_PULSE_WIDTH = 0x002cD ROBOROACH_NUM_PULSES = 0x0030 ROBOROACH_RANDOM_MODE = 0x0033 ROBOROACH_RIGHT_HANDLE = 0x0036 ROBOROACH_LEFT_HANDLE = 0x0039 ROBOROACH_GAIN = 0x003C ROBOROACH_FREQ_MIN = 0x003F ROBOROACH_FREQ_MAX = 0x0042 ROBOROACH_PW_MIN = 0x0045 ROBOROACH_PW_MAX = 0x0048 ROBOROACH_GAIN_MIN = 0x004B ROBOROACH_GAIN_MAX = 0x004E ####################### # CONSTRUCTOR ####################### def __init__(self, mac_address): self.mac_address = mac_address self.req = GATTRequester(mac_address) print type(self.req) ####################### # COMMON FUNCTIONS ####################### def _turn(self, direction): if direction == 'right': self.req.write_by_handle(self.ROBOROACH_LEFT_HANDLE, str(bytearray([1]))) elif direction == 'left': self.req.write_by_handle(self.ROBOROACH_RIGHT_HANDLE, str(bytearray([1]))) else: print "Unknown direction"
from gattlib import GATTRequester import time # Send: 0x0035 for left # Send: 0x0039 for right # Send: 0x0029 for frequency req = GATTRequester("90:59:AF:14:08:E8") req.write_by_handle(0x0036, str(bytearray([1]))) time.sleep(1) req.write_by_handle(0x0039, str(bytearray([1])))
class Reader(object): def __init__(self, address): writeResponse = False try: self.requester = GATTRequester(address, False) self.connect() self.send_data() except: print("Connection failed") self.requester.connect(False) def connect(self): print("Connecting...", end=' ') sys.stdout.flush() self.requester.connect(True) print("OK!") def send_data(self): status = True profile = self.requester.read_by_handle(0x61) time.sleep(2) print(profile) #Checks the profile loaded by the FPGA, if it's 12, then stop loop while ("\x0c" not in profile): #Attempt to set profile to 12 try: self.requester.write_by_handle(0x61, str(bytearray([12]))) except RuntimeError: status = False break #Delay time to allow for successful transfer time.sleep(2) print("Currently in profile loop") try: profile = self.requester.read_by_handle(0x61) except RuntimeError: status = False break time.sleep(2) #time.sleep(3) while status: #Write the button press to reset data try: writeResponse = GATTResponse() self.requester.write_by_handle_async(0x72, str(bytearray([1])), writeResponse) counter = 0 time.sleep(0.4) information_taken = self.requester.read_by_handle(0xa2)[0] counter = 0 time.sleep(0.5) print("bytes received:", end=' ') print(int(ord(information_taken[0]))) #first array containing value data = {} data[fields[0]] = 0 #send to bpressure array data[fields[1]] = int(ord(information_taken[0])) params = urllib.urlencode(data) data = urllib.urlencode(data) headers = {} headers["Content-Type"] = 'application/x-www-form-urlencoded' headers["Connection"] = "close" headers["Content-Length"] = len(params) headers["Phant-Private-Key"] = private_hash c = httplib.HTTPConnection(base_url) c.request("POST", "/input/" + public_hash + ".txt", params, headers) #send to website https://data.sparkfun.com/streams/7JYarO9dElfVn7vnlG5q r = c.getresponse() #print (r.status,r.reason) #time.sleep(2) except: break try: self.requester.disconnect() except: print("disconnect failed")
def main(): conn = mysql.connect() cursor = conn.cursor() sql = "SELECT * FROM plants_info WHERE id = 1" cursor.execute(sql) results = cursor.fetchall() for row in results: plants_name = row[1] sun_b = row[2] sun_t = row[3] moi_b = row[4] moi_t = row[5] tem_b = row[6] tem_t = row[7] fer_b = row[8] fer_t = row[9] sql = "SELECT * FROM sensor_data_hour WHERE id = 2" cursor.execute(sql) results = cursor.fetchall() for row in results: status_led = row[7] status_water = row[8] status_fan = row[9] cursor.close() conn.close() sun_b = int(sun_b*10.76/(0.71*24)) sun_t = int(sun_t*10.76/(0.71*2)) status_sun = 1 status_moi = 1 status_tem = 1 status_fer = 1 if request.method == 'POST': if not session.get('mac'): conn = mysql.connect() cursor = conn.cursor() sql = "SELECT * FROM plants_info WHERE id = 1" cursor.execute(sql) results = cursor.fetchall() for row in results: address_x = row[0] cursor.close() conn.close() address = str(address_x) session['mac'] = address_x else: address = str(session['mac']) try: requester = GATTRequester(address) #Read battery and firmware version attribute data=requester.read_by_handle(0x0038)[0] battery, version = unpack('<B6s',data) #Enable real-time data reading requester.write_by_handle(0x0033, str(bytearray([0xa0, 0x1f]))) #Read plant data data=requester.read_by_handle(0x0035)[0] temperature, sunlight, moisture, fertility = unpack('<hxIBHxxxxxx',data) temperature=float(temperature/10) data_time=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") conn = mysql.connect() cursor = conn.cursor() sql = "UPDATE plants_info SET baterry = %d, firmware = '%s' WHERE id = 1" % (battery,version) cursor.execute(sql) conn.commit() sql = "UPDATE sensor_data_hour SET sunlight = %d, moisture = %d,temperature=%0.1f,fertility=%d,time='%s' WHERE id = 2" % (sunlight,moisture,temperature,fertility,data_time) cursor.execute(sql) conn.commit() cursor.close() conn.close() flash('Data updated successfully','success') except: flash('Could not update sensor value, please try again','danger') conn = mysql.connect() cursor = conn.cursor() sql = "SELECT * FROM sensor_data_hour WHERE id = 2" cursor.execute(sql) results = cursor.fetchall() for row in results: sunlight = row[1] moisture = row[2] fertility = row[4] temperature = row[3] data_time = row[5] cursor.close() conn.close() if sunlight < sun_b: status_sun = 0 elif sunlight > sun_t: status_sun = 2 if moisture < moi_b: status_moi = 0 elif moisture > moi_t: status_moi = 2 if temperature < tem_b: status_tem = 0 elif temperature > tem_t: status_tem = 2 if fertility < fer_b: status_fer = 0 elif fertility > fer_t: status_fer = 2 string_time = str(data_time) string_time = string_time[11:-6] check_hour = int(string_time) if check_hour >= 18 or check_hour <=5: status_sun = 3 return render_template('index.html',status_fan=status_fan,status_led=status_led,status_water=status_water,status_sun=status_sun,status_moi=status_moi,status_tem=status_tem,status_fer=status_fer,sun=sunlight,moi=moisture,tem=temperature,fer=fertility,time=data_time,plants_name=plants_name,sun_b=sun_b,sun_t=sun_t,moi_b=moi_b,moi_t=moi_t,tem_b=tem_b,tem_t=tem_t,fer_b=fer_b,fer_t=fer_t) else: conn = mysql.connect() cursor = conn.cursor() sql = "SELECT * FROM sensor_data_hour WHERE id = 2" cursor.execute(sql) results = cursor.fetchall() for row in results: data_sun = row[1] data_moi = row[2] data_fer = row[4] data_tem = row[3] data_time = row[5] cursor.close() conn.close() if data_sun < sun_b: status_sun = 0 elif data_sun > sun_t: status_sun = 2 if data_moi < moi_b: status_moi = 0 elif data_moi > moi_t: status_moi = 2 if data_tem < tem_b: status_tem = 0 elif data_tem > tem_t: status_tem = 2 if data_fer < fer_b: status_fer = 0 elif data_fer > fer_t: status_fer = 2 string_time = str(data_time) string_time = string_time[11:-6] check_hour = int(string_time) if check_hour >= 18 or check_hour <=5: status_sun = 3 return render_template('index.html',status_fan=status_fan,status_led=status_led,status_water=status_water,status_sun=status_sun,status_moi=status_moi,status_tem=status_tem,status_fer=status_fer,plants_name=plants_name,sun=data_sun,moi=data_moi,tem=data_tem,fer=data_fer,time=data_time,sun_b=sun_b,sun_t=sun_t,moi_b=moi_b,moi_t=moi_t,tem_b=tem_b,tem_t=tem_t,fer_b=fer_b,fer_t=fer_t)
class SensorTag(object): def __init__(self, address): self.requester = GATTRequester(address, False) self.humidity = float(0.0) self.temperature = float(0.0) self.object_temperature = float(0.0) self.barometer = float(0.0) self.gyrometer = {"x": float(0.0), "y": float(0.0), "z": float(0.0)} self.acceleration = {"x": float(0.0), "y": float(0.0), "z": float(0.0)} self.geomagnetism = {"x": float(0.0), "y": float(0.0), "z": float(0.0)} self.lux = float(0.0) def connect(self): print("Connecting...") self.requester.connect(True) print("Succeed.") def check_status(self): status = "connected" if self.requester.is_connected( ) else "not connected" print("Checking current status: {}".format(status)) def disconnect(self): print(str("Disconnecting...")) self.requester.disconnect() print("Succeed.") def enable_humidity(self, enable): status = '\x01' if enable else '\x00' self.requester.write_by_handle(0x2f, status) def check_humidity(self): time.sleep(3) raw_data = self.requester.read_by_handle(0x2c)[0] raw_temp = (ord(raw_data[1]) << 8) + ord(raw_data[0]) raw_humi = (ord(raw_data[3]) << 8) + ord(raw_data[2]) self.temperature = round((float(raw_temp) / float(65536)) * 165 - 40, 1) self.humidity = round((float(raw_humi) / float(65536)) * 100, 1) def enable_IRtemperature(self, enable): status = '\x01' if enable else '\x00' self.requester.write_by_handle(0x27, status) def check_IRtemperature(self): time.sleep(3) raw_data = self.requester.read_by_handle(0x24)[0] raw_obj = (ord(raw_data[1]) << 8) + ord(raw_data[0]) raw_amb = (ord(raw_data[3]) << 8) + ord(raw_data[2]) self.object_temperature = round((float(raw_obj) / 4.0) * 0.03125, 1) self.temperature = round((float(raw_amb) / 4.0) * 0.03125, 1) def enable_Barometer(self, enable): status = '\x01' if enable else '\x00' self.requester.write_by_handle(0x37, status) def check_Barometer(self): time.sleep(3) raw_data = self.requester.read_by_handle(0x34)[0] raw_temp = (ord(raw_data[2]) << 16) + (ord(raw_data[1]) << 8) + ord( raw_data[0]) raw_baro = (ord(raw_data[5]) << 16) + (ord(raw_data[4]) << 8) + ord( raw_data[3]) self.temperature = round(float(raw_temp) / 100.0, 1) self.barometer = round(float(raw_baro) / 100.0, 1) def enable_9AxisSensor(self, enable): status = '\x7f\x00' if enable else '\x00\x00' self.requester.write_by_handle(0x3f, status) def check_9AxisSensor(self): time.sleep(3) raw_data = self.requester.read_by_handle(0x3c)[0] raw_gyro_x = struct.unpack('h', raw_data[0] + raw_data[1])[0] raw_gyro_y = struct.unpack('h', raw_data[2] + raw_data[3])[0] raw_gyro_z = struct.unpack('h', raw_data[4] + raw_data[5])[0] raw_acce_x = struct.unpack('h', raw_data[8] + raw_data[7])[0] raw_acce_y = struct.unpack('h', raw_data[10] + raw_data[9])[0] raw_acce_z = struct.unpack('h', raw_data[10] + raw_data[11])[0] raw_geom_x = struct.unpack('h', raw_data[12] + raw_data[13])[0] raw_geom_y = struct.unpack('h', raw_data[14] + raw_data[15])[0] raw_geom_z = struct.unpack('h', raw_data[16] + raw_data[17])[0] self.gyrometer["x"] = round(float(raw_gyro_x) / (65536 / 500), 2) self.gyrometer["y"] = round(float(raw_gyro_y) / (65536 / 500), 2) self.gyrometer["z"] = round(float(raw_gyro_z) / (65536 / 500), 2) #/2.0 ? /8.0 ? self.acceleration["x"] = float(raw_acce_x) / (32768.0 / 8.0) self.acceleration["y"] = float(raw_acce_y) / (32768.0 / 8.0) self.acceleration["z"] = float(raw_acce_z) / (32768.0 / 8.0) self.geomagnetism["x"] = float(raw_geom_x) self.geomagnetism["y"] = float(raw_geom_y) self.geomagnetism["z"] = float(raw_geom_z) def enable_Optical(self, enable): status = '\x01' if enable else '\x00' self.requester.write_by_handle(0x47, status) def check_Optical(self): raw_data = self.requester.read_by_handle(0x44)[0] raw_lux = (ord(raw_data[1]) << 8) + ord(raw_data[0]) raw_lux_m = raw_lux & 0b0000111111111111 raw_lux_e = (raw_lux & 0b1111000000000000) >> 12 self.lux = raw_lux_m * (0.01 * pow(2.0, raw_lux_e))
class Koshian: """ Koshian.pyの基本クラス """ def __init__(self, mac=""): if mac == "": self.mac = find() else: self.mac = mac self.startup() def startup(self): self.connect() delay(500) self.pin = 0 self.pin_mode = 0 self.pwm_mode = 0 #self.hardwareReset() # このシーケンスを経ると一発目の入力が正しく機能する(?) self.writePinMode(0xFF) self.writePIO(0xFF) self.writePinMode(0x00) self.I2C_read_length = 1 # ------------------------------------------- # Digital I/O Functions # ------------------------------------------- def pinMode(self, pin, mode): """ PIOを入出力指定します。 pin: ピン番号。PIO0などのように指定します。 mode: INPUT/OUTPUT で指定します。 """ self.setPWMmode(pin, DISABLE) r = self.readPinMode() if mode == OUTPUT: r |= (1 << pin) & 0xFF else: r &= (~((1 << pin)) & 0xFF) self.writePinMode(r) def digitalWrite(self, pin, value): """ PIOにデジタル出力します。 pin: ピン番号。PIO0などのように指定します。 value: HIGH/LOW で指定します。 """ self.setPWMmode(pin, DISABLE) if value == HIGH: self.pin |= (1 << pin) & 0xFF else: self.pin &= (~((1 << pin)) & 0xFF) self.writePIO(self.pin) def digitalRead(self, pin): """ PIOからデジタル入力します。 pin: ピン番号。PIO0などのように指定します。 戻り値は HIGH/LOW です。 """ if (self.pwm_mode & (1 << pin)) != 0: self.setPWMmode(pin, DISABLE) dat = self.readPIO() mask = (1 << pin) & 0xFF if (dat & mask) == 0: return LOW else: return HIGH # ------------------------------------------- # Analog I/O Functions # ------------------------------------------- def analogRead(self, pin): """ AIOからデジタル入力します。 pin: ピン番号。AIO0などのように指定します。 戻り値は mV単位です """ return self.ANALOG_read(pin) def analogWrite(self, pin, value): """ DACは未対応のようなので、PWMのみです。 pin: PIO0,1,2のみ。 value: 0-255 value/255*VCC が出力されます。 """ self.setPWMmode(pin, ENABLE) self.writePWMperiod(pin, 255 * 20) self.writePWMduty(pin, value * 20) # ------------------------------------------- # Others # ------------------------------------------- # ------------------------------------------- # PWM Functions # ------------------------------------------- def setPWMmode(self, pin, mode): """ pin: PIO0,1,2を指定。 mode: ENABLE/DISABLE """ new_mode = self.pwm_mode if mode == ENABLE: new_mode |= (1 << pin) & 0xFF else: new_mode &= (~((1 << pin)) & 0xFF) if new_mode != self.pwm_mode: self.writePWMmode(new_mode) # ------------------------------------------- # konashi PIO functions # ------------------------------------------- def writePinMode(self, value): """ value bit0-5: PIO0-5 0: INPUT 1: OUTPUT """ return self.write_command("PIO_setting", [value]) def readPinMode(self): return self.read_command("PIO_setting") def writePIOpullup(self, value): """ value bit0-5: PIO0-5 0: DISABLE 1: ENABLE """ return self.write_command("PIO_pullup", [value]) def readPIOpullup(self): return self.read_command("PIO_pullup") def writePIO(self, value): """ value bit0-5: PIO0-5 0: LOW 1: HIGH """ return self.write_command("PIO_output", [value]) def readPIO(self): return self.read_command("PIO_notification") # ------------------------------------------- # konashi Analog IO functions # ------------------------------------------- #def ANALOG_drive(self,pin): def ANALOG_read(self, pin): handle_string = "" if pin == AIO0: handle_string = "ANALOG_read_0" elif pin == AIO1: handle_string = "ANALOG_read_1" elif pin == AIO2: handle_string = "ANALOG_read_2" dat = self.read_async_command(handle_string, length=2) adat = (dat[0] << 8) + dat[1] return adat # ------------------------------------------- # konashi UART functions # ------------------------------------------- def UART_config(self, mode): """ mode 0: UART DISABLE 1: UART ENABLE """ self.write_command("UART_config", [mode]) def UART_baud_rate(self, bit_rate): """ bit_rate: bps(2400/9600 is supported) """ dat = [0, 0] bit_rate /= 240 dat[0] = (bit_rate & 0xFF00) >> 8 dat[1] = (bit_rate & 0x00FF) self.write_command("UART_baud_rate", dat) def UART_tx(self, data): """ data: max 18bytes strings """ dat = (map(lambda n: ord(n), data)) self.write_command("UART_tx", dat) def UART_rx(self): """ read 1 byte strings """ return chr(self.read_command("UART_rx", dat)[0]) # ------------------------------------------- # konashi I2C functions # ------------------------------------------- def I2C_config(self, mode): """ mode 0: I2C DISABLE 1: I2C ENABLE(100kHz) 2: I2C ENABLE(400kHz) """ self.write_command("I2C_config", [mode]) def I2C_start_stop(self, mode): """ mode 0: STOP CONDITION 1: START CONDITION 2: REPEATED START CONDITION """ self.write_command("I2C_start_stop", [mode]) def I2C_write(self, slave_address, data): """ slave_address: I2C slave address(8bit) data: data array (max 16 bytes) """ dat = [0] * 2 dat[0] = len(data) + 2 dat[1] = (slave_address << 1) & 0xfe if isinstance(data, list): dat += data if isinstance(data, str): dat += map(lambda n: ord(n), data) self.write_command("I2C_write", dat) def I2C_read_parameter(self, slave_address, length): """ Send Read Request slave_address: I2C slave address(7bit) """ self.I2C_read_length = length dat = [0] * 2 dat[0] = self.I2C_read_length dat[1] = (slave_address << 1) | 0x01 self.write_command("I2C_read_parameter", dat) def I2C_read(self): return self.read_async_command("I2C_read", length=self.I2C_read_length) # ------------------------------------------- # konashi PWM functions # ------------------------------------------- def readPWMmode(self): return self.read_command("PWM_config") def writePWMmode(self, mode): self.mode = mode self.write_command("PWM_config", [self.mode]) def writePWMperiod(self, pin, period): """ period: 1000-20480[usec] """ param = [pin, 0, 0, 0, 0] param[1] = (period & 0xFF000000) >> 24 param[2] = (period & 0x00FF0000) >> 16 param[3] = (period & 0x0000FF00) >> 8 param[4] = (period & 0x000000FF) self.write_command("PWM_parameter", param) def writePWMduty(self, pin, duty): param = [pin, 0, 0, 0, 0] param[1] = (duty & 0xFF000000) >> 24 param[2] = (duty & 0x00FF0000) >> 16 param[3] = (duty & 0x0000FF00) >> 8 param[4] = (duty & 0x000000FF) self.write_command("PWM_duty", param) # ------------------------------------------- # konashi other functions # ------------------------------------------- def hardwareReset(self): self.write_command("hardware_reset", [0xff]) # ------------------------------------------- # Bluetooth functions (depend on pygattlib) # ------------------------------------------- def connect(self): self.req = GATTRequester(self.mac) def write_command(self, handle_id, parameter): """ parameter: 配列 """ handle = HANDLE[handle_id] self.req.write_by_handle(handle, str(bytearray(parameter))) def read_async_command(self, handle_id, length=1): """ 1バイトリードのときはintで、 2バイト以上リードするときは配列で返します。 """ response = GATTResponse() handle = HANDLE[handle_id] self.req.read_by_handle_async(handle, response) while not response.received(): time.sleep(0.1) ans = response.received()[0] ans = map(lambda n: ord(n), ans) if length == 1: return ans[0] else: return ans def read_command(self, handle_id, length=1): """ 同期リード。 1バイトリードのときはintで、 2バイト以上リードするときは配列で返します。 """ handle = HANDLE[handle_id] ans = self.req.read_by_handle(handle)[0] ans = map(lambda n: ord(n), ans) if length == 1: return ans[0] else: return ans # ------------------------------------------- # Main Routine # ------------------------------------------- def setup(self): pass def loop(self): pass def run(self): self.setup() while 1: self.loop()
from gattlib import GATTRequester from time import sleep sleep(2.0) req = GATTRequester("F0:18:98:A6:FC:73", False) req.connect(True, 'random') req.write_by_handle(0x16, b"\x57\x01\x00")
print "cilia found" req = GATTRequester(tag_address, False, "hci1") response = GATTResponse() req.connect() req.read_by_handle_async(0x3A, response) while not response.received(): time.sleep(0.1) steps = response.received()[0] #print "steps..." #print type(steps) #print steps #for b in steps: # print hex(ord(b)),' ' req.write_by_handle(0x3C, str(bytearray([0xff, 0xff]))) req.write_by_handle(0x3E, str(bytearray([0x64]))) data = req.read_by_handle(0x3C)[0] #for d in data: # print hex(ord(d)),' ' #print("") req.write_by_handle(0x3A, str(bytearray([0x0, 0x0]))) for i in range(1000): data = req.read_by_handle(0x39)[0] for d in data: print hex(ord(d)), print("") i = 0 axl = 0x00 axh = 0x00 for d in data:
class MoveHub: address = "" controller = "" req = GATTRequester def __init__(self, address, controller): self.address = address self.controller = controller self.req = GATTRequester(self.address, False, self.controller) self.connect() def connect(self): if self.req.is_connected(): print("Already connected") else: print("Connecting...") sys.stdout.flush() self.req.connect(True) def is_connected(self): return self.req.is_connected() def getaddress(self): return self.address def getname(self): self.connect() devicename = self.req.read_by_handle(0x07) return devicename[0] def set_led_color(self, color): if color in LED_COLORS: self.connect() self.req.write_by_handle(HANDLE, SET_LED_COLOR[LED_COLORS.index(color)]) def motor_timed(self, motor, time_ms, dutycycle_pct): if motor in MOTORS: if dutycycle_pct in range(-100, 101): command = MOTOR_TIMED_INI command += motor command += MOTOR_TIMED_MID t = time_ms.to_bytes(2, byteorder='little') command += t if dutycycle_pct < 0: dutycycle_pct += 255 command += bytes(bytes(chr(dutycycle_pct), 'latin-1')) command += MOTOR_TIMED_END self.req.write_by_handle(HANDLE, command) def motors_timed(self, motor, time_ms, dutycycle_pct_A, dutycycle_pct_B): if motor in MOTOR_PAIRS: if dutycycle_pct_A in range(-100, 101) and dutycycle_pct_B in range(-100, 101): command = MOTORS_TIMED_INI command += motor command += MOTORS_TIMED_MID t = time_ms.to_bytes(2, byteorder='little') command += t if dutycycle_pct_A < 0: dutycycle_pct_A += 255 command += bytes(bytes(chr(dutycycle_pct_A), 'latin-1')) if dutycycle_pct_B < 0: dutycycle_pct_B += 255 command += bytes(bytes(chr(dutycycle_pct_B), 'latin-1')) command += MOTORS_TIMED_END self.req.write_by_handle(HANDLE, command)
print "cilia found" req = GATTRequester(tag_address, False, "hci1") response = GATTResponse() req.connect() req.read_by_handle_async(0x3A, response) while not response.received(): time.sleep(0.1) steps = response.received()[0] #print "steps..." #print type(steps) #print steps #for b in steps: # print hex(ord(b)),' ' req.write_by_handle(0x3C, str(bytearray([0xff, 0xff]))) req.write_by_handle(0x3E, str(bytearray([0x64]))) data = req.read_by_handle(0x3C)[0] #for d in data: # print hex(ord(d)),' ' #print("") req.write_by_handle(0x3A, str(bytearray([0x0, 0x0]))) for i in range(1000): data = req.read_by_handle(0x39)[0] for d in data: print hex(ord(d)), print("") i = 0 axl = 0x00 axh = 0x00 for d in data:
import sys from gattlib import GATTRequester, GATTResponse from struct import * import paho.mqtt.client as mqtt from farmware_tools import device address = "c4:7c:8d:66:35:49" #sys.argv[1] requester = GATTRequester(address) #Read battery and firmware version attribute data = requester.read_by_handle(0x0038)[0] battery, version = unpack('<B6s', data) device.log("Battery level:", battery, "%") device.log("Firmware version:", version) #Enable real-time data reading requester.write_by_handle(0x0033, str(bytearray([0xa0, 0x1f]))) #Read plant data data = requester.read_by_handle(0x0035)[0] temperature, sunlight, moisture, fertility = unpack('<hxIBHxxxxxx', data) device.log("Light intensity:", sunlight, "lux") print "Temperature:", temperature / 10., "C" print "Soil moisture:", moisture, "%" print "Soil fertility:", fertility, "uS/cm" #Sometimes the version contains some funny charcters which throws off the JSON processing. Cleaning string temp = version version = " " for x in temp: if x == ".": version = version + "." if x >= "0" and x <= "9":
def read_data_job(): address = mac_address global g_sun global g_moi global g_tem global g_fer now = datetime.datetime.now() test_min = int(now.strftime("%M")) time = now.strftime("%Y-%m-%d %H:%M:%S") try: requester = GATTRequester(address) #Read battery and firmware version attribute data=requester.read_by_handle(0x0038)[0] battery, version = unpack('<B6s',data) #Enable real-time data reading requester.write_by_handle(0x0033, str(bytearray([0xa0, 0x1f]))) #Read plant data data=requester.read_by_handle(0x0035)[0] temperature, sunlight, moisture, fertility = unpack('<hxIBHxxxxxx',data) temperature=float(temperature/10) min = int(test_min/10) #g_sun[min] = sunlight #g_moi[min] = moisture #g_fer[min] = fertility #g_tem[min] = temperature #conn = mysql.connect() #cursor = conn.cursor() #sql = "INSERT INTO sensor_data_test (sunlight,moisture,temperature,fertility,time) VALUES ('%d','%d','%f','%d','%s')" % (sunlight,moisture,temperature,fertility,time) #cursor.execute(sql) #conn.commit() #cursor.close() #conn.close() print "get data at %s" % time except: print "can not get data at %s" % time finally: if int(test_min/10) == 5: sum_sun = 0 sum_tem = 0 sum_fer = 0 sum_moi = 0 check_sun = 0 check_tem = 0 check_fer = 0 check_moi = 0 for i in range(0,6): if g_sun[i] != -1: sum_sun += g_sun[i] check_sun += 1 if g_moi[i] != -1: sum_moi += g_moi[i] check_moi += 1 if g_tem[i] != -1.0: sum_tem += g_tem[i] check_tem += 1 if g_fer[i] != -1: sum_fer += g_fer[i] check_fer += 1 if check_sun != 0: sum_sun = int(sum_sun/check_sun) if check_moi != 0: sum_moi = int(sum_moi/check_moi) if check_tem != 0: sum_tem = float(sum_tem/check_tem) if check_fer != 0: sum_fer = int(sum_fer/check_fer) conn = mysql.connect() cursor = conn.cursor() print "STORE DATA AFTER 1 HOUR at %s" % time sql = "INSERT INTO sensor_data (sunlight,moisture,temperature,fertility,time) VALUES ('%d','%d','%f','%d','%s')" % (sum_sun,sum_moi,sum_tem,sum_fer,time) cursor.execute(sql) conn.commit() cursor.close() conn.close() for i in range(0,6): g_sun[i] = -1 g_moi[i] = -1 g_tem[i] = -1.0 g_fer[i] = -1
#!/usr/bin/env python3 from gattlib import GATTRequester BOOST_handle = 0x0e RGBLED_WHITE = b'\x08\x00\x81\x32\x11\x51\x00\x0A' req = GATTRequester("00:16:53:A4:CD:7E", True, "hci0") req.write_by_handle(BOOST_handle, RGBLED_WHITE)
class RoboRoach: ####################### # API Constants ####################### ROBOROACH_FREQUENCY_HANDLE = 0x002A ROBOROACH_PULSE_WIDTH_HANDLE = 0x002D ROBOROACH_NUM_PULSES_HANDLE = 0x0030 ROBOROACH_RANDOM_MODE = 0x0033 ROBOROACH_RIGHT_HANDLE = 0x0036 ROBOROACH_LEFT_HANDLE = 0x0039 ROBOROACH_GAIN_HANDLE = 0x003C ROBOROACH_MIN_FREQ_HANDLE = 0x003F ROBOROACH_MAX_FREQ_HANDLE = 0x0042 ROBOROACH_MIN_PW_HANDLE = 0x0045 ROBOROACH_MAX_PW_HANDLE = 0x0048 ROBOROACH_MIN_GAIN_HANDLE = 0x004B ROBOROACH_MAX_GAIN_HANDLE = 0x004E ####################### # CONSTRUCTOR ####################### def __init__(self, mac_address): self.mac_address = mac_address self.req = GATTRequester(mac_address) self._set_min_freq(0x0A) self._set_max_freq(0X46) self._set_min_pw(0x01) self._set_max_pw(0x14) self._set_min_gain(0x0A) self._set_max_gain(0x46) ####################### # AUXILIAR FUNCTIONS ####################### def read_async(self, handle): response = GATTResponse() self.req.read_by_handle_async(handle, response) while not response.received(): time.sleep(0.1) return response.received()[0] ####################### # COMMON FUNCTIONS ####################### def _turn(self, direction): if direction == 'right': self.req.write_by_handle(self.ROBOROACH_LEFT_HANDLE, str(bytearray([1]))) elif direction == 'left': self.req.write_by_handle(self.ROBOROACH_RIGHT_HANDLE, str(bytearray([1]))) else: print "Unknown direction" def _rand(self, random): if random == True: self.req.write_by_handle(self.ROBOROACH_RANDOM_MODE, str(bytearray([1]))) else: self.req.write_by_handle(self.ROBOROACH_RANDOM_MODE, str(bytearray([0]))) def _set_freq(self, frequency): self.req.write_by_handle(self.ROBOROACH_FREQUENCY_HANDLE, str(bytearray([frequency]))) def _get_freq(self): freq = self.read_async(self.ROBOROACH_FREQUENCY_HANDLE) return freq.encode('hex') def _set_pw(self, pulse_width): self.req.write_by_handle(self.ROBOROACH_PULSE_WIDTH_HANDLE, str(bytearray([pulse_width]))) def _get_pw(self): pulse_width = self.read_async(self.ROBOROACH_PULSE_WIDTH_HANDLE) return pulse_width.encode('hex') def _set_gain(self, gain): self.req.write_by_handle(self.ROBOROACH_GAIN_HANDLE, str(bytearray([gain]))) def _get_gain(self): gain = self.read_async(self.ROBOROACH_GAIN_HANDLE) return gain.encode('hex') def _set_min_freq(self, freq): self.req.write_by_handle(self.ROBOROACH_MIN_FREQ_HANDLE, str(bytearray([freq]))) def _set_max_freq(self, freq): self.req.write_by_handle(self.ROBOROACH_MAX_FREQ_HANDLE, str(bytearray([freq]))) def _get_min_freq(self): min_freq = self.read_async(self.ROBOROACH_MIN_FREQ_HANDLE) return min_freq.encode('hex') def _get_max_freq(self): max_freq = self.read_async(self.ROBOROACH_MAX_FREQ_HANDLE) return max_freq.encode('hex') def _set_min_pw(self, pulse_width): self.req.write_by_handle(self.ROBOROACH_MIN_PW_HANDLE, str(bytearray([pulse_width]))) def _set_max_pw(self, pulse_width): self.req.write_by_handle(self.ROBOROACH_MAX_PW_HANDLE, str(bytearray([pulse_width]))) def _get_min_pw(self): min_freq = self.read_async(self.ROBOROACH_MIN_PW_HANDLE) return min_freq.encode('hex') def _get_max_pw(self): max_freq = self.read_async(self.ROBOROACH_MAX_PW_HANDLE) return max_freq.encode('hex') def _set_min_gain(self, gain): self.req.write_by_handle(self.ROBOROACH_MIN_GAIN_HANDLE, str(bytearray([gain]))) def _set_max_gain(self, gain): self.req.write_by_handle(self.ROBOROACH_MAX_GAIN_HANDLE, str(bytearray([gain]))) def _get_min_gain(self): min_gain = self.read_async(self.ROBOROACH_MIN_GAIN_HANDLE) return min_gain.encode('hex') def _get_max_gain(self): max_gain = self.read_async(self.ROBOROACH_MAX_GAIN_HANDLE) return max_gain.encode('hex') # Need more testing: def _set_np(self, num_pulses): self.req.write_by_handle(self.ROBOROACH_NUM_PULSES_HANDLE, str(bytearray([num_pulses]))) def _get_np(self): response = GATTResponse() self.req.read_by_handle_async(self.ROBOROACH_NUM_PULSES_HANDLE, response) while not response.received(): time.sleep(0.1) num_pulses = response.received()[0] return num_pulses.encode('hex')