diagram.json

import network
import machine
import utime as time
import microcoapy
import json
# Paramètres COAP
_SERVER_PORT = 5683  # default CoAP port
# Paramètres de connexion au réseau WiFi
WIFI_SSID = "coapnetwork"
WIFI_PASSWORD = "younes12345"

# Remplacez par votre adresse IP statique pour le Server COAP
static_ip = ("192.168.137.228", "255.255.255.0", "192.168.137.1", "192.168.137.1")  
# Fonction de connexion au réseau WiFi
def connect_wifi(WIFI_SSID, WIFI_PASSWORD, static_ip=None, timeout=30):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    
    if not wlan.isconnected():
        print("Connexion au réseau WiFi...")
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        start_time = time.time()
        while not wlan.isconnected() and time.time() - start_time < timeout:
            pass
        if wlan.isconnected():
            print("Connecté au réseau WiFi :", wlan.ifconfig())
            if static_ip:
                wlan.ifconfig(static_ip)
                print("Adresse IP statique définie :", static_ip)
        else:
            print("Échec de la connexion au réseau WiFi.")
    else:
        print("Déjà connecté au réseau WiFi :", wlan.ifconfig())


# Fonction de publication de la température et de l'humidité via MQTT
def publish_sensor_data(temperature, humidity):
    # Création du message en FORMAT DICTIONNAIRE PUIS JSON
    message = {
        "sensor_ID":1,
        "sensor_NAME": "DHT11",
        "temperature": temperature,
        "humidity": humidity
    }
    return(json.dumps(message))

# Fonction de CALLBACK COAP
def on_message(topic, message):
    print("Topic:", topic, "message:", message)
    # Décodage du message binaire pour extraire le JSON
    try:
        json_message = json.loads(message.decode("utf-8"))
        # Extraction de l'état du relais et contrôle en conséquence
        if json_message["etat"] == "on":
            control_relay(1)
            print("Relais activé")
        elif json_message["etat"] == "off":
            control_relay(0)
            print("Relais désactivé")
    except Exception as e:
        print("Erreur lors du décodage du message :", e)

# Fonctionde CALL BACK avec controle des TOPICs :
def on_message_wct(topic, message):
    print("Topic:", topic, "message:", message)
    
    # Décodage du message binaire pour extraire le JSON
    try:
        json_message = json.loads(message.decode("utf-8"))
    except Exception as e:
        print("Erreur lors du décodage du message :", e)
        return
    
    # Test de (topic)
    if topic.decode('UTF-8') == TOPIC_RELAY:
        # Extraction de l'état du relais et contrôle en conséquence
        if "etat" in json_message:
            if json_message["etat"] == "on":
                control_relay(1)
                print("Relais activé")
            elif json_message["etat"] == "off":
                control_relay(0)
                print("Relais désactivé")
        else:
            print("Message JSON invalide : aucune clé 'etat' trouvée.")
    elif topic == TOPIC_RELAY2:
        if "etat" in json_message:
            if json_message["etat"] == "on":
                print("Relais 2 activé")
            elif json_message["etat"] == "off":
                print("Relais 2 désactivé")
    else :
        print("Sujet inconnu :", topic)

# Connexion au réseau WiFi
connect_wifi(WIFI_SSID, WIFI_PASSWORD, static_ip)

#
def turnOnLed(packet, senderIp, senderPort):
    print('Turn-on-led request received:', packet.toString(), ', from: ', senderIp, ":", senderPort)
    server.sendResponse(senderIp, senderPort, packet.messageid,
                      "Ok", microcoapy.COAP_RESPONSE_CODE.COAP_CONTENT,
                      microcoapy.COAP_CONTENT_FORMAT.COAP_NONE, packet.token)

def measureCurrent(packet, senderIp, senderPort):
    print('Measure-current request received:', packet.toString(), ', from: ', senderIp, ":", senderPort)
    server.sendResponse(senderIp, senderPort, packet.messageid,
                      None, microcoapy.COAP_RESPONSE_CODE.COAP_SERVICE_UNAVALIABLE,
                      microcoapy.COAP_CONTENT_FORMAT.COAP_NONE, packet.token)
    
