Programming

This post describes a "work in progress" project I started today. Here is the High Level Overview:





Currently, this project sits on my desk as an Arduino UNO (on the bottom), an NB-IoT Shield (sandwiched in the middle), a Sensor Shield (on top) with a HM-10 BLE Module (in the little bread board):



The goal of this project is to combine the simple results from these two Arduino tests:
In a nutshell, I am going to attempt to combine two different Arduino apps / sketches, which currently work independently, into one Arduino UNO sketch, which will permit me to press a button on the iPhone (using the ArdunioBlue app, tested in the link above) and send the BLE message to the Ardunio and then forward/send a message (based on the BLE data) to the NB-IoT network which will relay the message to a Linux server on the Internet; and then get some server stats based on the iPhone BLE message and return the results to me and display it in a popup message on the iPhone.

Basically, I have (1) the BLE part (from the iPhone to the Arduino) working fine (see link above); and I also have (2) the NB-IoT part between the Arduino and a Python UDP server on the other side of the world (across the global Internet) working independently of each other (also in a link above).

In addition, I have already combined these two projects into a single Arduino sketch, but when I enable both apps at the same time, there is a "yet to be debugged" (actually, I have debugged for about 30 mins but don't have the answer yet), conflict between the Arduino Serial communications between the two apps.

Basically, there are three Arduino serial comms in this caper (on the Arduino):

The third one (the basic serial monitor) seems to be working fine. However, there is a "conflict" between the first two (the BLE and the NB-IoT serial comms).

When I enable one or the other, it works fine; but when I enable both at the same time, the NB-IoT lib setup() method locks up waiting on the availability of a serial device (in the library code). This leads me to believe there is a "conflict" between the serial comms in the two libs, since they were (obviously) not designed to work together.

So, that is where I stand today on this new project.

I could post the current Arduino "combined" sketch, but I would like to "read up" on Ardunio serial comms first and try another round of debugging before I do.

Why do this project in the first place?

Well, I wanted to do an Arduino project that "no one else has done." I have looked at around a bazillion YT videos (and Internet posts) of Arduino projects, and I'm not currently interested in opening trash cans with sonar or opening relays and turning off/on lights, controlling motors, and all the other "like minded" Arduino projects out there ad infinitum. Don't get me wrong. Those are all nice projects and I respect the makers, all of them. However, I'm inclined to network systems engineering and this project is useful to me, as follows:

Sometimes I want to know the load on a remote server or some other remote server / app statistic. If there is a problem with the Apache2 web server, of course it is hard to get the stats via HTTP because both the monitoring and the applications are in the same band (HTTPD, port 80). Also, when my home network is down (due to a fiber cable cut or some other local or international Internet provider anomaly), I cannot easily check the health of a server on the other side of the world.

So, in comes "out of bounds" remote server management. By using a commercial, wireless NB-IoT network, I can send small command and control messages back and forth between my iPhone and the server as described (and not use HTTPD). This will give me an out-of-bounds comm channel to check on the server even when my main Internet comms are down.

Also, I tend to like these kinds of networking projects more than opening boxes with radar or automatically watering my plants or turning on and off home automation relays or seeing how many 100s of km I can send a "Hello World" LoRa message, etc. Let's see how this networking project goes.

I'll post back after more debugging the serial comms in the libs and see if I can get past my current roadblock.

Stay tuned

Notes:

AltSoftSerial uses these pins on the Arduino UNO, according to AltSoftSerial_Boards.h (included with the AIS NB-IoT libs):

Code:

// Arduino Uno, Duemilanove, LilyPad, etc
//
#elif defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)

 #define ALTSS_USE_TIMER1
 #define INPUT_CAPTURE_PIN               8 // receive
 #define OUTPUT_COMPARE_A_PIN            9 // transmit
 #define OUTPUT_COMPARE_B_PIN           10 // unusable PWM

My BLE module sketch (taken from an ArduinoBlue example sketch) uses pins:

Code:

// The bluetooth tx and rx pins must be supported by software serial.
// Visit https://www.arduino.cc/en/Reference/SoftwareSerial for unsupported pins.
// Bluetooth TX -> Arduino D8
const int BLUETOOTH_TX = 8;
// Bluetooth RX -> Arduino D7
const int BLUETOOTH_RX = 7;

So, not yet more more than an Arduino noob, my first guess is that I should move the Arduino UNO pins for the HM-10 BLE module to some supported SoftwareSerial pins which are different than the AltSoftSerial pins (8,9) above.

Seems the conflict is pin 8 being used by both SoftwareSerial (used in the BLE code) and AltSoftSerial (used in the NB-IoT code).

Will try different pins tomorrow and see how far that get me.

Hi Neo...
I was thinking about this type of event but as I don't have the HW and code then I couldn't comment for certain.
Just one thing though, ensure whichever I/O pin you decide to use, make absolutely sure that it is not used for the two external HW boards at all.

This bit is weapon of last resort, it is possible to use one of the unused analogue inputs as a _digital_ input for RX.
Difficult - YES, probably VERY difficult, but it all depends on the analogue sample speed.

I have done it on my ancient Arduino Diecimila board but speed was not important...


Bazza...

Update:

I have all the serial ports working together now.

The "conflict" was solved by moving the BLE pins from my original ArdunioBlue example sketch from (8,7) to (7,6):

Code:

// The bluetooth tx and rx pins must be supported by software serial.
// Visit https://www.arduino.cc/en/Reference/SoftwareSerial for unsupported pins.
// Bluetooth TX -> Arduino D7 was D8
const int BLUETOOTH_TX = 7;
// Bluetooth RX -> Arduino D6 was D7
const int BLUETOOTH_RX = 6;
SoftwareSerial bluetooth(BLUETOOTH_TX, BLUETOOTH_RX);

So, I've confirmed the NB-IoT shield is sending / receiving data and the BLE app is sending and receiving data:

Code:

23:18:37.770 -> ################################################################
23:18:37.841 -> # Sending Data IP=209.126.XXX.XXX PORT=YYYYY
23:18:37.917 -> # Data=50696e6720436f756e743a203133
23:18:37.917 -> # Send OK
23:18:37.917 -> 
23:18:37.917 -> ################################################################
23:18:37.992 -> # Sending Data IP=209.126.XXX.XXX PORT=YYYYY
23:18:38.066 -> # Data=626c652e73656e736f72203133
23:18:38.104 -> # Send OK
23:18:38.104 -> 
23:18:38.104 -> ################################################################
23:18:38.179 -> # Sending Data IP=209.126.XXX.XXX PORT=YYYYY
23:18:38.215 -> # Data=424c4520427574746f6e2031
23:18:38.253 -> # Send OK
23:18:40.076 -> Button: 5   <------ ArduinoBlue test data from iPhone
23:18:43.679 -> Button: 0   <------ ArduinoBlue test data from iPhone
23:18:48.946 -> Button: 99 <------ ArduinoBlue test data from iPhone

Tomorrow, if all goes according to plan and I get time to work on this, will do the next step in merging these two apps together and see if I can push a button on the iPhone and get the result on the remote Linux server (I'm confident this will be easy now); and then I'll write some mini-apps, like pressing a button on the iPhone and requesting the load averages of the server and pressing another button and getting some other metric like total number of users on the server.

From here, the rest of the coding should be a piece of cake.

More tomorrow.....

PS: One thing I am starting to notice is the lack of programming space (flash memory) on the UNO:

Code:

Sketch uses 20012 bytes (62%) of program storage space. Maximum is 32256 bytes.
Global variables use 1055 bytes (51%) of dynamic memory, leaving 993 bytes for local variables. Maximum is 2048 bytes.

Looks like I'll be moving to the Raspberry PI sooner than later

In an earlier test of the AIS NB-IoT Arduino shield, I touched on the fact that the AIS 923MHz NB-IoT network tested illustrated "not the best reliability" due to spotty 923MHz cell tower penetration / coverage.

However, on the ocean side of my condo, I have improved this reliability issue a few DB (my RF power meter is not very accurate, sorry) with this antenna:



More importantly than potential antenna gain, the 923MHz NB-IoT signal is considerably more reliable after placing the antenna at the window and off my desktop (which is about 3 to 4 meters away from the window).

In addition, I have the Arduino sketch sending the message to a remote Linux server via BLE and the NB-IoT network and will post the code / sketch after I add a mini-app to get some server stats like the server load averages back to the iPhone. Just need to add a few lines of code to my test Python UDP server code and change the sketch to receive the result and display it on the iPhone.

So far, it's pretty simple (after working out the conflict between serial comm pins last yesterday).

More Arduino shield porn

Update:

Well, there seems to be a new serial "conflict" when receiving data from the NB-IoT network with the BLE HT-10 serial comms in place.

The NB-IoT sketch will receive data without issues without the BLE serial comms enabled.

Back to the drawing board ....

Edit: Fixed bug, working now .... will post code after I get the reply displaying on iPhone

Success!

Push a button on the iPhone and send a BLE bluetooth message to the Arduino UNO who forwards the request to a remote server via a commercial NB-IoT network; where the server parses the request and returns the results back to the iPhone via the same NB-IoT / BLE link.

In this case we request the load average of a remote Ubuntu Linux server 'cat /proc/loadavg' 12 times zones away. The remote server runs a Python UDP service "test app" for this "mini application" example.

BLE/NB-IOT/UDP internetworking

I think I may well be the first "maker" to do this with the Arduino UNO, and iPhone, the HM-10 BLE module and an NB-IoT shield and commercial network... but I cannot be sure!





I'm currently testing reliability. Will post the draft Arduino UNO sketch and the Python UDP test server code when finished preliminary testing. Please don't expect a polished product, as this is just a demonstration using the iPhone to send a BLE message to the Ardunio with an NB-IoT shield to forward the request to a remote UDP server and display the results back on the iPhone.

Also, I think I should include a few more "mini-app buttons" for this demo.