thomascoope:
Hmmm. I'm in a bit over my head here. I need to do some further learning on the new elements that you've presented to me which is going to take some time.
Take a look at the following piece of code:
void setup() {
Serial.begin(115200);
sayHello("Thomas"); // function call to sayHello
}
void loop() {}
void sayHello(const char *name) { // function definition for sayHello
Serial.printf("Hello, %s\r\n", name);
}
The compiler runs through this piece of code from top to bottom. In the setup, it encounters a call to the sayHello function. However, the compiler doesn't know that this function exists, because it is defined further down the page.
It will say something like: error: ‘sayHello’ was not declared in this scope.
To solve this, you add a function prototype for sayHello, before it is called for the first time. A function prototype tells the compiler that the function exists, and that is defined somewhere else. It also needs to tell it what the data types of the parameters are, and what data type it returns. As PaulS mentioned, you don't have to specify the name of the parameters, but it's often done to make it more readable for programmers (just like the compiler, most humans read from top to bottom as well, so encounter the function prototype before the function definition).
A function prototype is basically a declaration for a function.
The following piece of code compiles without problems, because sayHello is declared before it is called, using a prototype.
void sayHello(const char *); // function prototype for sayHello (function declaration)
void setup() {
Serial.begin(115200);
sayHello("Thomas"); // function call to sayHello
}
void loop() {}
void sayHello(const char *name) { // function definition for sayHello
Serial.printf("Hello, %s\r\n", name);
}
Note:
void sayHello(const char *name); // function prototype for sayHello (function declaration)
void sayHello(const char *foobar); // function prototype for sayHello (function declaration)
are both valid prototypes as well.
thomascoope:
I understand that going from WiFiClient to WiFiClientSecure is supposed to be relatively straightforward.
Yes, just remember that HTTPS uses port 443, and HTTP uses port 80. You should also check the fingerprint of the servers TLS/SSL certificate.
thomascoope:
I was successfully making REST Posts over http using this: https://github.com/pantri/A-Bit-Pushy/blob/3142657b7cde1693c64169b8fc03054e632ba9c9/pb01_sketch/pb01b_httpPost.inoWas this & the methods of stringing together the elements to form the POST an incorrect way of doing it in the first place?
The first method was correct, but inefficient. Strcat has to go to the entire buffer to find the end of the string every time you make a new request, and you create the MAC address string on every request as well. You can just do that once in the setup, the MAC address doesn't change while the program is running.
There's no need to fit everything in a single buffer, since you can use client.print() multiple times with different parts of the request string, no need to concatenate.
Using Strings can cause memory fragmentation in the long run, so are usually not recommended.
There is just no need for Strings here, you can use (static) char arrays combined with a single char buffer for the variable objectID. If you use preprocessor defines for the URI and host, it will be concatenated to the static char arrays at compile time, without causing overhead or memory problems at run time.
Pieter