def measureTemphum(packet, senderIp, senderPort):
    print('Measure Temperature and Humidity request received:', packet.toString(), ', from: ', senderIp, ":", senderPort)
    # Mesures via capteur des données :
    temperature = 25
    humidity = 60
    messagejson = publish_sensor_data(temperature, humidity)
    server.sendResponse(senderIp, senderPort, packet.messageid, messagejson, microcoapy.COAP_RESPONSE_CODE.COAP_CONTENT,
                      microcoapy.COAP_CONTENT_FORMAT.COAP_APPLICATION_JSON, packet.token)

server = microcoapy.Coap()
# setup callback for incoming response to a request
server.addIncomingRequestCallback('led/turnOn', turnOnLed)
server.addIncomingRequestCallback('current/measure', measureCurrent)
server.addIncomingRequestCallback('temphum/measure', measureTemphum)

# Starting CoAP...
server.start()

# Boucle principale
while True:
    try:
        #Comportement Serveur :
        server.poll(60000) # attendre les réponses des servers pendant 60s (1min)
        print("Pas de requete server pendant 1 min entrer en mode Sleep pour 10s")
        # Mise en attente ou autre action :
        time.sleep(10)
        # Mise en veille profonde (deep sleep) pendant 10 secondes :
        #machine.deepsleep(10000)
            
    except Exception as e:
        print("Erreur :", e)
        time.sleep(1)


main.py

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

libraries.txt

from .microcoapy import Coap
from .coap_macros import COAP_CONTENT_FORMAT
from .coap_macros import COAP_RESPONSE_CODE


__init__.py

# Macros
_COAP_HEADER_SIZE = 4
_COAP_OPTION_HEADER_SIZE = 1
_COAP_PAYLOAD_MARKER = 0xFF
_MAX_OPTION_NUM = 10
_BUF_MAX_SIZE = 1024
_COAP_DEFAULT_PORT = 5683

def enum(**enums):
    return type('Enum', (), enums)


class CoapResponseCode:
    """ """
    @staticmethod
    def encode(class_, detail):
        """ """
        return ((class_ << 5) | (detail))

    @staticmethod
    def decode(value):
        class_ = (0xE0 & value) >> 5
        detail = 0x1F & value
        return (class_, detail)

COAP_VERSION = enum(
    COAP_VERSION_UNSUPPORTED = 0,
    COAP_VERSION_1 = 1
)

COAP_TYPE = enum(
    COAP_CON=0,
    COAP_NONCON=1,
    COAP_ACK=2,
    COAP_RESET=3
)

COAP_METHOD = enum(
    COAP_EMPTY_MESSAGE=0,
    COAP_GET=1,
    COAP_POST=2,
    COAP_PUT=3,
    COAP_DELETE=4
)

COAP_RESPONSE_CODE = enum(
    COAP_CREATED=CoapResponseCode.encode(2, 1),
    COAP_DELETED=CoapResponseCode.encode(2, 2),
    COAP_VALID=CoapResponseCode.encode(2, 3),
    COAP_CHANGED=CoapResponseCode.encode(2, 4),
    COAP_CONTENT=CoapResponseCode.encode(2, 5),
    COAP_BAD_REQUEST=CoapResponseCode.encode(4, 0),
    COAP_UNAUTHORIZED=CoapResponseCode.encode(4, 1),
    COAP_BAD_OPTION=CoapResponseCode.encode(4, 2),
    COAP_FORBIDDEN=CoapResponseCode.encode(4, 3),
    COAP_NOT_FOUND=CoapResponseCode.encode(4, 4),
    COAP_METHOD_NOT_ALLOWD=CoapResponseCode.encode(4, 5),
    COAP_NOT_ACCEPTABLE=CoapResponseCode.encode(4, 6),
    COAP_PRECONDITION_FAILED=CoapResponseCode.encode(4, 12),
    COAP_REQUEST_ENTITY_TOO_LARGE=CoapResponseCode.encode(4, 13),
    COAP_UNSUPPORTED_CONTENT_FORMAT=CoapResponseCode.encode(4, 15),
    COAP_INTERNAL_SERVER_ERROR=CoapResponseCode.encode(5, 0),
    COAP_NOT_IMPLEMENTED=CoapResponseCode.encode(5, 1),
    COAP_BAD_GATEWAY=CoapResponseCode.encode(5, 2),
    COAP_SERVICE_UNAVALIABLE=CoapResponseCode.encode(5, 3),
    COAP_GATEWAY_TIMEOUT=CoapResponseCode.encode(5, 4),
    COAP_PROXYING_NOT_SUPPORTED=CoapResponseCode.encode(5, 5)
)

