def test_hivemind_dht():
peers = [DHT(start=True)]
for i in range(10):
neighbors_i = [
f'{LOCALHOST}:{node.port}'
for node in random.sample(peers, min(3, len(peers)))
]
peers.append(DHT(initial_peers=neighbors_i, start=True))
you: DHT = random.choice(peers)
theguyshetoldyounottoworryabout: DHT = random.choice(peers)
expert_uids = [str(uuid.uuid4()) for _ in range(110)]
batch_size = 10
for batch_start in range(0, len(expert_uids), batch_size):
you.declare_experts(expert_uids[batch_start:batch_start + batch_size],
'localhost', 1234)
found = theguyshetoldyounottoworryabout.get_experts(
random.sample(expert_uids, 5) + ['foo', 'bar'])
assert all(res is not None
for res in found[:-2]), "Could not find some existing experts"
assert all(res is None for res in found[-2:]), "Found non-existing experts"
that_guys_expert, that_guys_port = str(uuid.uuid4()), random.randint(
1000, 9999)
theguyshetoldyounottoworryabout.declare_experts(
[that_guys_expert], f'that_host:{that_guys_port}')
you_notfound, you_found = you.get_experts(['foobar', that_guys_expert])
assert isinstance(you_found, dht.RemoteExpert)
assert you_found.endpoint == f'that_host:{that_guys_port}'
# test first_k_active
assert theguyshetoldyounottoworryabout.first_k_active(
expert_uids, k=10) == expert_uids[:10]
some_permuted_experts = random.sample(expert_uids, k=32)
assert theguyshetoldyounottoworryabout.first_k_active(
some_permuted_experts, k=32) == some_permuted_experts
assert theguyshetoldyounottoworryabout.first_k_active(
some_permuted_experts, k=1) == some_permuted_experts[:1]
fake_and_real_experts = list(
chain(*zip([str(uuid.uuid4())
for _ in some_permuted_experts], some_permuted_experts)))
assert theguyshetoldyounottoworryabout.first_k_active(
fake_and_real_experts, k=9) == some_permuted_experts[:9]
for peer in peers:
peer.shutdown()
def test_dht_single_node():
node = DHT(start=True)
assert all(node.declare_experts(['e1', 'e2', 'e3'], f"{LOCALHOST}:{1337}"))
for expert in node.get_experts(['e3', 'e2']):
assert expert.endpoint == f"{LOCALHOST}:{1337}"
assert node.first_k_active(['e0', 'e1', 'e3', 'e5', 'e2'],
k=2) == ['e1', 'e3']
def create():
node = Node(random_32bytes(), port=next(ports))
seed = random.choice(kads).node
dht = DHT(node, seed, context=context)
kads.append(dht)
processes.append(dht.run())
return json.dumps({'n': len(processes) - 1})
def main(n_processes, fill, test, needs_server):
for _ in xrange(n_processes):
try:
seed = random.choice(kads).node
except IndexError:
seed = None
node = Node(random_32bytes(), port=next(ports))
dht = DHT(node, seed, context=context)
kads.append(dht)
processes.append(dht.run())
print "%s started." % node
if fill:
with open('./lipsum.txt') as f:
result = re.findall(
"[A-Z]{2,}(?![a-z])|[A-Z][a-z]+(?=[A-Z])|[\'\w\-]+", f.read())
for idx in xrange(1, len(result)):
first, second = result[idx - 1], result[idx]
random.choice(kads)[first] = second
if test:
n_failures = 0
for idx in xrange(1, len(result)):
first, second = result[idx - 1], result[idx]
try:
print "%s -> %s" % (first, random.choice(kads)[first])
except KeyError:
n_failures += 1
print "Failed %s times" % n_failures
if needs_server:
app.run()
def __init__(self, ob_ctx, db):
self.ob_ctx = ob_ctx
self.log = logging.getLogger(
'[%s] %s' % (ob_ctx.market_id, self.__class__.__name__))
requests_log = logging.getLogger("requests")
requests_log.setLevel(logging.WARNING)
self.db = db
self.bitmessage_api = None
if (ob_ctx.bm_user, ob_ctx.bm_pass, ob_ctx.bm_port) != (None, None,
-1):
if not self._connect_to_bitmessage():
self.log.info('Bitmessage not installed or started')
self.market_id = ob_ctx.market_id
self.nick_mapping = {}
self.uri = network_util.get_peer_url(ob_ctx.server_ip,
ob_ctx.server_port)
self.ip = ob_ctx.server_ip
self.nickname = ""
self.dev_mode = ob_ctx.dev_mode
self.all_messages = ('hello', 'findNode', 'findNodeResponse', 'store')
self._setup_settings()
ob_ctx.market_id = self.market_id
self.dht = DHT(self, self.market_id, self.settings, self.db)
TransportLayer.__init__(self, ob_ctx, self.guid, self.nickname)
self.start_listener()
if ob_ctx.enable_ip_checker and not ob_ctx.seed_mode and not ob_ctx.dev_mode:
self.start_ip_address_checker()
def __init__(self, my_ip, my_port, market_id):
self._log = logging.getLogger('[%s] %s' %
(market_id, self.__class__.__name__))
# Connect to database
MONGODB_URI = 'mongodb://localhost:27017'
_dbclient = MongoClient()
self._db = _dbclient.openbazaar
self._market_id = market_id
self.nick_mapping = {}
self._uri = "tcp://%s:%s" % (my_ip, my_port)
# Set up
self._setup_settings()
self._dht = DHT(market_id, self.settings)
self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'),
privkey=self.secret.decode('hex'),
curve='secp256k1')
TransportLayer.__init__(self, market_id, my_ip, my_port, self.guid)
# Set up callbacks
self.add_callback('ping', self._dht._on_ping)
self.add_callback('findNode', self._dht._on_findNode)
self.add_callback('findNodeResponse', self._dht._on_findNodeResponse)
def init_sensors():
adc = machine.ADC() # create an ADC object
adc.vref(1157) # Set calibration
moist_sense1 = adc.channel(pin='P16', attn = machine.ADC.ATTN_11DB) # create an analog pin on P16
moist_sense2 = adc.channel(pin='P18', attn = machine.ADC.ATTN_11DB) # create an analog pin on P18
temp_humid_sens = DHT(machine.Pin('P23', mode=machine.Pin.OPEN_DRAIN), 0)
time.sleep(2)
return moist_sense1, moist_sense2, temp_humid_sens
def __init__(self,
my_ip,
my_port,
market_id,
db,
bm_user=None,
bm_pass=None,
bm_port=None,
seed_mode=0,
dev_mode=False,
disable_ip_update=False):
self.log = logging.getLogger('[%s] %s' %
(market_id, self.__class__.__name__))
requests_log = logging.getLogger("requests")
requests_log.setLevel(logging.WARNING)
# Connect to database
self.db = db
self.bitmessage_api = None
if (bm_user, bm_pass, bm_port) != (None, None, None):
if not self._connect_to_bitmessage(bm_user, bm_pass, bm_port):
self.log.info('Bitmessage not installed or started')
try:
socket.inet_pton(socket.AF_INET6, my_ip)
my_uri = "tcp://[%s]:%s" % (my_ip, my_port)
except (socket.error, ValueError):
my_uri = "tcp://%s:%s" % (my_ip, my_port)
self.market_id = market_id
self.nick_mapping = {}
self.uri = my_uri
self.ip = my_ip
self.nickname = ""
self._dev_mode = dev_mode
# Set up
self._setup_settings()
self.dht = DHT(self, self.market_id, self.settings, self.db)
# self._myself = ec.ECC(pubkey=self.pubkey.decode('hex'),
# privkey=self.secret.decode('hex'),
# curve='secp256k1')
TransportLayer.__init__(self, market_id, my_ip, my_port, self.guid,
self.nickname)
self.setup_callbacks()
self.listen(self.pubkey)
if seed_mode == 0 and not dev_mode and not disable_ip_update:
self.start_ip_address_checker()
def Main():
parser = argparse.ArgumentParser()
parser.add_argument("ip", help="Your IP address")
parser.add_argument("port", help="Port to run dht on")
parser.add_argument("region", help="Your region")
args = parser.parse_args()
dht = DHT(args.ip, int(args.port), args.region)
while True:
time.sleep(0.1)
pass
def humid_temp_sensor(read):
th = DHT('P23', 0)
time.sleep(2)
while read:
result = th.read()
while not result.is_valid():
time.sleep(.5)
result = th.read()
temperature = result.temperature
humidity = result.humidity
read = False
return (temperature, humidity)
def __init__(self, root, bootstrap_node, local_ip='localhost',
local_port=8000):
self.realroot = realpath(root)
self.rwlock = Lock()
self.dht = DHT(bootstrap_node, local_ip, local_port)
time.sleep(3)
# walk dir and update dht
files = utils.rgetdir(self.realroot)
for path, newval in files.iteritems():
newold = self.dht[path]
if newold:
utils.rdict_update(newold, newval)
self.dht[path] = newold
else:
self.dht[path] = newval
print "done mounting"
def __init__(self, lcd_rs_pin, lcd_e_pin, lcd_db_pins, button_pin,
dht_pin):
# LCD
self.lcd_rs_pin = lcd_rs_pin
self.lcd_e_pin = lcd_e_pin
self.lcd_db_pins = lcd_db_pins
# Button
self.button_pin = button_pin
# DHT
self.dht_type = Adafruit_DHT.DHT22
self.dht_pin = dht_pin
self.dht = DHT(self.dht_pin, self.dht_type)
self.lcd = HD44780(self.lcd_e_pin, self.lcd_rs_pin, self.lcd_db_pins)
self.cur_transport = 0
self.transports = TRANSPORTS_TO_SHOW[self.cur_transport]
DHT_NUM = 8
RECEPTI_NUM = 5
state = random.getstate()
random.seed(dht.config.TESTING_CATEGORY_SEED)
recepti = [{
'title': 'naziv' + str(i),
'type': dht.config.category_names[random.randint(0, len(dht.config.category_names) - 1)],
'description': 'Opis ' + str(i),
'ingredients': ['Sastojak_1_' + str(i), 'Sastojak_2_' + str(i), 'Sastojak_3_' + str(i)],
'picture': None
} for i in range(RECEPTI_NUM)]
random.setstate(state)
dht = [DHT("localhost", 3001 + i, dht.config.regions[i % len(dht.config.regions)]) for i in range(DHT_NUM)]
# Sacekaj dok se svi konektuju
all_connected = False
while not all_connected:
all_connected = True
for d in dht:
if not d.connected:
all_connected = False
break
print "KONEKCIJE"
for d in dht:
print d.peer.address()
peer_sum = 0
for b_index, bucket in enumerate(d.buckets.buckets):
import pycom
import time
from machine import Pin
from dht import DHT
pycom.heartbeat(False)
pycom.rgbled(0x000008) # blue
th = DHT(Pin('P3', mode=Pin.OPEN_DRAIN), 1)
time.sleep(2)
result = th.read()
if result.is_valid():
pycom.rgbled(0x001000) # green
print('Temperature: {:3.2f}'.format(result.temperature / 1.0))
print('Humidity: {:3.2f}'.format(result.humidity / 1.0))
def __init__(self, port):
self.dht = DHT(port)
self.myPort = port
self.fila = queue.Queue()
self.t = threading.Thread(target=self.enviando)
self.t.start()
import signal
import time
import datetime
logging.basicConfig()
logger = logging.getLogger(__name__)
logger.setLevel(logging.WARNING)
from sds import SDS
from gps import GPS
from dht import DHT
quit_event = threading.Event()
sds = SDS(quit_event=quit_event)
gps = GPS(quit_event=quit_event)
dht = DHT(quit_event=quit_event)
def signal_handler(sig, frame):
logger.warning("Ctrl-C pressed, quitting")
quit_event.set()
sys.exit(0)
def mount_disk():
if not os.path.ismount(DISK):
os.system("mount %s" % dist)
if __name__ == "__main__":
#Start all acquisition threads
import pycom
import time
from machine import Pin
from dht import DHT
powerPin = Pin('G28', mode=Pin.OUT)
powerPin(0)
pycom.heartbeat(False)
pycom.rgbled(0x000008) # blue
powerPin(1)
time.sleep(2)
th0 = DHT('G24', 1)
th1 = DHT('G11', 1)
result0 = th0.read()
result1 = th1.read()
# powerPin(0)
if result0.is_valid():
pycom.rgbled(0x001000) # green
print('Temperature0: {:3.1f}'.format(result0.temperature / 1.0))
print('Humidity0: {:3.1f}'.format(result0.humidity / 1.0))
if result1.is_valid():
pycom.rgbled(0x001000) # green
print('Temperature1: {:3.1f}'.format(result1.temperature / 1.0))
print('Humidity1: {:3.1f}'.format(result1.humidity / 1.0))
'naziv' + str(i),
'type':
dht.config.category_names[random.randint(
0,
len(dht.config.category_names) - 1)],
'description':
'Opis ' + str(i),
'ingredients':
['Sastojak_1_' + str(i), 'Sastojak_2_' + str(i), 'Sastojak_3_' + str(i)],
'picture':
None
} for i in range(RECEPTI_NUM)]
random.setstate(state)
dht = [
DHT("localhost", 3001 + i, dht.config.regions[i % len(dht.config.regions)])
for i in range(DHT_NUM)
]
# Sacekaj dok se svi konektuju
all_connected = False
while not all_connected:
all_connected = True
for d in dht:
if not d.connected:
all_connected = False
break
print "KONEKCIJE"
for d in dht:
print d.peer.address()
vPanel = adc.channel(pin='P13', attn = ADC.ATTN_11DB)
vBatt = adc.channel(pin='P14', attn = ADC.ATTN_11DB)
vPyra = adc.channel(pin='P15', attn = ADC.ATTN_11DB)
vTherm = adc.channel(pin='P17', attn = ADC.ATTN_11DB)
vBias = adc.channel(pin='P18', attn = ADC.ATTN_11DB)
powerPin = Pin('P8', mode=Pin.OUT)
powerPin(1)
ow = OneWire(Pin('P4'))
temp = DS18X20(ow) # DS18X20 must be powered on on instantiation (rom scan)
powerPin(0)
th = DHT('P3',1)
def medir(n=1):
powerPin(1)
time.sleep_ms(1000)
for i in range(n):
result = th.read()
temp.start_convertion()
time.sleep_ms(750)
print('Temperature DS18B20: {:3.4f}'.format(temp.read_temp_async()))
print('Temperature DHT22: {:3.1f}'.format(result.temperature/1.0))
print('Humidity DHT22: {:3.1f}'.format(result.humidity/1.0))
print('vPanel: {:3.4f}'.format(vPanel.voltage()))
print('vBatt: {:3.4f}'.format(vBatt.voltage()))
print('vPyra: {:3.4f}'.format(vPyra.voltage()))
print('vTherm: {:3.4f}'.format(vTherm.voltage()))
import time
from machine import Pin
from dht import DHT
th = DHT(Pin('P23', mode=Pin.OPEN_DRAIN), 0)
time.sleep(2)
def read_data():
result = th.read()
while not result.is_valid():
time.sleep(.5)
result = th.read()
return(result.temperature - 5,result.humidity - 45)
'naziv' + str(i),
'type':
dht.config.category_names[random.randint(
0,
len(dht.config.category_names) - 1)],
'description':
'Opis ' + str(i),
'ingredients':
['Sastojak_1_' + str(i), 'Sastojak_2_' + str(i), 'Sastojak_3_' + str(i)],
'picture':
None
} for i in range(RECEPTI_NUM)]
random.setstate(state)
dht = [
DHT(dht.config.BOOTSTRAP_HOST, 3001 + i,
dht.config.regions[i % len(dht.config.regions)])
for i in range(DHT_NUM)
]
# Sacekaj dok se svi konektuju
all_connected = False
while not all_connected:
all_connected = True
for d in dht:
if not d.connected:
all_connected = False
break
print "KONEKCIJE"
for d in dht:
print d.peer.address()
class MasterServer(object):
HOST = '127.0.0.1'
PORT = 5001
DHT = DHT(50)
def __init__(self):
print "servidor rodando..."
self.waitForConnection()
def waitForConnection(self):
socketTCP = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
orig = (self.HOST, self.PORT)
socketTCP.bind(orig)
socketTCP.listen(1)
while True:
con, client = socketTCP.accept()
threading.Thread(target=self.clientConnected,
args=(con, client)).start()
socketTCP.close()
def clientConnected(self, socketTCPThread, client):
while True:
try:
#socketTCPThread.settimeout(60)
data = socketTCPThread.recv(2048)
request = json.loads(data)
self.getRequestStatus(request, socketTCPThread, client)
except socket.error as msg:
print 'Error code: ' + str(msg[0]) + ', Error message: ' + str(
msg[1])
socketTCPThread.close()
self.DHT.logOutUser(client)
return False
except:
print 'ocorreu algum erro desconhecido, matando thread'
socketTCPThread.close()
self.DHT.logOutUser(client)
return False
def getRequestStatus(self, request, socketTCP, client):
try:
type = request['type']
if type == Define.REGISTER:
self.registerUser(request, socketTCP, client)
elif type == Define.LOGIN:
self.logUser(request, socketTCP, client)
elif type == 'keepalive':
self.userStillActive(request, socketTCP, client)
elif type == Define.UPLOAD:
self.uploadFile(request, socketTCP, client)
elif type == Define.DOWNLOAD:
self.downloadFile(request, socketTCP, client)
elif type == Define.DIRINFO:
self.sendDirectoriesTree(socketTCP)
elif type == Define.INFOFILES:
self.infoFiles(request, socketTCP, client)
elif type == Define.CREATEDIR:
self.createDir(request, socketTCP, client)
elif type == Define.RENAMEDIR:
self.renameDir(request, socketTCP, client)
elif type == Define.REMOVEDIR:
self.removeDir(request, socketTCP, client)
elif type == Define.REMOVEFILE:
self.removeFile(request, socketTCP, client)
elif type == Define.RENAMEFILE:
self.renameFile(request, socketTCP, client)
else:
response = dict(responseStatus=Define.ERROR,
errormsg='undefined_type')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
except:
response = dict(responseStatus=Define.ERROR,
errormsg='unknown_error')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def registerUser(self, request, socketTCP, client):
username = request['username']
id = self.DHT.registerUser(username, client)
if id >= 0:
response = dict(responseStatus=Define.SUCCESS, id=id)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
self.DHT.rebalancing()
elif id == -1:
response = dict(responseStatus=Define.ERROR,
errormsg='dht_overflow')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
elif id == -2:
response = dict(responseStatus=Define.ERROR,
errormsg='user_already_registered')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def logUser(self, request, socketTCP, client):
username = request['username']
id = self.DHT.logUser(username, client)
if id >= 0:
response = dict(responseStatus=Define.SUCCESS, id=id)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
self.DHT.sendFilesToUser(id)
elif id == -1:
response = dict(responseStatus=Define.USERNOTREGISTER,
errormsg='user_not_found')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def userStillActive(self, request, socketTCP, client):
pass
# if self.DHT.getIDForIPPort(client):
# response = dict(responseStatus = Define.SUCCESS)
# responseJSON = json.dumps(response)
# socketTCP.send(responseJSON)
# else:
# response = dict(responseStatus = Define.USERUNAUTHENTICATED, message = 'you_are_not_logged')
# responseJSON = json.dumps(response)
# socketTCP.send(responseJSON)
def uploadFile(self, request, socketTCP, client):
path = str(request['path'])
data = str(request['data'])
if self.DHT.saveFileAtPath(path, data, client): #salvou
response = dict(responseStatus=Define.SUCCESS)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
self.DHT.rebalancing()
else:
response = dict(responseStatus=Define.ERROR,
errormsg='error_processing_file')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def downloadFile(self, request, socketTCP, client):
method = request['method']
if method == 'hash':
self.sendFileToUser(request, socketTCP, client)
else:
self.sendHostThatWillUpdloadFileToUser(request, socketTCP, client)
def sendFileToUser(self, request, socketTCP, client):
hash = request['hash']
file = self.DHT.getBase64StringForFileWithHash(hash)
response = dict(responseStatus=Define.SUCCESS, type='file', data=file)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def sendHostThatWillUpdloadFileToUser(self, request, socketTCP, client):
path = request['path']
hash = self.DHT.getHashForPath(path)
id = self.DHT.getUserResponsableForFile(hash)
if self.DHT.checkIfUserActive(id):
(ip, port) = self.DHT.getIPPortForID(id)
response = dict(responseStatus=Define.SUCCESS,
type='node',
node=(ip, 6000 + id),
hashName=hash)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
else:
request.update(hash=hash)
self.sendFileToUser(request, socketTCP, client)
def infoFiles(self, request, socketTCP, client):
response = dict(responseStatus=Define.SUCCESS,
numberOfFiles=self.DHT.getNumberOfFiles(),
capacityOfSystem=self.DHT.getCapacityOfSystem(),
filesDistribution=self.DHT.getFilesDistribution(),
activeNodes=self.DHT.getActiveNodes())
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def createDir(self, request, socketTCP, client):
path = request['path']
if self.DHT.createDir(path, client):
response = dict(responseStatus=Define.SUCCESS)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
else:
response = dict(responseStatus=Define.ERROR,
errormsg='error_processing_file')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def renameDir(self, request, socketTCP, client):
path = request['path']
dir = request['newname']
if self.DHT.renameDir(path, dir, client):
response = dict(responseStatus=Define.SUCCESS)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
self.DHT.rebalancing()
else:
response = dict(responseStatus=Define.ERROR,
errormsg='error_processing_file')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def removeDir(self, request, socketTCP, client):
path = request['path']
if self.DHT.removeDir(path, client):
response = dict(responseStatus=Define.SUCCESS)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
else:
response = dict(responseStatus=Define.ERROR,
errormsg='error_processing_file')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def removeFile(self, request, socketTCP, client):
path = request['path']
if self.DHT.removeFile(path, client):
response = dict(responseStatus=Define.SUCCESS)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
else:
response = dict(responseStatus=Define.ERROR,
errormsg='error_processing_file')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
def renameFile(self, request, socketTCP, client):
path = request['path']
newName = request['newname']
if self.DHT.renameFile(path, newName, client):
response = dict(responseStatus=Define.SUCCESS)
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
self.DHT.rebalancing()
else:
response = dict(responseStatus=Define.ERROR,
errormsg='error_processing_file')
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
@staticmethod
def sendFilesForUser(userID, ip, files):
time.sleep(2)
socketTCP = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
dest = (ip, 6000 + userID)
socketTCP.connect(dest)
request = dict(type=Define.DHTFILES, files=files)
requestJSON = json.dumps(request)
socketTCP.send(requestJSON)
def sendDirectoriesTree(self, socketTCP):
dictTree = self.DHT.getDirectioriesTree()
response = dict(responseStatus=Define.SUCCESS, tree=[dictTree])
responseJSON = json.dumps(response)
socketTCP.send(responseJSON)
from network import WLAN
import urequests as requests
import machine
import time
from dht import DHT
from machine import Pin
TOKEN = "Token here" #Put here your TOKEN
DELAY = 60 # Delay in seconds
th = DHT(Pin('P23', mode=Pin.OPEN_DRAIN),
0) # DHT sensor is connected to port 23
time.sleep(2) # wait 2 seconds
wlan = WLAN(mode=WLAN.STA)
wlan.antenna(WLAN.INT_ANT)
# Assign your Wi-Fi credentials
wlan.connect("wifi-name", auth=(WLAN.WPA2, "wifi-password"), timeout=5000)
while not wlan.isconnected():
machine.idle()
print("Connected to Wifi\n")
# Builds the json to send the request
def build_json(variable1, value1, variable2, value2):
try:
data = {variable1: {"value": value1}, variable2: {"value": value2}}
return data
except:
# Assign your Wi-Fi credentials
wlan.connect(config.WIFI_SSID,
auth=(WLAN.WPA2, config.WIFI_PASS),
timeout=5000)
while not wlan.isconnected():
print("Beeb boop!\n")
machine.idle()
print("Connected to Wifi! :D\n")
print("Connecting sensors...\n")
distance_sensor = UDM(echo_pin='P21', trigger_pin='P20')
temp_sensor = DHT(pin='P10')
light_sensor = LGT(pin='P15')
time.sleep(2)
print("Let's a go!")
# -------------------------------------- Funky functions
# make a json package of the data
def build_json(variable1, value1, variable2, value2, variable3, value3,
variable4, value4):
try:
data = {
variable1: {
"value": value1
