Or “How to build a portable self-powered, self-licking ice cream cone.”  😀

Several years ago, I started building what I referred to affectionately as a self-licking ice cream cone: a Renewable Energy (RE) system that powered the same IoT system that monitored it. I’ve given several talks about this system, both its hardware and its software stack, and there are so many useful (and scalable) lessons I’ve learned that I really enjoy sharing. Still learning those lessons too, btw.

Recently, Stephen Chin asked me if I could put together a portable RE IoT system to demo in the MakerZone at JavaOne this year. If a picture is worth a thousand words, a fully-built and on-premises demo must be worth at least a million, right? The idea intrigued me. Could I create a 100% fully-capable representation of a (my) real working system that would be small enough to transport to conferences and meaningful for attendees to see? Yes…yes, I thought I could.  🙂

It has been a lot of work fun!

There is much to tell, but we’ll stick to the high points for this post. More to follow.

Hardware List and Related Observations

For the portable configuration, here is the hardware I used:

• One (1) 50W, 12V photovoltaic (PV) panel, bought via ebay
• One (1) Cyber 250 wind turbine
• One (1) 18Ah 12V deep cycle battery for energy storage and IoT system power
• One (1) sheet of Lexan cut to size and edged, courtesy of Regal Plastics in St. Louis
• One (1) Raspberry Pi, case, SD card, & wifi plug adapter – this serves as the IoT gateway device
• One (1) 5V DC voltage regulator, allowing me to step down the 12V battery output to the 5V required by the Pi
• One (1) Arduino Uno R3, solderless breadboard, combined mounting board – this represents an IoT endpoint
• One (1) Adafruit INA219 high-side DC current sensor breakout
• One (1) Virtuabotix DHT11 temperature & humidity sensor
• One (1) 4 channel DC 5V relay to control physical devices
• One (1) LED case cooling fan
• One (1) interior/dome light to represent building interior lighting
• Two (2) running lights to serve as loads for two RE inputs/charge controllers
• Two (2) solar charge controllers**
• One (1) 12 position terminal strip/wiring block
• Numerous (?) solder joints, wires, and cables

** I was able to use solar charge controllers for both solar/PV and wind inputs because the wind turbine I selected produces 12V DC power (vs. the AC power output of many turbines) and has a blocking diode to prevent overspeeding, and thus turbine damage. These charge controllers also have load connectors, to which I attached lamps to maintain loads on the inputs, further reducing potential for overspeeding.

This configuration closely follows my permanent installation at my house, albeit at a much smaller scale. For transportability, I’m using only a single 18Ah 12V deep cycle battery instead of several larger-capacity 12V deep cycle batteries wired in parallel to form an energy storage array. And input sensors have been reduced from a full weather station providing temperature, humidity, rainfall, wind speed & direction, ambient lighting, and atmospheric pressure readings to (for the demo system) temperature and humidity. Power readings are comparable for both systems, although I’m using a separate INA219 sensor on the demo system vs. integrated power sensors in the permanent system’s weather circuitry. And my portable system has no actuators to open windows in my power-generation building like my permanent system does. Since the demo system is fully visible to viewers, there was no need to configure a camera for visual observation/checks as I did at home. In actuality, there are few substantive differences between my 24/7/365 production system and this portable demo. 🙂

One nice feature of this portable rig: as configured, it produces far more energy than it consumes, even with a fan providing the “wind” and venue lighting providing the “sun”. Power won’t be a problem.

Software and Related Observations

The software stack for the demo system is nearly identical to that of the production system, with minor changes being made to accommodate the minor differences in attached sensors and physical devices.

I developed software for the Arduino microcontroller to run in Autonomous Mode using sensible defaults, turning on heat when ambient temperature inside the power-generation building is too low, turning on a cooling fan when it’s too hot, and opening windows on opposite sides of the building when temps climb and no rain is present (no windows in the demo config, of course). The Arduino represents an IoT endpoint that regularly (1x/second) polls attached sensors, assembles their readings, and sends them “upstream” to the IoT gateway. It also processes any inputs received from the gateway and acts accordingly; if it receives a command to switch to Manual Override, the software then accepts and processes any subsequent (validated) commands from the gateway until directed to resume with Autonomous Mode.