COAP_OPTION_NUMBER = enum(
    COAP_IF_MATCH=1,
    COAP_URI_HOST=3,
    COAP_E_TAG=4,
    COAP_IF_NONE_MATCH=5,
    COAP_URI_PORT=7,
    COAP_LOCATION_PATH=8,
    COAP_URI_PATH=11,
    COAP_CONTENT_FORMAT=12,
    COAP_MAX_AGE=14,
    COAP_URI_QUERY=15,
    COAP_ACCEPT=17,
    COAP_LOCATION_QUERY=20,
    COAP_PROXY_URI=35,
    COAP_PROXY_SCHEME=39
)

COAP_CONTENT_FORMAT = enum(
    COAP_NONE=-1,
    COAP_TEXT_PLAIN=0,
    COAP_APPLICATION_LINK_FORMAT=40,
    COAP_APPLICATION_XML=41,
    COAP_APPLICATION_OCTET_STREAM=42,
    COAP_APPLICATION_EXI=47,
    COAP_APPLICATION_JSON=50,
    COAP_APPLICATION_CBOR=60
)

coapTypeToStringMap={
        COAP_TYPE.COAP_CON:    'CON',
        COAP_TYPE.COAP_NONCON: 'NONCON',
        COAP_TYPE.COAP_ACK:    'ACK',
        COAP_TYPE.COAP_RESET:  'RESET'
    }

def coapTypeToString(type):
    return coapTypeToStringMap.get(type, "INVALID")


coap_macros.py

class CoapOption:
    def __init__(self, number=-1, buffer=None):
        self.number = number
        byteBuf = bytearray()
        if buffer is not None:
            byteBuf.extend(buffer)
        self.buffer = byteBuf


coap_option.py

import coap_macros as macros
from coap_option import CoapOption

class CoapPacket:
    def __init__(self):
        self.version = macros.COAP_VERSION.COAP_VERSION_UNSUPPORTED
        self.type = macros.COAP_TYPE.COAP_CON  # uint8_t
        self.method = macros.COAP_METHOD.COAP_GET  # uint8_t
        self.token = bytearray()
        self.payload = bytearray()
        self.messageid = 0
        self.content_format = macros.COAP_CONTENT_FORMAT.COAP_NONE
        self.query = bytearray()  # uint8_t*
        self.options = []

    # def __eq__(self, other):
    #     return self.toString() == other.toString()
        # (self.version == other.version and self.type == other.type and\
        #     self.method == other.method and self.token == other.token and\
        #     self.payload == other.payload and self.messageid == other.messageid and\
        #     self.content_format == other.content_format and self.query == other.query and\
        #     self.options == other.options)

    def addOption(self, number, opt_payload):
        if(len(self.options) >= macros._MAX_OPTION_NUM):
            return
        self.options.append(CoapOption(number, opt_payload))

    def setUriHost(self, address):
        self.addOption(macros.COAP_OPTION_NUMBER.COAP_URI_HOST, address)

    def setUriPath(self, url):
        for subPath in url.split('/'):
            self.addOption(macros.COAP_OPTION_NUMBER.COAP_URI_PATH, subPath)

    def toString(self):
        class_, detail = macros.CoapResponseCode.decode(self.method)
        return "type: {}, method: {}.{:02d}, messageid: {}, payload: {}".format(macros.coapTypeToString(self.type), class_, detail, self.messageid, self.payload)


