def update_poll(self):
"""
Call this method inside your main event loop to get the server
check for new incoming client requests. When a request comes in,
the application callable will be invoked.
"""
for sock in self._client_sock:
if sock.available():
environ = self._get_environ(sock)
result = self.application(environ, self._start_response)
self.finish_response(result, sock)
self._client_sock.remove(sock)
break
for sock in self._client_sock:
if sock.status == wiznet5k.adafruit_wiznet5k.SNSR_SOCK_CLOSED:
self._client_sock.remove(sock)
for _ in range(len(self._client_sock), MAX_SOCK_NUM):
try:
new_sock = socket.socket()
new_sock.settimeout(self._timeout)
new_sock.bind((None, self.port))
new_sock.listen()
self._client_sock.append(new_sock)
except RuntimeError:
pass
def __init__(self, eth, mac_address, timeout=1, timeout_response=1, debug=False):
self._debug = debug
self._timeout = timeout
self._response_timeout = timeout_response
self._mac_address = mac_address
# Initalize a new UDP socket for DHCP
socket.set_interface(eth)
self._sock = socket.socket(type=socket.SOCK_DGRAM)
self._sock.settimeout(timeout)
# DHCP state machine
self._dhcp_state = STATE_DHCP_START
self._initial_xid = 0
self._transaction_id = 0
# DHCP server configuration
self.dhcp_server_ip = 0
self.local_ip = 0
self.gateway_ip = 0
self.subnet_mask = 0
self.dns_server_ip = 0
# Lease configuration
self._lease_time = 0
self._last_check_lease_ms = 0
self._renew_in_sec = 0
self._rebind_in_sec = 0
self._t1 = 0
self._t2 = 0
def __init__(self, iface, dns_address, debug=False):
self._debug = debug
self._iface = iface
socket.set_interface(iface)
self._sock = socket.socket(type=socket.SOCK_DGRAM)
self._sock.settimeout(1)
self._dns_server = dns_address
self._host = 0
self._request_id = 0 # request identifier
self._pkt_buf = bytearray()
def __init__(self, iface, ntp_address, utc, debug=False):
self._debug = debug
self._iface = iface
socket.set_interface(self._iface)
self._sock = socket.socket(type=socket.SOCK_DGRAM)
self._sock.settimeout(1)
self._utc = utc
self._ntp_server = ntp_address
self._host = 0
self._request_id = 0 # request identifier
self._pkt_buf_ = bytearray([0x23] + [0x00] * 55)
def start(self):
"""
Starts the server and begins listening for incoming connections.
Call update_poll in the main loop for the application callable to be
invoked on receiving an incoming request.
"""
for _ in range(MAX_SOCK_NUM):
new_sock = socket.socket()
new_sock.settimeout(self._timeout)
new_sock.bind((None, self.port))
new_sock.listen()
self._client_sock.append(new_sock)
if self._debug:
ip = _the_interface.pretty_ip(_the_interface.ip_address)
print("Server available at {0}:{1}".format(ip, self.port))
def update_poll(self):
"""
Call this method inside your main event loop to get the server
check for new incoming client requests. When a request comes in,
the application callable will be invoked.
"""
add_sock = []
for sock in self._client_sock:
if sock.available():
environ = self._get_environ(sock)
result = self.application(environ, self._start_response)
self.finish_response(result, sock)
self._client_sock.remove(sock)
new_sock = socket.socket()
new_sock.settimeout(self._timeout)
new_sock.bind((None, self.port))
new_sock.listen()
add_sock.append(new_sock)
self._client_sock.extend(add_sock)
def __init__(self,
eth,
mac_address,
hostname=None,
response_timeout=3,
debug=False):
self._debug = debug
self._response_timeout = response_timeout
self._mac_address = mac_address
# Initalize a new UDP socket for DHCP
socket.set_interface(eth)
self._sock = socket.socket(type=socket.SOCK_DGRAM)
self._sock.settimeout(response_timeout)
# DHCP state machine
self._dhcp_state = STATE_DHCP_START
self._initial_xid = 0
self._transaction_id = 0
# DHCP server configuration
self.dhcp_server_ip = 0
self.local_ip = 0
self.gateway_ip = 0
self.subnet_mask = 0
self.dns_server_ip = 0
# Lease configuration
self._lease_time = 0
self._last_check_lease_ms = 0
self._renew_in_sec = 0
self._rebind_in_sec = 0
self._t1 = 0
self._t2 = 0
# Host name
mac_string = "".join("{:02X}".format(o) for o in mac_address)
self._hostname = bytes(
(hostname
or "WIZnet{}").split(".")[0].format(mac_string)[:42], "utf-8")
ethernetRst = digitalio.DigitalInOut(W5x00_RSTn)
ethernetRst.direction = digitalio.Direction.OUTPUT
ethernetRst.value = False
time.sleep(1)
ethernetRst.value = True
# edit host and port to match server
HOST = "192.168.10.10"
PORT = 5000
TIMEOUT = 5
INTERVAL = 5
MAXBUF = 256
while True:
print("Create TCP Client Socket")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(TIMEOUT)
print("Connecting")
s.connect((HOST, PORT))
size = s.send(b'Hello, world')
print("Sent", size, "bytes")
buf = s.recv(MAXBUF)
print('Received', buf)
s.close()
time.sleep(INTERVAL)
def _dhcp_state_machine(self):
"""DHCP state machine without wait loops to enable cooperative multi tasking
This state machine is used both by the initial blocking lease request and
the non-blocking DHCP maintenance function"""
if self._eth.link_status:
if self._dhcp_state == STATE_DHCP_DISCONN:
self._dhcp_state = STATE_DHCP_START
else:
if self._dhcp_state != STATE_DHCP_DISCONN:
self._dhcp_state = STATE_DHCP_DISCONN
self.dhcp_server_ip = BROADCAST_SERVER_ADDR
self._last_lease_time = 0
reset_ip = (0, 0, 0, 0)
self._eth.ifconfig = (reset_ip, reset_ip, reset_ip, reset_ip)
if self._sock is not None:
self._sock.close()
self._sock = None
if self._dhcp_state == STATE_DHCP_START:
self._start_time = time.monotonic()
self._transaction_id = (self._transaction_id + 1) & 0x7FFFFFFF
try:
self._sock = socket.socket(type=socket.SOCK_DGRAM)
except RuntimeError:
if self._debug:
print("* DHCP: Failed to allocate socket")
self._dhcp_state = STATE_DHCP_WAIT
else:
self._sock.settimeout(self._response_timeout)
self._sock.bind((None, 68))
self._sock.connect((self.dhcp_server_ip, DHCP_SERVER_PORT))
if self._last_lease_time == 0 or time.monotonic() > (
self._last_lease_time + self._lease_time):
if self._debug:
print("* DHCP: Send discover to {}".format(
self.dhcp_server_ip))
self.send_dhcp_message(
STATE_DHCP_DISCOVER,
(time.monotonic() - self._start_time))
self._dhcp_state = STATE_DHCP_DISCOVER
else:
if self._debug:
print("* DHCP: Send request to {}".format(
self.dhcp_server_ip))
self.send_dhcp_message(
DHCP_REQUEST, (time.monotonic() - self._start_time),
True)
self._dhcp_state = STATE_DHCP_REQUEST
elif self._dhcp_state == STATE_DHCP_DISCOVER:
if self._sock.available():
if self._debug:
print("* DHCP: Parsing OFFER")
msg_type, xid = self.parse_dhcp_response()
if msg_type == DHCP_OFFER:
# Check if transaction ID matches, otherwise it may be an offer
# for another device
if htonl(self._transaction_id) == int.from_bytes(xid, "l"):
if self._debug:
print("* DHCP: Send request to {}".format(
self.dhcp_server_ip))
self._transaction_id = (self._transaction_id +
1) & 0x7FFFFFFF
self.send_dhcp_message(
DHCP_REQUEST,
(time.monotonic() - self._start_time))
self._dhcp_state = STATE_DHCP_REQUEST
else:
if self._debug:
print(
"* DHCP: Received OFFER with non-matching xid")
else:
if self._debug:
print("* DHCP: Received DHCP Message is not OFFER")
elif self._dhcp_state == STATE_DHCP_REQUEST:
if self._sock.available():
if self._debug:
print("* DHCP: Parsing ACK")
msg_type, xid = self.parse_dhcp_response()
# Check if transaction ID matches, otherwise it may be
# for another device
if htonl(self._transaction_id) == int.from_bytes(xid, "l"):
if msg_type == DHCP_ACK:
if self._debug:
print("* DHCP: Successful lease")
self._sock.close()
self._sock = None
self._dhcp_state = STATE_DHCP_LEASED
self._last_lease_time = self._start_time
if self._lease_time == 0:
self._lease_time = DEFAULT_LEASE_TIME
if self._t1 == 0:
# T1 is 50% of _lease_time
self._t1 = self._lease_time >> 1
if self._t2 == 0:
# T2 is 87.5% of _lease_time
self._t2 = self._lease_time - (
self._lease_time >> 3)
self._renew_in_sec = self._t1
self._rebind_in_sec = self._t2
self._eth.ifconfig = (
self.local_ip,
self.subnet_mask,
self.gateway_ip,
self.dns_server_ip,
)
gc.collect()
else:
if self._debug:
print("* DHCP: Received DHCP Message is not ACK")
else:
if self._debug:
print("* DHCP: Received non-matching xid")
elif self._dhcp_state == STATE_DHCP_WAIT:
if time.monotonic() > (self._start_time + DHCP_WAIT_TIME):
if self._debug:
print("* DHCP: Begin retry")
self._dhcp_state = STATE_DHCP_START
if time.monotonic() > (self._last_lease_time +
self._rebind_in_sec):
self.dhcp_server_ip = BROADCAST_SERVER_ADDR
if time.monotonic() > (self._last_lease_time +
self._lease_time):
reset_ip = (0, 0, 0, 0)
self._eth.ifconfig = (reset_ip, reset_ip, reset_ip,
reset_ip)
elif self._dhcp_state == STATE_DHCP_LEASED:
if time.monotonic() > (self._last_lease_time + self._renew_in_sec):
self._dhcp_state = STATE_DHCP_START
if self._debug:
print("* DHCP: Time to renew lease")
if (self._dhcp_state in (
STATE_DHCP_DISCOVER,
STATE_DHCP_REQUEST,
) and time.monotonic() > (self._start_time + self._response_timeout)):
self._dhcp_state = STATE_DHCP_WAIT
if self._sock is not None:
self._sock.close()
self._sock = None
eth = WIZNET5K(spi_bus, cs, is_dhcp=True, debug=False)
ethernetRst = digitalio.DigitalInOut(W5x00_RSTn)
ethernetRst.direction = digitalio.Direction.OUTPUT
ethernetRst.value = False
time.sleep(1)
ethernetRst.value = True
# edit host and port to match server
HOST = "192.168.10.10"
PORT = 5000
TIMEOUT = 5
INTERVAL = 5
MAXBUF = 256
buf = bytearray(MAXBUF)
while True:
print("Create UDP Client Socket")
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(TIMEOUT)
size = s.sendto(b"Hello, world", (HOST, PORT))
print("Sent", size, "bytes")
size, addr = s.recvfrom_into(buf)
print("Received", buf[:size], size, "bytes from", addr)
s.close()
time.sleep(INTERVAL)
import digitalio
from adafruit_wiznet5k.adafruit_wiznet5k import WIZNET5K
import adafruit_wiznet5k.adafruit_wiznet5k_socket as socket
print("Wiznet5k SimpleServer Test")
# For Adafruit Ethernet FeatherWing
cs = digitalio.DigitalInOut(board.D10)
# For Particle Ethernet FeatherWing
# cs = digitalio.DigitalInOut(board.D5)
spi_bus = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
# Initialize ethernet interface
eth = WIZNET5K(spi_bus, cs, is_dhcp=False)
# Initialize a socket for our server
socket.set_interface(eth)
server = socket.socket() # Allocate socket for the server
server_ip = "192.168.10.1" # IP address of server
server_port = 50007 # Port to listen on
server.bind((server_ip, server_port)) # Bind to IP and Port
server.listen() # Begin listening for incoming clients
conn, addr = server.accept() # Wait for a connection from a client.
while True:
with conn:
data = conn.recv(1024)
if data: # Wait for receiving data
print(data)
conn.send(data) # Echo message back to client