For the IoT gateway, I used Linux and Java SE Embedded to create a secure and standards-based stack. Raspbian Linux allows me to use utilities like ssh and vnc and to set up startup scripts for the demo config…and since it ships with Java SE Embedded, I have easy access to developer tool support and libraries for everything from RESTful web services to Websocket, which I use for system/cloud communication. I used the JSSC (Java Simple Serial Connector) library to create a wired connection from gateway to endpoint, Pi to Arduino, establishing a reliable comm link within the remote IoT system.

IoT systems are great! But without a way to communicate with, control, and harvest meaningful data from those systems, their usefulness is severely constrained. To unleash the full value of an IoT system, you need the cloud. I used Java SE, Spring Boot, and Spring Cloud OSS to do the heavy lifting with an HTML5/JS user interface, all running on Pivotal Cloud Foundry. I’m still tweaking and expanding it (in my copious spare time 😉 ), but it’s effectively feature-complete…and with only minor differences (to accommodate the sensor/device differences) between the permanent and demo systems.

And…action!

More to Come

Come see me at JavaOne! This will be up and running in the MakerZone all week, so stop by to see it and chat with the crew there. If you have any questions, comments, or feedback of any kind, please ping me on Twitter at @MkHeck or leave a comment below. Hope to see you there!

Keep coding,
Mark

Related Posts:

• Nighthacking Interview: Jfokus
• Spring Boot for IoT Developers: Getting Started
• Adding Solar/PV to A MANAGEABLE Renewable Energy System
• Quick & Dirty How-to Guide: Install GlassFish 4 on Raspberry Pi
• Getting up & running quickly with Spring Cloud Sleuth

At Jfokus this week, I was honored to be interviewed by Stephen Chin of Nighthacking.com. We discussed the Renewable Energy system I built and developed using industrial Internet of Things (IoT) concepts and Domain Driven Design principles. The core of the system is Java SE Embedded on the IoT Gateway device, Spring Boot + Cloud Foundry (CF) for the backend services, and an HTML5/JavaScript frontend application also delivered via CF…all accessible from any device, anywhere in the world. I was pushing code and controlling operations in St. Louis from Stockholm, Sweden – smoothly and speedily.  🙂

Anyway, here is the video. Hope you enjoy it!

Keep coding,
Mark

Related Posts:

• Building a Portable, Self-powering, Cloud-Connected IoT demo
• Spring Boot for IoT Developers: Getting Started
• How to Create an Alexa Skill with Spring Boot & Cloud Foundry
• Join Us at JavaOne 2014!
• Adding Solar/PV to A MANAGEABLE Renewable Energy System

It often surprises other devs when I suggest that Spring Boot is a perfect addition to the IoT developer’s toolbox. If you’re deep into IoT and have the luxury of another group providing all of your back-end and/or cloud platform code, that’s perfectly understandable. However, if you’re a full-stack developer, by choice or necessity, you need to know this! Grab a chair and a cup of coffee; I think you’ll find this interesting (and useful).

Let Me Just Put This Out There

Here is what most people imagine when they hear “IoT”:

Internet of THINGS

But this is what they should be thinking:

INTERNET of Things

The things get most of the attention, mindshare, and “buzz”. Why is that? Well…because gadgets are cool! Most of us chose to be developers because of the fun/interesting/obsessive parts, not because of the dull bits. And while there are usually fun and (ahem) less-fun components to everything, who can resist gadgetry in general?

Ah, but without connectivity, without storage, without the ability to monitor, manage, and analyze those often-remote sensors and controls…what do we have? Truthfully, not much. Something interesting, but barely so; a school science project, perhaps. The real payoff (in money and intrigue) is in what happens when you connect those “things”. Without a versatile and reliable platform behind those devices, you just have islands of misfit toys.