coap_packet.py

import coap_macros as macros
from coap_option import CoapOption

def parseOption(packet, runningDelta, buffer, i):
    option = CoapOption()
    headlen = 1

    errorMessage = (False, runningDelta, i)

    if (buffer is None):
        return errorMessage

    buflen = len(buffer) - i

    if (buflen < headlen):
        return errorMessage

    delta = (buffer[i] & 0xF0) >> 4
    length = buffer[i] & 0x0F

    if delta == 15 or length == 15:
        return errorMessage

    if delta == 13:
        headlen += 1
        if (buflen < headlen):
            return errorMessage
        delta = buffer[i+1] + 13
        i += 1
    elif delta == 14:
        headlen += 2
        if (buflen < headlen):
            return errorMessage
        delta = ((buffer[i+1] << 8) | buffer[i+2]) + 269
        i += 2

    if length == 13:
        headlen += 1
        if (buflen < headlen):
            return errorMessage
        length = buffer[i+1] + 13
        i += 1
    elif length == 14:
        headlen += 2
        if (buflen < headlen):
            return errorMessage
        length = ((buffer[i+1] << 8) | buffer[i+2]) + 269
        i += 2

    endOfOptionIndex = (i + 1 + length)

    if endOfOptionIndex > len(buffer):
        return errorMessage

    option.number = delta + runningDelta
    option.buffer = buffer[i+1:i+1+length]
    packet.options.append(option)

    return (True, runningDelta + delta, endOfOptionIndex)

def parsePacketHeaderInfo(buffer, packet):
    packet.version = (buffer[0] & 0xC0) >> 6
    packet.type = (buffer[0] & 0x30) >> 4
    packet.tokenLength = buffer[0] & 0x0F
    packet.method = buffer[1]
    packet.messageid = 0xFF00 & (buffer[2] << 8)
    packet.messageid |= 0x00FF & buffer[3]

def parsePacketOptionsAndPayload(buffer, packet):
    bufferLen = len(buffer)
    if (macros._COAP_HEADER_SIZE + packet.tokenLength) < bufferLen:
        delta = 0
        bufferIndex = macros._COAP_HEADER_SIZE + packet.tokenLength
        while (len(packet.options) < macros._MAX_OPTION_NUM) and\
              (bufferIndex < bufferLen) and\
              (buffer[bufferIndex] != 0xFF):
            (status, delta, bufferIndex) = parseOption(packet, delta, buffer, bufferIndex)
            if status is False:
                return False

        if ((bufferIndex + 1) < bufferLen) and (buffer[bufferIndex] == 0xFF):
            packet.payload = buffer[bufferIndex+1:]  # does this works?
        else:
            packet.payload = None
    return True


coap_reader.py

from coap_macros import _BUF_MAX_SIZE
from coap_macros import COAP_VERSION

def CoapOptionDelta(v):
    if v < 13:
        return (0xFF & v)
    elif v <= 0xFF + 13:
        return 13
    else:
        return 14

def writePacketHeaderInfo(buffer, packet):
    # make coap packet base header
    buffer.append(COAP_VERSION.COAP_VERSION_1 << 6)
    buffer[0] |= (packet.type & 0x03) << 4
    # max: 8 bytes of tokens, if token length is greater, it is ignored
    tokenLength = 0
    if (packet.token is not None) and (len(packet.token) <= 0x0F):
        tokenLength = len(packet.token)

    buffer[0] |= (tokenLength & 0x0F)
    buffer.append(packet.method)
    buffer.append(packet.messageid >> 8)
    buffer.append(packet.messageid & 0xFF)

    if tokenLength > 0:
        buffer.extend(packet.token)

