LG201: IoT Prototype Development - The How & What of It

Areas of Development and their Iterations

The various areas of development in this module require different skillsets, those areas also reflect the learning outcomes. As some require the completion of others, it makes sense to iterate them separately and reiterate and test where one has the potential to affect the others…

Here is my starting point based on my requirements:

• Electronic Circuits
  • Specify Components – Based on the requirements outlined above research and specify the required component to create the electronic circuit.
  • Breadboard Prototype – Push the required modules and some jumper wires into the board, plug the microcontroller into the USB port of your laptop and read what’s happening on the Serial Monitor.
  • Perma-Prototype – A Breadboard you can shake… Solder the modules from the Breadboard onto this PCB with the same form factor, add sockets for the breakout boards and this will give us an idea how much space we need inside our case.
  • Custom PCB – Once we’ve decided which interfaces and pins to expose in 2b above, we can take our Breadboard diagram in Fritzing and use it to create Custom PCBs. We will explore CNC milling and online PCB fabrication services.
  • Sensor Module – Now we have a versatile prototyping thing, let’s test it’s modular capabilities by creating our first sensor breakout. We are going to need some data to send to the internet.
• Digital Fabrication
  • Software Evaluation – Learn how to use the required software and establish what the required outputs are for digital fabrication. Use my experience in 2D vector software to start creating 3D Solids. Use Parametric Modelling to ensure we keep track of that extra axis of data.
  • Proof of Concept – Digital Fabrications equivalent of programming’s “Hello, World!”. A box that securely holds the required components, a starting point… This might not be pretty, but something to reflect and learn from.
  • Modular Case – No doubt learning from our Proof of Concept, let’s make this device as versatile as possible. We’ll need to swap out controllers and sensors, and we don’t want to be starting from scratch each time we do so. Permanent core components and modular breakouts for sensors and displays seems to make sense.
  • Design Guide – Form is as important as function, it gives consumers confidence, what could be more important as we explore new relationships between people and devices?
  • Final Prototype – Using our design guide and concentrating on post-processing, can we create a final prototype that looks great, that fill potential investors with confidence. What tools should we add to our arsenal to ensure this is achievable in the future?
• Embedded Programming
  • Test Functionality – Writing the results of inputs and outputs to the Serial Interface enables us to keep track of our programme and test our circuit. Once we’re online we can extend this logging to the Web Sockets interface too.
  • Multi-Mode Functionality – To get a headless device online we need to be able to put it into set-up mode and let the user know we have done so. A button and an LED are all we need.
  • Internet Connection – We don’t want to hard-code the network details or we have to upload a new sketch every time we change location. EEPROM or SPIFFS will enable us to save and update set-up details.
  • Sensor Module – Let’s read some sensor data and send it to the web every time a reading changes. Web Sockets over SSL seems like a sensible place to start.
• IoT Capabilities
  • Embedded Webpages – Enable device set-up and troubleshooting with some simple webpages uploaded to SPIFFS and hosted on the Microcontroller.
  • Web Socket Server – A simple echo function that sends any received message to all connected devices, will enable us to demonstrate the device is online. We will create this in .Net Core and host on Azure as that’s my preferred server-side stack.
  • Sensor Module – A webpage that displays the sensor data from the device, a JavaScript socket-client and some simple HTML and CSS.