This is where Spring Boot really shines: helping you to create meaningful software at velocity. Software that is clean, concise, readable, maintainable…and built Cloud Native. We’ll come back to that last part over the next few installments, but for now, let’s focus upon building a basic platform to enable your IoT to mean something.

Choose Your Legos(TM)

Spring Boot integrates several useful capabilities into a single, coherent code framework and approach. In a nutshell, it helps a developer rapidly build stand-alone applications that incorporate and integrate with various third-party libraries that can be deployed anywhere a JAR will run. Anywhere. It’s open source, opinionated (minimal configuration, but flexible to fully accommodate edge cases), and insanely effective. Coming from a more staid environment, I found my first exposure to Spring Boot (and every one since) surprising and refreshing. If so-called enterprise software development sounds boring to you, you probably haven’t taken Boot for a test drive.

And that’s it! Kidding, that’s not it. But Spring Boot does bring along several goodies that streamline the effort it takes to build robust back end applications. Remember how I said it’s “opinionated”? Let’s examine a few of its carefully-chosen opinions, step through building a simple cloud-ready application for your IoT system, and then see where that takes us. Shall we?

On Your Mark, Get Set, Go!

The Spring Initializr gets our project off to a running start. There are several ways to accomplish this, but since we’re taking the simplest path possible for this first example, let’s just point our browsers to start.spring.io. Spring Boot gives you options, such as a Gradle-based build, various versions of Boot, Java/Groovy, and packaging (JAR vs. WAR), but we’ll stick to most of the defaults for our example.

NOTE: To see all of the choices at your disposal, simply click the “Switch to the full version.” link at the bottom of the page.

Here are the choices we’ll make for our example:

• Maven Project
• Latest non-snapshot version of Spring Boot
• Group: org.thehecklers (feel free to use your own)
• Artifact: iot-service
• Dependencies: Web, JPA*, H2**, REST Repositories

* For this example, we’ll use a JPA data source, but feel free to choose a NoSQL option. Boot gives you many data source options out of the box, and of course, you can “bring your own” with a bit more effort.
** H2 is an in-memory database. While unsuitable for environments in which physical persistence is a requirement, it functions the same from a developer perspective and satisfies our demo requirements nicely for now.

Once we’ve made the above selections, simply click the Generate Project button to have the Spring Initializr generate a skeleton project, bundle it into a .zip file, and serve it up for download. Save it locally, unzip it, and open the project in your favorite IDE to get started coding.

Building your IoT Service

With just that little bit of effort, we already have the foundation in place for our IoT back end service. You can verify this by running the app and pointing your browser to localhost:8080. You should see the following:

“Large streams from little fountains flow, Tall oaks from little acorns grow.”

For this installment, we’ll focus on the MVP (Minimum Viable Product) needed to support our nascent IoT installation. Assuming we’ll need to track readings captured by one or more sensors, let’s define an Entity class for our Readings:

The annotations @Entity, @Id, and @GeneratedValue are from the Java Persistence API (JPA) standard and identify/describe the class and its Id attribute as a JPA entity and its primary key, respectively. Aside from these annotations, the Reading class is just a straightforward POJO.

Next, we face the daunting task of creating the following functionality:

• REST endpoint(s) via which our devices can provide (POST) readings
• REST endpoint(s) allowing us to retrieve (GET) readings for review, reporting, and analysis
• Mechanism(s) for storage and retrieval of readings from our chosen data store

Spring makes this functionality easy to implement. Spring Data REST was one of the dependencies we included when we created this project (REST Repositories), and by simply extending a Spring Data repository interface specifying the Reading class and Id type and annotating our new interface as a RepositoryRestResource, the repository is exposed via a REST API. For now, this meets our needs nicely:

Re-running our application and refreshing our browser page (localhost:8080) confirms that our REST endpoint for readings is now active:

Getting there…

Next, let’s test functionality by emulating a device pushing readings to our IoT service. I used curl, but feel free to use whatever means you prefer to POST to a REST endpoint.