def writePacketOptions(buffer, packet):
    runningDelta = 0
    # make option header
    for opt in packet.options:
        if (opt is None) or (opt.buffer is None) or (len(opt.buffer) == 0):
            continue

        optBufferLen = len(opt.buffer)

        if (len(buffer) + 5 + optBufferLen) >= _BUF_MAX_SIZE:
            return 0

        optdelta = opt.number - runningDelta
        delta = CoapOptionDelta(optdelta)
        length = CoapOptionDelta(optBufferLen)

        buffer.append(0xFF & (delta << 4 | length))
        if (delta == 13):
            buffer.append(optdelta - 13)
        elif (delta == 14):
            buffer.append((optdelta - 269) >> 8)
            buffer.append(0xFF & (optdelta - 269))

        if (length == 13):
            buffer.append(optBufferLen - 13)
        elif (length == 14):
            buffer.append(optBufferLen >> 8)
            buffer.append(0xFF & (optBufferLen - 269))

        buffer.extend(opt.buffer)
        runningDelta = opt.number

def writePacketPayload(buffer, packet):
    # make payload
    if (packet.payload is not None) and (len(packet.payload)):
        if (len(buffer) + 1 + len(packet.payload)) >= _BUF_MAX_SIZE:
            return 0
        buffer.append(0xFF)
        buffer.extend(packet.payload)


coap_writer.py

import usocket as socket
import uos
import utime as time
import coap_macros as macros
from coap_packet import CoapPacket

from coap_reader import parsePacketHeaderInfo
from coap_reader import parsePacketOptionsAndPayload
from coap_writer import writePacketHeaderInfo
from coap_writer import writePacketOptions
from coap_writer import writePacketPayload

import binascii

