Renewable energy (RE) has long been a passion of mine, but practically speaking, it simply hasn’t been cost-effective to implement at a personal level. Factoring in credits, location, type of RE, etc. can often tip the scale, but generally speaking, an investment in RE would require more commitment than simply “running the numbers.” No judgment here, I understand and appreciate both sides of that argument.

In recent years, though, things have changed. Not entirely, and not across the board even now…but with inexpensive (yet quality) RE equipment being produced in the US, China, and many locations throughout Europe, one can begin to experiment with RE on a much smaller scale and determine if/how it makes sense for your particular situation.

As a software engineer, I also work to integrate whatever I build into a more manageable, usable system. Physical computing promises many things, which I’ll coarsely lump into the term “better living” – but to do it right requires more than just assembling some hardware. The intersection of devices with software and the greater internet results in what is often termed the “Internet of Things”, or the IoT…and this is where the potential for “better living” can skyrocket, if things are properly integrated. It’s a small and limited example, but how much more useful is a fully-integrated system that is easily managed from anywhere on the planet than a complex system composed of numerous components…all of which must be monitored individually and manually?

For this post, we’ll focus solely upon one small portion of that integrated system: adding PV, or photovoltaic (solar) panels to a functioning small-scale RE system. Before these additions, the system consisted of:

• Wind turbine
• Deep-cycle battery bank
• Arduino to control sensors, radio transceiver
• Temp/humidity and current/voltage sensors
• Radio transceiver, primarily for comm link to send readings

Now we’re adding a solar charge controller and initially, two 25W solar panels wired in parallel for a total of 50W maximum.

In future posts, I hope to elaborate on the software side because (as stated above) that is where the difference truly lies. For now, here are some pictures (and a very short video) of the PV addition:

Connecting the PV Panel

Mounting the PV Panels to the Backing Board

Initial Two Panels Mounted

Simple Wire Terminals on PV Board

Charge Controller Mounted, Not Yet Connected

Charge Controller Mounted AND Connected!
The “Sun” light indicates power from the panels;
the “Battery” light flashes while charging attached batteries.

And finally, a short video to give a glimpse of the PV portion of the system in action:

In future posts, I plan to provide more information about the “good stuff” (teaser: JavaFX, Java Embedded Suite, more Arduino, BeagleBone Black, wireless management, and more!), but a system must exist before it can be monitored and managed. As we continue to “build out” the system, those opportunities will only increase. Stay tuned, and please feel free to comment below or drop me a line. Thanks for visiting!

All the best,
Mark

Related Posts:

• Building a Portable, Self-powering, Cloud-Connected IoT demo
• Join Us at JavaOne 2014!
• Quick & Dirty How-to Guide: Install GlassFish 4 on Raspberry Pi
• Nighthacking Interview: Jfokus
• Spring Boot for IoT Developers: Getting Started

orapki wallet pkcs12_to_jks -wallet <wallet_directory> -pwd <wallet_password> -jksKeyStoreLoc <java_key_store_path_and_filename> -jksKeyStorepwd <jks_password>

Related Posts:

• Why PGP? How PGP?
• Getting up & running quickly with Spring Cloud Sleuth
• Spring Tip: Request header filtering in @RequestMapping
• Spring Tip: Spring Boot Actuator /actuator endpoint
• Building a Portable, Self-powering, Cloud-Connected IoT demo

Cross-posted from The Java Jungle by Mark

I recently had the opportunity to spin up a small web application using JSF and MySQL. Having developed JSF apps with Oracle Database back-ends before and possessing some small familiarity with MySQL (sans JSF), I thought this would be a cakewalk. Things did go pretty smoothly…but there was one little “gotcha” that took more time than the few seconds it really warranted.

The Problem

Every DBMS has its own way of automatically generating primary keys, and each has its pros and cons. For the Oracle Database, you use a sequence and point your Java classes to it using annotations that look something like this:

@GeneratedValue(strategy=GenerationType.SEQUENCE, generator=”POC_ID_SEQ”)
@SequenceGenerator(name=”POC_ID_SEQ”, sequenceName=”POC_ID_SEQ”, allocationSize=1)

Between creating the actual sequence in the database and making sure you have your annotations right (watch those typos!), it seems a bit cumbersome. But it typically “just works”, without fuss.

Enter MySQL. Designating an integer-based field as PRIMARY KEY and using the keyword AUTO_INCREMENT makes the same task seem much simpler. And it is, mostly. But while NetBeans cranks out a superb “first cut” for a basic JSF CRUD app, there are a couple of small things you’ll need to bring to the mix in order to be able to actually (C)reate records. The (RUD) performs fine out of the gate.

The Solution

Omitting all design considerations and activity (!), here is the basic sequence of events I followed to create, then resolve, the JSF/MySQL “Primary Key Perfect Storm”:

1. Fire up NetBeans.
2. Create JSF project.
3. Create Entity Classes from Database.
4. Create JSF Pages from Entity Classes.
5. Test run. Try to create record and hit error.

It’s a simple fix, but one that was fun to find in its completeness. 🙂 Even though you’ve told it what to do for a primary key, a MySQL table requires a gentle nudge to actually generate that new key value. Two things are needed to make the magic happen.

First, you need to ensure the following annotation is in place in your Java entity classes:

@GeneratedValue(strategy = GenerationType.IDENTITY)

All well and good, but the real key is this: in your controller class(es), you’ll have a create() function that looks something like this, minus the comment line and the setId() call in bold red type:

    public String create() {
        try {
            // Assign 0 to ID for MySQL to properly auto_increment the primary key.
            current.setId(0);
            getFacade().create(current);
            JsfUtil.addSuccessMessage(ResourceBundle.getBundle(“/Bundle”).getString(“CategoryCreated”));
            return prepareCreate();
        } catch (Exception e) {
            JsfUtil.addErrorMessage(e, ResourceBundle.getBundle(“/Bundle”).getString(“PersistenceErrorOccured”));
            return null;
        }
    }

Setting the current object’s primary key attribute to zero (0) prior to saving it tells MySQL to get the next available value and assign it to that record’s key field. Short and simple…but not inherently obvious if you’ve never used that particular combination of NetBeans/JSF/MySQL before. Hope this helps!

All the best,
Mark

Related Posts:

• Getting up & running quickly with Spring Cloud Sleuth
• Spring Tip: Request header filtering in @RequestMapping
• Spring Tip: Spring Boot Actuator /actuator endpoint
• Building a Portable, Self-powering, Cloud-Connected IoT demo
• Nighthacking Interview: Jfokus