Then we verify using a vanilla curl GET:

Here we see the two readings I created in testing, returned via our GET request:

If you’ve been pair-programming with me, congratulations! You have now created your first very basic IoT service…and since we had Spring Boot build a fully self-contained “uberJAR” (bringing its own container with it), it can be deployed wherever Java is installed. Who would have thought it could be this fast (or fun)?!?

Future Articles, Future Enhancements

As we proceed, there are several topics we will expand upon, options/adjustments we will explore (WebSocket, SQL & NoSQL persistence, …), functionality we can add (security, tailored queries, visualizations, …), and of course, we’ll leverage Spring Boot’s focus upon Cloud Native Java to deploy quickly and easily to the leading open source cloud platform, Cloud Foundry. If you have comments, questions, or suggestions, please leave them below! For updates, please follow me on Twitter at @MkHeck.

Keep coding,
Mark

Additional Information

Spring Initializr
Spring Boot
Spring Data REST
Spring Getting Started Guides
Cloud Foundry
Pivotal Cloud Foundry
Pivotal Web Services (for free trial)

Related Posts:

• Building a Portable, Self-powering, Cloud-Connected IoT demo
• Nighthacking Interview: Jfokus
• T4SD (Tips 4 Spring Devs): How to get Spring Boot REST endpoints to speak XML
• How to Create an Alexa Skill with Spring Boot & Cloud Foundry
• Getting up & running quickly with Spring Cloud Sleuth

There are some absolutely SUPERB conferences dedicated to Java (the language, the platform, the ecosystem) around the world, and I’ve been privileged to speak at some of them. No two are alike, and that is a good thing! JavaOne San Francisco holds a very special place in that lineup, bringing together a phenomenal mixture of vision, direction, community leadership, and grassroots innovation that is nearly impossible to describe. You just have to be there!

This year I’m pleased and honored to be presenting in three sessions, sharing the stage with some of my favorite people from around the world: Jim Weaver, Sean Phillips, David Heffelfinger, Geertjan Wielenga, Jens Deters, José Pereda, and James Gosling. As I said, it’s a genuine honor!

Here are the sessions in which I’ll be taking part:

Creating Our Robot Overlords: Autonomous Drone Development with Java and the Internet of Things [CON1863]
Tuesday, Sep 30, 2:30 PM – 3:30 PM – Hilton – Continental Ballroom 4

Who wants a mindless drone? Teach it to “think,” and it can do so much more. But how do you take it from Toy Story to Terminator? This session’s speakers discuss their new open source library, Autonomous4j, for autonomous drone development. Combining this library and some components from their mad science toolkit, they demonstrate how to get your Internet of Things off the ground and do some real cloud computing. In the session, you’ll learn how to write an autonomous drone program with Java 8; deploy it to the drone’s “positronic brain,” an onboard Raspberry Pi; have the Pi guide an AR.Drone to accomplish a task; monitor it via a JavaFX console; and create your own robot overlord. Demos are included: you’ve been warned!

With Jim Weaver & Sean Phillips

Debugging and Profiling Robots with James Gosling [CON6699]
Wednesday, Oct 1, 1:00 PM – 2:00 PM – Hilton – Continental Ballroom 4

James Gosling recently stated that “being able to debug and profile robots out at sea is a truly life-altering experience.” He uses a set of tools—consisting of editors, debuggers, and profilers—that are part of the NetBeans IDE. In this session, Gosling and other speakers introduce you to these tools and show you how easily and quickly you can program and interact with devices via Java tools. Come see how well integrated embedded devices are with the Java ecosystem.

With Geertjan Wielenga, Jens Deters, José Pereda, & James Gosling

Java Platform, Enterprise Edition Lab 101: An Introduction [HOL1827]
Wednesday, Oct 1, 10:00 AM – 12:00 PM – Hilton – Franciscan A/B