class Coap:
    TRANSMISSION_STATE = macros.enum(
        STATE_IDLE = 0,
        STATE_SEPARATE_ACK_RECEIVED_WAITING_DATA = 1
    )

    def __init__(self):
        self.debug = True
        self.sock = None
        self.callbacks = {}
        self.responseCallback = None
        self.port = 0
        self.isServer = False
        self.state = self.TRANSMISSION_STATE.STATE_IDLE
        self.isCustomSocket = False

        #beta flags
        self.discardRetransmissions = False
        self.lastPacketStr = ""

    def log(self, s):
        if self.debug:
            print("[microcoapy]: " + s)

    # Create and initialize a new UDP socket to listen to.
    # port: the local port to be used.
    def start(self, port=macros._COAP_DEFAULT_PORT):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.bind(('', port))

    # Stop and destroy the socket that has been created by
    # a previous call of 'start' function
    def stop(self):
        if self.sock is not None:
            self.sock.close()
            self.sock = None

    # Set a custom instance of a UDP socket
    # Is used instead of calling start/stop functions.
    #
    # Note: This overrides the automatic socket that has been created
    # by the 'start' function.
    # The custom socket must support functions:
    # * socket.sendto(bytes, address)
    # * socket.recvfrom(bufsize)
    # * socket.setblocking(flag)
    def setCustomSocket(self, custom_socket):
        self.stop()
        self.isCustomSocket = True
        self.sock = custom_socket

    def addIncomingRequestCallback(self, requestUrl, callback):
        self.callbacks[requestUrl] = callback
        self.isServer = True

    def sendPacket(self, ip, port, coapPacket):
        if coapPacket.content_format != macros.COAP_CONTENT_FORMAT.COAP_NONE:
            optionBuffer = bytearray(2)
            optionBuffer[0] = (coapPacket.content_format & 0xFF00) >> 8
            optionBuffer[1] = (coapPacket.content_format & 0x00FF)
            coapPacket.addOption(macros.COAP_OPTION_NUMBER.COAP_CONTENT_FORMAT, optionBuffer)

        if (coapPacket.query is not None) and (len(coapPacket.query) > 0):
            coapPacket.addOption(macros.COAP_OPTION_NUMBER.COAP_URI_QUERY, coapPacket.query)

        buffer = bytearray()
        writePacketHeaderInfo(buffer, coapPacket)

        writePacketOptions(buffer, coapPacket)

        writePacketPayload(buffer, coapPacket)

        status = 0
        try:
            sockaddr = (ip, port)
            try:
                sockaddr = socket.getaddrinfo(ip, port)[0][-1]
            except Exception as e:
                pass

            status = self.sock.sendto(buffer, sockaddr)

            if status > 0:
                status = coapPacket.messageid

            self.log('Packet sent. messageid: ' + str(status))
        except Exception as e:
            status = 0
            print('Exception while sending packet...')
            import sys
            sys.print_exception(e)

        return status

    def send(self, ip, port, url, type, method, token, payload, content_format, query_option):
        packet = CoapPacket()
        packet.type = type
        packet.method = method
        packet.token = token
        packet.payload = payload
        packet.content_format = content_format
        packet.query = query_option

        return self.sendEx(ip, port, url, packet)

    def sendEx(self, ip, port, url, packet):
        self.state = self.TRANSMISSION_STATE.STATE_IDLE
        # messageId field: 16bit -> 0-65535
        # urandom to generate 2 bytes
        randBytes = uos.urandom(2)
        packet.messageid = (randBytes[0] << 8) | randBytes[1]
        packet.setUriHost(ip)
        packet.setUriPath(url)

        return self.sendPacket(ip, port, packet)

    # to be tested
    def sendResponse(self, ip, port, messageid, payload, method, content_format, token):
        packet = CoapPacket()

        packet.type = macros.COAP_TYPE.COAP_ACK
        packet.method = method
        packet.token = token
        packet.payload = payload
        packet.messageid = messageid
        packet.content_format = content_format

        return self.sendPacket(ip, port, packet)

    #Confirmable
    def get(self, ip, port, url, token=bytearray()):
        return self.send(ip, port, url, macros.COAP_TYPE.COAP_CON, macros.COAP_METHOD.COAP_GET, token, None, macros.COAP_CONTENT_FORMAT.COAP_NONE, None)

    def put(self, ip, port, url, payload=bytearray(), query_option=None, content_format=macros.COAP_CONTENT_FORMAT.COAP_NONE, token=bytearray()):
        return self.send(ip, port, url, macros.COAP_TYPE.COAP_CON, macros.COAP_METHOD.COAP_PUT, token, payload, content_format, query_option)

    def post(self, ip, port, url, payload=bytearray(), query_option=None, content_format=macros.COAP_CONTENT_FORMAT.COAP_NONE, token=bytearray()):
        return self.send(ip, port, url, macros.COAP_TYPE.COAP_CON, macros.COAP_METHOD.COAP_POST, token, payload, content_format, query_option)

    #non Confirmable
    def getNonConf(self, ip, port, url, token=bytearray()):
        return self.send(ip, port, url, macros.COAP_TYPE.COAP_NONCON, macros.COAP_METHOD.COAP_GET, token, None, macros.COAP_CONTENT_FORMAT.COAP_NONE, None)

    def putNonConf(self, ip, port, url, payload=bytearray(), query_option=None, content_format=macros.COAP_CONTENT_FORMAT.COAP_NONE, token=bytearray()):
        return self.send(ip, port, url, macros.COAP_TYPE.COAP_NONCON, macros.COAP_METHOD.COAP_PUT, token, payload, content_format, query_option)

    def postNonConf(self, ip, port, url, payload=bytearray(), query_option=None, content_format=macros.COAP_CONTENT_FORMAT.COAP_NONE, token=bytearray()):
        return self.send(ip, port, url, macros.COAP_TYPE.COAP_NONCON, macros.COAP_METHOD.COAP_POST, token, payload, content_format, query_option)

    def handleIncomingRequest(self, requestPacket, sourceIp, sourcePort):
        url = ""
        for opt in requestPacket.options:
            if (opt.number == macros.COAP_OPTION_NUMBER.COAP_URI_PATH) and (len(opt.buffer) > 0):
                if url != "":
                    url += "/"
                url += opt.buffer.decode('unicode_escape')

        urlCallback = None
        if url != "":
            urlCallback = self.callbacks.get(url)

        if urlCallback is None:
            if self.responseCallback:
                # The incoming request may be a response, let the responseCallback handle it.
                return False
            print('Callback for url [', url, "] not found")
            self.sendResponse(sourceIp, sourcePort, requestPacket.messageid,
                              None, macros.COAP_RESPONSE_CODE.COAP_NOT_FOUND,
                              macros.COAP_CONTENT_FORMAT.COAP_NONE, requestPacket.token)

        else:
            urlCallback(requestPacket, sourceIp, sourcePort)
        return True

    def readBytesFromSocket(self, numOfBytes):
        try:
            return self.sock.recvfrom(numOfBytes)
        except Exception:
            return (None, None)

    def parsePacketToken(self, buffer, packet):
        if (packet.tokenLength == 0):
            packet.token = None
        elif (packet.tokenLength <= 8):
            packet.token = buffer[4:4+packet.tokenLength]
        else:
            (tempBuffer, tempRemoteAddress) = self.readBytesFromSocket(macros._BUF_MAX_SIZE - bufferLen)
            if tempBuffer is not None:
                buffer.extend(tempBuffer)
            return False
        return True

    def loop(self, blocking=True):
        if self.sock is None:
            return False

        self.sock.setblocking(blocking)
        (buffer, remoteAddress) = self.readBytesFromSocket(macros._BUF_MAX_SIZE)
        self.sock.setblocking(True)

        while (buffer is not None) and (len(buffer) > 0):
            bufferLen = len(buffer)
            if (bufferLen < macros._COAP_HEADER_SIZE) or (((buffer[0] & 0xC0) >> 6) != 1):
                (tempBuffer, tempRemoteAddress) = self.readBytesFromSocket(macros._BUF_MAX_SIZE - bufferLen)
                if tempBuffer is not None:
                    buffer.extend(tempBuffer)
                continue

            packet = CoapPacket()

            self.log("Incoming Packet bytes: " + str(binascii.hexlify(bytearray(buffer))))

            parsePacketHeaderInfo(buffer, packet)

            if not self.parsePacketToken(buffer, packet):
                continue

            if not parsePacketOptionsAndPayload(buffer, packet):
                return False

            # beta functionality
            if self.discardRetransmissions:
                if packet.toString() == self.lastPacketStr:
                    self.log("Discarded retransmission message: " + packet.toString())
                    return False
                else:
                    self.lastPacketStr = packet.toString()
            ####

            if not self.isServer or not self.handleIncomingRequest(packet, remoteAddress[0], remoteAddress[1]):
                # To handle cases of Separate response (rfc7252 #5.2.2)
                if packet.type == macros.COAP_TYPE.COAP_ACK and\
                    packet.method == macros.COAP_METHOD.COAP_EMPTY_MESSAGE:
                      self.state = self.TRANSMISSION_STATE.STATE_SEPARATE_ACK_RECEIVED_WAITING_DATA
                      return False
                # case of piggybacked response where the response is in the ACK (rfc7252 #5.2.1)
                # or the data of a separate message
                else:
                    if self.state == self.TRANSMISSION_STATE.STATE_SEPARATE_ACK_RECEIVED_WAITING_DATA:
                        self.state = self.TRANSMISSION_STATE.STATE_IDLE
                        self.sendResponse(remoteAddress[0], remoteAddress[1], packet.messageid,
                                        None, macros.COAP_TYPE.COAP_ACK,
                                        macros.COAP_CONTENT_FORMAT.COAP_NONE, packet.token)
                    if self.responseCallback is not None:
                        self.responseCallback(packet, remoteAddress)
            return True

        return False

    def poll(self, timeoutMs=-1, pollPeriodMs=500):
        start_time = time.ticks_ms()
        status = False
        while not status:
            status = self.loop(False)
            if (time.ticks_diff(time.ticks_ms(), start_time) >= timeoutMs): break
            time.sleep_ms(pollPeriodMs)
        return status
