Hi,
what is the size counted against the quota for base64-encoded payload? Is it less when a template is set up? Is it transmitted in base64 or in a binary format?
Is the quota counted against data routed out of the notehub or for every note that is synced to the notehub?
Best regards, Gaute
Yes, how can I estimate how much of the bundled cellular data will be used. There’s isn’t any mention of total data in the subscription plans at the notehub. If I subscribe to one of the paid plans, may I use more data than 500mb for each notecard?
Regards, Gaute
I now tried to send some data as base64 encoded payload, but I am getting the error payload too large 250 max. This is really frustrating to work with, since it is not documented and everything has to be trial and error. Can the payload be a maximum of 250 bytes?! That’s not very much!
I need to send about 8 kb size notes. Do I have to run the notecard in continuous mode to be able to use web.post (as suggested in other threads here). What are the size limits in that case?
I’ll try to answer the many different questions.
If a template is not used then note payloads are limited to 250 bytes (I will request to have that added to the documentation). However, if a template is used the payload size can be many kilobytes - 8kb would be fine. In terms of data usage over the air if you are only using binary payloads templates do not offer an advantage - though they allow for much larger payloads. Templates offer significant data savings if your notes are mostly JSON bodies, because the templated notes compress the JSON into a binary array of the field values.
Although the data is sent to the notecard base64 encoded it is sent as binary over the air. It is converted back to base64 at Notehub to facilitate viewing and routing via text based protocols.
Estimating data usage over the air involves much more than just the note content. If the notecard is in continuous mode then syncing a single note will typically not involve much overhead - there is a request / response sequence and, of course TCP/IP headers - perhaps under 1k bytes. However if the Notecard is in periodic mode and has to establish a connection to Notehub to sync the note then there is extra overhead of establishing the TCP/IP connection (~1k) and if the note is in a secure notefile (.qos/.qis) a TLS session is established, which typically uses another 6k of data over the air. Note that, after being powered off the Notecard will make a TLS connection to Notehub on the first sync after power is re-applied, so the first sync after power up will consume an extra 6k of data. For this reason we recommend leaving the Notecard permanently powered up - the standby power consumption is less than 10uA, when not connected to Notehub.
Therefore, for the lowest data usage you would leave the Notecard in a continuous connection to Notehub - the only drawback to this is significantly higher power consumption (~20mA from memory) versus the 10uA standby consumption in periodic mode. However if your application is not battery powered, this may be the better approach.
Finally, rather than trying to make an estimate of data usage it may be easier to run the Notecard for a period and measure the data usage, using {"req":"card.usage.get"}.
https://dev.blues.io/reference/notecard-api/card-requests/#card-usage-get
Note that the Notecard only updates its usage when it disconnects from Notehub, so if you run it in continuous mode you would need to disconnect it periodically to check the updated usage data. You can achieve this by running these commands:
{"req":"hub.set","mode":"off"}
<wait for 30 seconds>
{"req":"card.usage.get"}
{"req":"hub.set","mode":"continuous"}
Thanks
Sean
Thanks a lot for the answer. I am sending time series of 16 bit floats, and I was planning to set up templates anyway so that works fine.
So it might actually be more bandwidth efficient for me to send the arrays of floats in the note body as templated JSON, rather than encoding them as base64? I will probably try to compress the floats and in that case I will have an array of u8’s either for templated body or base64 payload.
It is battery powered, so I think I have to rather turn on continuous mode for sending rather than staying in continuous all the time. In this case it is probably better to be unconnected and sync when necessary. I will cache as much as possible of the data on the MCU before adding the notes, so that syncs can be more infrequent and the notecard can stay mostly in standby mode.
Thanks for the tip on estimating usage.
I would expect the data usage will be lower if your host MCU performs any possible compression and then supplies the data to the Notecard as a base64 encoded payload. Even if templates are used I would expect JSON bodies to be less efficient than a packed payload - but that’s just a hunch.
If your application is battery based you could use periodic mode - there is no advantage to using continuous mode if you are enabling and disabling it. You can also force a particular notefile to be sync’d outside of the periodic schedule by appending sync:true to the note.add - so your application has full control. It’s always a good idea to setup a fallback inbound sync duration, just in case the host MCU misbehaves so that the Notecard will check in to Notehub once a day or once a week:
{"req":"hub.set","mode":"periodic","inbound":1440}
I don’t know if the timestamp of the 16 bit floats is important, but one trade-off you might want to consider is to submit the notes to the notecard more frequently, and with smaller payloads, so that the Notecard captures the time at which the note was added. The notes will then sit in the Notecard filesystem until the next sync. The Notecard LPUART and I2C can both accept note.add while the Notecard is running at the standby current of 10uA.
Thanks
Sean
Thanks for the tips. I think I will send a timestamp in the JSON body with each payload. That’s good to know that the notecard can receive and enqueue the notes while in standby, also good point to configure a regular sync regardless of whether MCU acts up.
Is it possible to use UART over the TX/RX pins from the MCU? Would it be able to operate at a higher speed than the I2C?
I’m trying to send both body and payload with a template, the payload is sent just fine (also with about 8kB!!), and template is true in the response: but the body is empty in the routed event. Any idea what might be going on?
It also seems like the payload is padded with a bunch of NULs (AAAAA…), more than what I specified in the length of the template. Why is that? That means I also need to send a length parameter of the base64 string. I have confirmed that the transmitted base64 string is the same as the length specified in the template.
The body in this case was a timestamp and an offset, both 4 byte ints. It seems that if I set the value to 0 when adding the body, the fields are simply omitted.
@gauteh could you give an example so that we can try to recreate the problem, and also check the response of {"req":"card.version"} to make sure you are running up to date firmware (the LTS 2.1.1 build is the most recent).
If your Notecard is running older firmware please update to 2.1.1 before going any further:
Thanks
Sean
It also seems like the payload is padded with a bunch of NULs (AAAAA…), more than what I specified in the length of the template.
Do you mean that when you take the base64 string received by Notehub and run it through a base64 decoder that the binary data produced is longer than the payload length specified in the note.template ?
The body in this case was a
timestampand anoffset, both 4 byte ints. It seems that if I set the value to0when adding the body, the fields are simply omitted.
I should have read all of the posts before replying. This is the JSON “omit if empty” feature, which reduces data over the air by eliminating “null” fields.
The “omitempty” option specifies that the field should be omitted from the encoding if the field has an empty value, defined as false, 0, a nil pointer, a nil interface value, and any empty array, slice, map, or string.
Any missing fields are implicitly zero / null / false.
This base64 string:
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
becomes this payload:
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
The length I have specified in the template is 8196.
The DFU version from notehub is:
Fri 02:03:33 PM cain 1.5.6.13807 1.5.6.13807
omit if empty won’t present a big problem for my use case, but it is ambiguous: a missing value is not the same as 0 always. Anyway, would be good to see that in the docs 
Makes sense and there probably was some sort of “heads up” warning to developers I missed…
Nonetheless that 250 bytes limit broke code deployed that used to work 