For anyone familiar with the Java language but without direct Java Platform, Enterprise Edition (Java EE) experience, the capabilities and APIs in Java EE can seem daunting. Documentation is helpful, and well-written books can make it easier to come up to speed, but isn’t the best way to learn something to actually do it? This session’s speakers hope to smooth the path for anyone curious about Java EE by offering a gentle, yet useful, introduction to four key concepts:

• JavaServer Faces (JSF)
• Contexts and Dependency Injection (CDI)
• Java Persistence API (JPA)
• Enterprise JavaBeans (EJB)

Using NetBeans and the bundled GlassFish application server, the speakers present each new concept with live code and then help attendees complete hands-on exercises.

With David Heffelfinger (and gracious assistance from Sven Reimers, Josh Juneau, Bob Larsen, & Bruno Borges)

I’ve said it before: There’s no better place to see what’s happening in the world of Java than JavaOne. Hope to see you there!

All the best,
Mark

Cross-posted from The Java Jungle.

Related Posts:

• Adding Solar/PV to A MANAGEABLE Renewable Energy System
• Nighthacking Interview: Jfokus
• Quick & Dirty How-to Guide: Install GlassFish 4 on Raspberry Pi
• Building a Portable, Self-powering, Cloud-Connected IoT demo
• Thanks For Sharing Informal International HackFest – A Virtual Event!

I’ve been testing various “embedded platforms” lately to provide infrastructure for my IoT configurations. In doing so, I’ve installed and configured the GlassFish 4 Web Profile to run successfully on the Raspberry Pi Model B (512M). This post is not meant to be exhaustive or even necessarily prescriptive, but rather an iterative log of what I’ve done and do to configure a Raspberry Pi to “run with the big dogs”, i.e. Java Enterprise Edition (EE) 7.

Please check back (or subscribe to my RSS feed for IoT) to monitor updates. The Internet of Things (IoT) is a very dynamic space and will likely remain so for some time! The only constant…is change.  😀

Document version 1.3 (This number will change as I make updates and is for reference only)

Steps to Install/Configure GlassFish 4 on the Raspberry Pi

1. Download the latest version of Raspbian Wheezy from here. You can install NOOBS, Arch, or some other distro, but I chose Raspbian. Note that this distro includes the Java SE 7 JDK, which simplifies things a bit. If you wish to use an previous Raspbian build that doesn’t already include the JDK, simply run “sudo apt-get update && sudo apt-get install oracle-java7-jdk” from your Pi shell.
2. Make a bootable SD card by doing the following (on my Mac; Windows steps will vary a bit):
   1. Unzip/decompress the downloaded image from step 1
   2. Open a Mac terminal window
   3. Run “diskutil list” to see drives
   4. Plug SD card into SD card slot
   5. Again run “diskutil list” to see drives, now including the SD card
   6. Run “sudo diskutil unmountDisk /dev/diskn“, where n is the disk number of the SD card (as reported by diskutil)
   7. Issue the following command, being very careful to ensure the of= parameter points to the SD card! If not, you can overwrite something you’d rather not…like your boot drive: “sudo dd if=<path/name_of_Raspbian_image.img> of=/dev/diskn bs=1m”
   8. Once dd completes, issue “diskutil eject /dev/diskn” to eject the SD card
3. Plug the SD card into the Pi, plug ethernet cable and power into the Pi to boot.
4. At this point, you’ll need to determine current (dynamic) IP address of the Pi. I plugged in my Atrix Lapdock and did this “on the Pi”, but you can also use nmap or connect it to HDMI (TV) and USB keyboard.
5. Run “sudo raspi-config” and set the following:
   1. Expand the file system to take the entire SD card (not just what the image initially does)
   2. Under Internationalisation Options, change Locale, Timezone, & Keyboard layout as desired
   3. Overclock to High (950MHz). I’ve tried Turbo, but it seems prone to flakiness & data loss…at least for me.
   4. Under Advanced Options, change Hostname to desired Pi name, Memory Split to 16 (as a server, we can skinny the GPU memory allocation to maximize “main” memory), and enable SSH. You can also “Update this tool” (raspi-config) to the latest version, never a bad thing.
   5. Select “Finish” to reboot the Pi & use the new settings
