iotcreators.com web
    • Login
    • Search
    • forum.iotcreators.com
    • docs.iotcreators.com
    • Tags
    • Popular
    • Recent
    • Register

    Quectel BG96 ervaring met otheruse

    Archive
    2
    3
    1624
    Loading More Posts
    • Oldest to Newest
    • Newest to Oldest
    • Most Votes
    Reply
    • Reply as topic
    Log in to reply
    This topic has been deleted. Only users with topic management privileges can see it.
    • M
      melvinItude last edited by

      Hoi Allemaal,

      Wij hebben het voor elkaar om met de Quectel BG96 Neul messages te sturen naar het Nokia impact platform.
      Er is wat vraag naar om hierover mijn ervaring te delen dus bij deze :)

      De library die wij gebruikt hebben:
      https://github.com/otheruse/NeulMessenger

      Wij hebben deze library gepoort naar Mbed en gebruiken geen Arduino oid.
      De enige twee klassen die wij gebruiken zijn:

      • CoapPacket.h .cpp
      • NeulMessenger.h .cpp

      De MDM9206Module klasse hebben wij verwerkt in onze eigen klasse.

      Er was 1 probleem dat wij ondervonden hebben in de MDM9206Module.
      De methode receiveUDP houdt geen rekening met achtereenvolgende downlink berichten. De methode receiveUDP is zo geprogrammeerd dat deze wacht op een +QIURC: “recv” bericht. Dit bericht wordt echter alleen verstuurd als de BG96 buffer op dat moment leeg is!
      Het oceanconnect/impact platform stuurt een ACK bericht terug en direct daar achteraan een bericht bevattende een token oid. Wij hebben ondervonden dat hij de ACK netjes verwerkt en daarna vervolgens wacht op nogmaals een +QIURC: “recv” wat nooit naar voren komt omdat de buffer op het moment dat het bericht binnen kwam al data bevatte (de ACK).

      Zie hiervoor ook de Quectel documentatie (pagina 19):
      https://www.quectel.com/UploadImage/Downlad/Quectel_BG96_TCP(IP)_AT_Commands_Manual_V1.0.pdf
      “Please note that if the buffer is not empty, and the module receives data again, it will not report a new
      URC until all the received data has been retrieved via AT+QIRD from buffer.”

      Hierbij onze implementatie van receiveUDP (deze zou je moeten verbouwen voor Arduino):

      size_t BG96::receiveUDP(const int socket, uint8_t* buffer, const size_t len, const uint32_t timeout) {
      uint32_t start = us_ticker_read();
      	bool found = false;
      	// Ignore ip address and port for now
      	size_t size = 0;
      	char crLf;
      
      	//No +QIURC will be sended when the buffer already contained data.
      	//So check if we have already some data ready to be read
      	LOG("Reading UDP buffer\n");
      	sendCommand("AT+QIRD=%d", socket);
      	receive(DEFAULT_TIMEOUT, "+QIRD: %d%c", &size, &crLf);
      	if (size == 0) {
      		LOG("Buffer is empty. Waiting for incoming UDP messages\n");
      		while (us_ticker_read() - start < (timeout * 1000)) {
      			// +QIURC: "recv",<socket>
      			int sock;
      			char crLf;
      			LOG("Checking for incoming UDP message\n");
      			if (receive(DEFAULT_TIMEOUT, "+QIURC: \"recv\",%d%c%c", &sock, &crLf, &crLf)) {
      				LOG("Got a incoming UDP message\n");
      				if (sock == socket) {
      					LOG("UDP message is from the same socket\n");
      					found = true;
      					break;
      				}
      			}
      		}
      		if (found) {
      			LOG("Reading UDP buffer\n");
      			sendCommand("AT+QIRD=%d", socket);
      			receive(DEFAULT_TIMEOUT, "+QIRD: %d%c", &size, &crLf);
      		}
      	}
      	if (size != 0) {
      		LOG("Got message size: %d\n", size);
      		size_t bytesToRead = (size <= len ? size : len);
      		LOG("Bytes to read: %d\n", bytesToRead);
      		//drop ip information and other stuff till we find the new line character
      		while (crLf != '\n') {
      			read(DEFAULT_TIMEOUT, &crLf, 1);
      		}
      		read(DEFAULT_TIMEOUT, (char*)buffer, bytesToRead);
      		for (size_t i = 0; i < bytesToRead; i++) {
      			LOG("%02x ", buffer[i]);
      		}
      		LOG("\n");
      		return bytesToRead;
      	}
      	return 0;
      }
      

      Success :)

      1 Reply Last reply Reply Quote 1
      • M
        melvinItude last edited by

        Hierbij dan toch nog een ongeteste poort naar otheruse :) :

        size_t MDM9206Module::receiveUDP(int socket, uint8_t* buffer, size_t len, uint32_t timeout) {
        	timestamp_t start = getTimestamp();
        	bool found = false;
        	int size;
        	serial.printf("AT+QIRD=%d\r\n", socket);
        	serial.find(1000,{"+QIRD: "});
        	serial.readLine((char*)buffer, len, 1000);// the response
        	size = atoi((char*)buffer);
        
        	if (size == 0) {
        		while (getTimestamp() - start < timeout) {
        			// +QIURC: "recv",
        			if (serial.find(1000, {"+QIURC: \"recv\","}) == 0) {
        				char buf[10]{};
        				serial.readLine(buf, sizeof(buf), timeout - (getTimestamp() - start));
        				int sock = atoi(buf);
        	//			Serial.print("Message receive indicator found on socket ");
        	//			Serial.println(sock, 10);
        				if (sock == socket) {
        					found = true;
        					break;
        				}
        			}
        		}
        		if (found) {
        			serial.printf("AT+QIRD=%d\r\n", socket);
        			serial.find(1000,{"+QIRD: "});
        			serial.readLine((char*)buffer, len, 1000);// the response
        			size = atoi((char*)buffer);
        		}
        	}
        	if (size != 0) {
        		// Ignore ip address and port for now
        		serial.readBytes(buffer, size, 1000);
        		return size;
        	}
        	return 0;
        }
        
        1 Reply Last reply Reply Quote 1
        • T
          thijs buuron last edited by

          Hey,

          Heeft er toevallig ook al iemand ervaring met deze library en de BC68?

          1 Reply Last reply Reply Quote 0
          • 1 / 1
          • First post
            Last post