TagoIO Integration Guide: LooUQ MTC2-N9151

How to build an end to end solution with TagoIO using TagoTiP on the LooUQ MTC2-N9151

Getting device data into a cloud platform usually means picking a protocol, then discovering it was designed for networks with more bandwidth and patience than yours. MQTT needs a TCP session and keep-alives. HTTP spends hundreds of bytes on headers before your payload starts. On a metered cellular plan, and even more so over a narrowband satellite link, that overhead is the largest part of what you transmit.

TagoIO’s TagoTiP (Tago Transport IoT Protocol) takes a different approach. It is a compact, human-readable, text-based frame that rides on a single UDP datagram. This post shows how to connect a LooUQ MTC2-N9151, built on the Nordic Semiconductor nRF9151, to TagoIO using TagoTiP over UDP. The example uses AT commands, and we point out the equivalent calls if you work in the nRF Connect SDK (NCS) instead.

Why TagoTiP over UDP

• Lightweight. One frame is one datagram. There is no handshake and no session to keep alive, which matters when each radio-on second costs battery and, on NTN, airtime.
• Human-readable. You can read a frame in a terminal log and build one with a string format call. Debugging does not need a protocol analyzer.
• Acknowledgements are optional. The server replies with an ACK, but your firmware is free to ignore it. Wait for it when delivery confirmation matters, and skip it for fire-and-forget telemetry.
• Same frame on terrestrial (TN) and non-terrestrial (NTN) networks. The payload is identical on terrestrial cellular (LTE-M, NB-IoT) and satellite NB-IoT NTN. Only the network attach step differs. If you are weighing satellite for a deployment, see our GEO vs. LEO overview for how orbit choice affects this kind of traffic.

If you prefer C over AT commands, the same flow works with TagoTiP implemented in code on the nRF9151. Only the transport calls change.

The flow

1. Connect to the network (this example uses Monogoto, a multi-network IoT connectivity provider).
2. Open a UDP socket to the TagoIO endpoint.
3. Send a frame.
4. Optionally read the acknowledgement.

Repeat steps 3 and 4 until you have sent everything. Then close the socket and detach from the network.

If you need assistance with connecting, the MTC2-N9151 product page has guides for both cellular (TN) and satellite (NTN).

What you need

ItemWhat it isHashThe shared authorization token, in its wire-safe form. Generate it in the TagoIO console. One hash can serve all of your devices.SerialThe unique name for your device. It can be the IMEI, but the serial travels in every frame, so use something shorter if you can.EndpointThe TagoIO UDP ingest host for your region (see below).

TagoIO publishes regional endpoints. At the time of writing these are udp.tip.us-e1.tago.io (US East) and udp.tip.eu-w1.tago.io (EU West), with port 5683 for plaintext frames and 5684 for TagoTiP(s). Check the TagoTiP UDP documentation for the current list.

Anatomy of a frame

A PUSH frame has four pipe-delimited fields:

PUSH|<hash>|<serial>|[<variables>]


FieldPUSHThe action: send data.hashYour authorization token.serialYour device identifier.variablesOne or more variables in square brackets, separated by semicolons.

Each variable uses an operator that tells TagoIO its type:

TypeOperatorExampleNumber:=temperature:=25.5String=status=onlineBoolean?=active?=trueLocation@=position@=39.74,-104.99

Numeric values also accept optional suffixes, such as a unit (#C), a timestamp, a group, or metadata. The UDP transport page lists them all. A complete frame looks like this:

PUSH|ae81bc617197d3b0|loouq-1|[temperature:=60;conditions=overcast]


That is a single datagram carrying two variables. Keep each datagram under roughly 1,400 bytes to avoid IP fragmentation. At the sizes typical of IoT telemetry, you will be well below that.

The acknowledgement

After a PUSH, the server answers with an ACK frame:

ACK|OK|2


The second field is the status. OK means success, and on failure you get ERR followed by a reason such as invalid_token, device_not_found, invalid_payload, rate_limited, or payload_too_large. The final field is the number of data points stored (2 here, one for each variable in the frame).

Reading the ACK is entirely optional. A battery-powered sensor reporting every few minutes can skip it. A device sending an alarm, or one that needs to know a message landed before it goes back to sleep, can wait for it and retry on a timeout.

Putting it together with AT commands

On the nRF9151 running a serial AT interface, the sequence maps to attach, open socket, send, receive, close, detach. The commands below use the Nordic Serial LTE Modem command set.

// 1. Attach to the network
AT+CFUN=1
AT+CEREG?                         // wait for registered (1 or 5)// 2. Open a UDP socket and set the TagoIO endpoint
AT#XSOCKET=1,2,0
AT#XCONNECT="udp.tip.us-e1.tago.io",5683

// 3. Send a frame
AT#XSEND="PUSH|ae81bc617197d3b0|loouq-1|[temperature:=60;conditions=overcast]"

// 4. (Optional) read the acknowledgement
AT#XRECVFROM=0,1,0,10
ACK|OK|2

// 5. Done: close and detach
AT#XCLOSE
AT+CFUN=0


If you build on NCS, the same steps map onto the standard socket API: nrf_modem_lib network init, then socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), sendto(), an optional recvfrom() with a timeout, and close().

Taking it to satellite

The frame does not change when the network does. The MTC2-N9151 is Skylo-certified and supports NB-NTN, a standard based largely on the terrestrial equivalent NB-IoT, so a device that reports over cellular in town can report over GEO satellite where there is no coverage, using the same PUSH frame to the same endpoint. What changes is the attach step and the link behavior. Round-trip latency is higher over GEO, so a longer ACK timeout is sensible if you choose to wait for acknowledgements, and a compact frame helps keep airtime and cost down. This is where the small TagoTiP footprint pays off most.

Tips for production

• Shorten the serial. It is sent with every frame. An IMEI works, but a short unique ID saves bytes on every message.
• Batch variables. Several variables in one frame cost less than several frames.
• Treat the hash as a secret. It authenticates the frame. Frames sent to port 5683 are plaintext, so the hash and your data are visible on the wire. If that matters for your application, use port 5684 (TagoTiP(s)) instead. Provision the hash per fleet or per device, and rotate it if it leaks.
• Handle rate_limited and retries. If you do wait for ACKs, back off on errors instead of resending immediately.
• Close the socket and detach when you are done so the modem can return to its low-power state.
• Use PSM or eDRX for frequent reporting. A full detach and re-attach costs time and airtime on every report, especially over NTN, so a device that wakes often should stay registered and sleep in PSM or eDRX instead.

Next steps

For the full protocol details, see the TagoTiP documentation from its creators at tago.io/tip. For the hardware, see the MTC2-N9151 product page, and contact the LooUQ team if you want help designing your first TagoIO integration.

‍