6. Ensure the Pi has a static IP by doing the following (recommended for any server):
   1. Run “ifconfig -a” and “netstat -nr” on the Pi to gather the following information: current IP (if you want to keep it), netmask, gateway, destination, and broadcast. Jot these down.
   2. Make a backup of /etc/network/interfaces by running “sudo cp /etc/network/interfaces /etc/network/interfaces.orig
   3. Modify the interfaces file. I used vi, but use whatever editor you can & are comfortable with! The vi syntax is “sudo vi /etc/network/interfaces”
   4. Change the line that reads “iface eth0 inet dhcp” to “iface eth0 inet static” and add the following lines:
      • address 192.168.1.nnn (this is the IP address you want the Pi to have & keep)
      • netmask 255.255.255.0 (or whatever was shown in ifconfig -a above)
      • network 192.168.1.0 (or whatever was in the destination column, 2nd line from netstat -nr above)
      • broadcast 192.168.1.255 (as shown in ifconfig -a)
      • gateway 192.168.1.1 (or what was shown in either ifconfig or netstat)
   5. Save the file
   6. Reboot the Pi (“sudo reboot”)
   7. NOTE: You’ll also need to tell your network DHCP device/router that the IP address you statically assigned to the Pi is off-limits for assigning to another device
7. Download GlassFish 4 Web Profile (or full EE platform) from here. I chose the Zip installer.
8. Copy the GlassFish .zip file to the Pi (“scp glassfish-4.0-web.zip pi@raspi:.”). I have an entry in my Mac’s /etc/hosts that points “raspi” to the Pi’s static IP address.
9. On the Pi, “install” GlassFish by doing the following:
   1. Run “sudo mkdir -p /app/glassfish” to create GlassFish app parent directory
   2. Run “sudo chown pi /app/glassfish” to assign directory ownership to the pi user. Not absolutely necessary, but you typically don’t want root to own everything (although honestly at this stage & for this install, it’s not critical)
   3. “cd /app/glassfish” as the pi user to change directories into the “install” directory
   4. Run “unzip ~/glassfish-4.0-web.zip” to extract the GF files into this directory
10. Now to configure GF to allow for remote administration/configuration using its web console app:
    1. “cd /app/glassfish/glassfish4/bin”
    2. Run “./asadmin change-admin-password --user admin” to assign a password to the admin user. The admin password defaults to a blank password, a no-no for GF remote admin.
    3. Run “./asadmin start-domain” to start the default domain (which comes preconfigured in GF)
    4. Run “./asadmin enable-secure-admin” to enable remote administration using the web console
    5. In order to take utilize remote admin, stop the domain by running “./asadmin stop-domain”, then…
    6. Start the domain once more with “./asadmin start-domain”
11. From your workstation/laptop, plug this into a browser address bar: “raspi:4848” (substituting the name of your Pi per your /etc/hosts file) or “192.168.1.n:4848″ (substituting the IP address or your Pi) to load the GF admin console
12. Login and relish the fact that you now have a full Java EE 7 stack (or web profile) running on your Raspberry Pi server!

I’m capturing this from memory, so it’s possible I’ve missed a step I performed or have related it not-exactly-perfectly…but if you spot something that isn’t quite right or have questions, please let me know! I’ll update this document accordingly. YMMV (Your Mileage May Vary), especially if you’re using a Linux or Windows machine for your workstation, but hopefully, this will get you that much closer to your own tiny Java EE 7 stack for your own growing IoT empire.

All the best,
Mark

P.S. – Follow me on Twitter at @MkHeck for more Java/IoT adventures…yours and mine (and ours)!

Related Posts:

• Building a Portable, Self-powering, Cloud-Connected IoT demo
• Adding Solar/PV to A MANAGEABLE Renewable Energy System
• Join Us at JavaOne 2014!
• Nighthacking Interview: Jfokus
• Spring Boot for IoT Developers: Getting Started