]]>]]>
The stepper motor is controlled by pulsing the GPIO pins from LOW to HIGH states in a sequence that causes the motor to spin. Each time a GPIO pin state is HIGH an electromagnet is engaged inside the stepper motor to cause a rotational force on the center rotor. With the proper sequence and timing you achieve motor rotation.
Here is a fantastic article with photos and illustrations to help learn more about stepper motors and stepping techniquest:
http://www.lirtex.com/robotics/stepper-motor-controller-circuit/
Below are photos of the assembled board and attached stepper motor.
;)
;)
;)
;)
;)
This breakout board includes two ports for controlling two separate stepper motors.
;)
You can purchase an additional stepper motor to use on the second port here:
The two stepper motor controllers are mapped to GPIO pins on the Raspberry Pi's P1 header as depicted in the diagram below. The GPIO numbering in the diagrams below is based on the WiringPi / Pi4J numbering scheme. See below for a mapping chart for other numbering schemes.
;)
Below is a cross reference chart to better help define the GPIO pin numbers used under the various pin numbering schemes.
;)
A jumper is provided on the board to supply 5 VDC to the stepper motors directly from the 5 VDC output from the Raspberry Pi. If you would prefer to provide 5 VDC from an external power supply, please remove the jumper from JP1 and connect your power source to JP1 pins 2 and 3. See the diagrams below.
;)
Make sure that you place the jumper between pins 1 and 2.
ATTENTION !
Never attach JP1 pins 1 and 3 together as this will cause a direct short on the 5 VDC power line from the Raspberry Pi. This would likely render the Pi defective.
Below is a sample Java program for controlling the stepper motor. The Pi4J project now includes a new stepper motor interface and component implementation for GPIO based stepper motors. This makes it really simple to control a stepper motor from Java. (Note that the stepper motor implementation is available in 0.0.5 and later versions of Pi4J.)
The source for this example is provided with the Pi4J installation package and can also be found on Github:
This was my first time working with a stepper motor and having this kit certainly made it much easier to understand and get started. For me the timing was the trickiest thing to get right. Fortunately with a little trial and error I was able to get it working. Here is a quick video demonstrating the final working project.
Happy New Year!
;)
The Airlink 101 Wireless N 150 Ultra Mini-USB Adapter is another low-cost wireless network adapter for use with the Raspberry Pi. Here is what this little adapter has going for it:
(Click photo to enlarge.)
;)
;)
;)
;)
(Click image to enlarge.)
;)
;)
The latest Raspian distribution (Raspbian “wheezy” 2012-12-16) already includes the drivers for this adapter pre-installed. This greatly simplifies the installation. (If you are using a different distribution or an older distribution you may have to install the Linux driver for the Realtek RTL8192CU driver.)
Insert the Airlink 101 USB adapter into your Raspberry Pi's USB port. Next, lets make sure that the Raspberry Pi recognizes the device. Use the following command to verify that the Pi "sees" the Airlink 101 WiFi adapter.
lsusb
You should see the RealTek RTL8188CUS 802.11n WLAN Adapter device listed in the output. This is the chipset used by the Airlink 101 adapter.
Now that we have verified that the Airlink 101 adapter is recognized, lets check to make sure the kernel driver is loaded. Use the following command to list the kernel modules:
lsmod
You should see the "8192cu" kernel module loaded. If not, try removing and re-inserting the Airlink 101 USB adapter.
As a final validation check to make sure that the Airlink 101 adapter is ready to use, send the "iwconfig" command to display a listing of the current wireless network configuration.
iwconfig
We are just looking to ensure that the "wlan0" adapter is present.
Now we are ready to move on to the configuration steps.
One you have installed the adapter, verified the kernel driver is loaded, and confirmed that a wireless network interface ("wlan0") is available, you will need to configure the wireless connection settings to securely connect to your wireless network.
First, let's open the network interfaces configuration file for editing using the following command:
sudo nano /etc/network/interfaces
Make sure the following lines are added to (or un-commented in) your file
auto wlan0 allow-hotplug wlan0
iface wlan0 inet manual wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
After modifying the network interface configuration file, we need to create the wireless configuration file. Use the following command to create (or edit) this file.
sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
Add the following data to this wireless configuration file. (Replace the "_SSID_" and "_WPA_SHARED_KEY_" text with your actual SSID and WPA key values.)
network={
ssid="_SSID_"
proto=RSN
key_mgmt=WPA-PSK
pairwise=CCMP TKIP
group=CCMP TKIP
psk="_WPA_SHARED_KEY_"
}
(Note: This configuration is intended for WPA protected wireless networks.)
Once the configuration files are complete, use the following command to restart the wireless adapter / interface.
sudo ifup wlan0
This command will restart the network interface and use the newly defined interface and wireless settings to establish a wireless network connection. Assuming the configuration is correct, the wlan0 interface should connect and acquire an IP address.
For connection verification and an alternate way to see your assigned IP address, use the following command to list the network configuration:
ifconfig wlan0
If you have any trouble getting connected using the "ifup" command, verify your wireless connection settings and reboot your Raspberry Pi. If you have the Raspberry Pi connected to a display you can watch the Pi attempt the connection during startup.
That's it, hopefully you now have a WiFiPi.
* Raspberry Pi is a trademark of the Raspberry Pi foundation.
Also check out the installation instructions for installing and configuring the
]]>The following article is an excellent resource describing many different wireless network configurations for Debian based distributions:
;)
(click image to enlarge)
I picked up a new Raspberry Pi case a few days ago from Amazon and was impressed so much that I decided to write this review article.
PROS
CONS
I really do like this case overall and think it is my personal favorite so far. It is very compact and will make an excellent travel case for my Pi on the go.
You can purchase this case via the link below directly on Amazon:
Here are additional photos. Click any of the images to enlarge hi-resolution photo.
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
;)
The Oracle JDK8 for ARM with support for hard-float ABI is now available as a developer preview edition! This article will provide the necessary instructions on how to install the Oracle Java SE 8 (with JavaFX) Developer Preview for ARM on your Raspberry Pi.
;)
All:
Windows:
Mac-OSX:
You can download the Oracle Java SE 8 (with JavaFX) Developer Preview for ARM on this page:
http://jdk8.java.net/fxarmpreview/
After downloading the Oracle JDK to you desktop computer, we need to transfer it over to the Raspberry Pi. We will use SCP to transfer the file over the network. If you are running on a Windows desktop, then download and install WinSCP.
If you are using Mac OSX, you can download and install Cyberduck. The screens will look different but the goals are the same.
Create a new session in WinSCP using the IP address of you Raspberry Pi. The default authentication credentials for the Debian Squeeze image is username "pi" and password "raspberry". Save the session and then login. You may be prompted to accept the SSH fingerprint, choose "Yes" to accept and continue.
After successfully establishing a connection, select the drive and folder location in the left pane where you download the Oracle JDK file to on your local desktop system. In the right pane is the file system on the Raspberry Pi, we will leave it in it's default location in the "pi" user's home directory. Drag and drop the Oracle JDK file from the left pane to the right pane and WinSCP will start the file transfer process. You will be prompted with a transfer dialog, just click the "Copy" button to start the transfer.
When the file transfer is complete, you can close WinSCP (or CyberDuck).
The remaining steps should be performed directly on the console of the Raspberry Pi or using a SSH terminal connection with shell access. In the last step, we transfered the Oracle JDK file to the "pi" user's home directory. We should be logged in as the "pi" user and already in the user's home directory.
Lets create a new directory where we will install the JDK files to.
sudo mkdir -p -v /opt/java
Next, lets unpack the Oracle JDK .gz file using this command
tar xvzf ~/jdk-8-ea-b36e-linux-arm-hflt-29_nov_2012.tar.gz
The unpacking process will take a few seconds to complete. It unpacks all the contents of the Oracle JDK tz file to a new directory named "jdk1.8.0" located in the user's home directory.
With the unpack complete its now time to move the new unpacked directory to the Java install location that we created earlier under "opt/java".
sudo mv -v ~/jdk1.8.0 /opt/java
We can also delete the original .gz file as it is no longer needed
rm ~/jdk-8-ea-b36e-linux-arm-hflt-29_nov_2012.tar.gz
To complete the JDK installation we need to let the system know there is a new JVM installed and where it is located. Use the following command to perform this task.
;)
sudo update-alternatives --install "/usr/bin/java" "java" "/opt/java/jdk1.8.0/bin/java" 1
And finally we also need to tell the system that we want this JDK to be the default Java runtime for the system. The following command will perform this action.
sudo update-alternatives --set java /opt/java/jdk1.8.0/bin/java
;)
Now java is installed. To test and verify we can execute the java command using the version argument.
java -version
You should get the following response:
That's it the Oracle JDK is installed and ready for use.
Some Java programs require a JAVA_HOME environment variable to be configured on the system. Add the following line to you "/etc/environment" using your favorite text editor.
JAVA_HOME="/opt/java/jdk1.8.0"
Also, edit your "~/.bashrc" file using this command
nano ~/.bashrc
and add the following two lines to the bottom of the file and save.
export JAVA_HOME="/opt/java/jdk1.8.0"
export PATH=$PATH:$JAVA_HOME/bin
Reboot or re-login to apply the export to your environment.
* Raspberry Pi is a trademark of the Raspberry Pi foundation.
* Oracle and Java are registered trademarks of Oracle.
The Oracle JDK for ARM is now available! This article will provide the necessary instructions on how to install the Oracle Java Development Kit (JDK) on your Raspberry Pi.
All:
Windows:
Mac-OSX:
You can download the Oracle Java SE Development Kit 7u10 on this page:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
First, select JDK Download button under JDK SE 7, then select the Linux ARM JDK7 SE distribution (jdk-7u10-linux-arm-sfp.gz).
After downloading the Oracle JDK to you desktop computer, we need to transfer it over to the Raspberry Pi. We will use SCP to transfer the file over the network. If you are running on a Windows desktop, then download and install WinSCP.
If you are using Mac OSX, you can download and install Cyberduck. The screens will look different but the goals are the same.
Create a new session in WinSCP using the IP address of you Raspberry Pi. The default authentication credentials for the Debian Squeeze image is username "pi" and password "raspberry". Save the session and then login. You may be prompted to accept the SSH fingerprint, choose "Yes" to accept and continue.
After successfully establishing a connection, select the drive and folder location in the left pane where you download the Oracle JDK file to on your local desktop system. In the right pane is the file system on the Raspberry Pi, we will leave it in it's default location in the "pi" user's home directory. Drag and drop the Oracle JDK file from the left pane to the right pane and WinSCP will start the file transfer process. You will be prompted with a transfer dialog, just click the "Copy" button to start the transfer.
When the file transfer is complete, you can close WinSCP (or CyberDuck).
The remaining steps should be performed directly on the console of the Raspberry Pi or using a SSH terminal connection with shell access. In the last step, we transfered the Oracle JDK file to the "pi" user's home directory. We should be logged in as the "pi" user and already in the user's home directory.
Lets create a new directory where we will install the JDK files to.
sudo mkdir -p -v /opt/java
Next, lets unpack the Oracle JDK .gz file using this command
tar xvzf ~/jdk-7u10-linux-arm-sfp.gz
The unpacking process will take a few seconds to complete. It unpacks all the contents of the Oracle JDK tz file to a new directory named "jdk1.7.0_10" located in the user's home directory.
With the unpack complete its now time to move the new unpacked directory to the Java install location that we created earlier under "opt/java".
sudo mv -v ~/jdk1.7.0_10 /opt/java
We can also delete the original .tz file as it is no longer needed
rm ~/jdk-7u10-linux-arm-sfp.gz
To complete the JDK installation we need to let the system know there is a new JVM installed and where it is located. Use the following command to perform this task.
sudo update-alternatives --install "/usr/bin/java" "java" "/opt/java/jdk1.7.0_10/bin/java" 1
And finally we also need to tell the system that we want this JDK to be the default Java runtime for the system. The following command will perform this action.
sudo update-alternatives --set java /opt/java/jdk1.7.0_10/bin/java
Now java is installed. To test and verify we can execute the java command using the version argument.
java -version
You should get the following response:
That's it the Oracle JDK is installed and ready for use.
Some Java programs require a JAVA_HOME environment variable to be configured on the system. Add the following line to you "/etc/environment" using your favorite text editor.
JAVA_HOME="/opt/java/jdk1.7.0_10"
Also, edit your "~/.bashrc" file using this command
nano ~/.bashrc
and add the following two lines to the bottom of the file and save.
export JAVA_HOME="/opt/java/jdk1.7.0_10"
export PATH=$PATH:$JAVA_HOME/bin
Reboot or re-login to apply the export to your environment.
* Raspberry Pi is a trademark of the Raspberry Pi foundation.
* Oracle and Java are registered trademarks of Oracle.
Announcing the release of Version 0.0.4 of the Pi4J project!
Version 0.0.4 is the first "official" release of the Pi4J project. Development snapshot builds have been available since September but now an official release is available complete with an installer and a number of sample projects to help you get started.
Project Summary
This project is intended to provide a bridge between the native hardware and Java for full access to the Raspberry Pi in with a Java-friendly object-oriented approach. Pi4J provides a set of advanced features that make working with the Raspberry Pi an easy to implement and more convenient experience for Java developers.
The Pi4J website content has been updated with instructions and examples for 0.0.4.
The Pi4J project now posts announcements on Twitter.
Follow us to get the latest Pi4J release notices and other Pi4J news.
The Pi4J project has started a Pi4J Google Groups forum for community discussions on Pi4J project development.
For general questions and support try posting to the Java topic on the Raspberry Pi community forums:
Version 0.0.4 introduces a new installer package that makes it easy to install the Pi4J libraries and examples on a Raspbian / Debian OS distribution. See the link below for instructions on downloading and installing Pi4J.
With the release of 0.0.4, the Pi4J project artifacts are now available on Maven Central:
2012-12-16 :: 0.0.4
>> Click here to see the full: Release Notes
To get started using the Pi4J library, please see the Usage page and review each of the examples to explore the functionality provided by the Pi4j library.
]]>In a previous article we discussed how to use the Twine to monitor the state of a garage door and send alert notifications via text (SMS) or email if the door had been left open for a certain period of time. In that article/project we used the built-in orientation sensor in the Twine and the Twine mounted directly to the garage door to determine garage door state. While this was a simple and elegant solution there a certain practical issues for a long term garage monitoring solution that this project did not really address.
The number one issue is battery life. Mounting the Twine directly to the garage door forces the Twine to run solely on batteries and the battery life on the Twine may be too short to be practical for a permanent installation. Personally, I prefer a physically connected powered solution so that I don't have to concern myself with battery replacements. The second practical need for my installation was the need to monitor more than one garage door. Using the previous project concept, it would require 2 Twines to pull this off. Finally, it may not be practical to mount the Twine directly to the garage door for all installations.
In this article we will address these limitations by installing the Twine to the garage wall and not directly to the door. We will use external magnetic sensors designed for garage doors and we will connect two door sensors to a single Twine unit to monitor the state of both garage doors.
The installation time took about 30 minutes for this project. We start with opening the garage door sensors from their packaging. These sensors support both a normally-open (NO) and normally-closed (NC) mode of operation. In this project we will use the normally-closed (NC) behavior and contacts. (Normally-closed in this application means that when the magnet is not near the sensor, the circuit is closed. When the magnet is brought in range to the sensor, the circuit becomes open.)
;)
The advantage of using a sensor that is designed for use with a garage/overhead door is that its sensor range is much greater and thus more tolerant than a traditional security system door magnetic sensor. The sensor range is 3 to 4 inches. These garage door sensors are designed to be installed on a concrete floor, but in my installation, I decided to install them on the wall above the door and not go through the effort of drilling into the concrete.
;)
;)
Install the sensor directly to the wall or floor and route the wires such that they will not interfere with the garage door as it travels up/down. Install the magnet and adjustable plate directly to the garage door so that the magnet is within a couple of inches of the sensor when the garage door is fully shut. I have two garage doors that I want to monitor so I installed a duplicate sensor on the adjacent garage door. (see photo)
;)
;)
Route the wires to the location where you want to install the Twine. You may need to use nylon cable ties to hold the wires in position to prevent getting in the way of the garage door travel. I installed mine in a location where I could easily access the Twine for battery replacement or maintenance. You may also want to consider a location that can easily access a power outlet so the Twine can be powered locally and not rely on battery power.
;)
I used a 4D finish nail to hang the Twine on and a 6D common nail on the right-hand side of the Twine to hold it in place. The Twine breakout sensor board is also required and should be installed along with the Twine using the provided 1/8" stereo wire. The magnetic sensors can be wired directly to the Twine breakout board or you can extend them with additional wire if you need to install the Twine in a location that is a further distance than the existing sensor wires can reach. The black wires (common) from the sensors should be attached to the GND pin on the Twine breakout board. The red wires (NC) from the sensors should be attached to the IN pin on the Twine breakout board. The green wires (NO) from the sensors are not used in this project. Both garage doors are attached to the single Twine so that both doors can be monitored. Note, they are not monitored individually or discretely, but rather as one.
;)
;)
The last step is to use a micro-USB power supply to power the Twine locally. This will then use the mains power to power the Twine and the batteries will only be used for backup in the event of a power failure.
;)
;)
If you have not previously performed the initial setup configuration on your Twine, then please visit this article and perform the configuration steps before continuing.
Open a web browser and login to the Twine management web application:
https://twine.supermechanical.com/
Next, select the specific Twine device that you are working with from the drop-down menu at the top of the screen.
;)
Next, we are going to create a new RULE to issue notifications when the Twine's breakout sensor is in the closed position for at least 15 minutes indicating that one of the the garage doors is open. (If you have any existing rules defined, you may want to delete them first.) Use the Add Rule button to create a new rule.
The new rule should be applied as follows:
WHEN
> "breakout" changes to "is closed" after "900" seconds
THEN
> send SMS text message (and/or email)
Also make sure to define the number of seconds for the trigger time and reset time under the "Options" section of the "When" trigger. I am using 900 seconds which is 15 minutes. So the garage door must be open for 15 minutes before triggering the notification.
Below is rule I am using:
;)
Now that we have installed the Twine and garage soor sensors to the garage doors and configured the logic rule, let's test the system. Simply open one of the garage doors and wait the configured delay time, fifteen minutes in my case, and you should receive the text notification (and/or email).
;)
;)
While this project was a little more complex and involved than the first Twine garage door project, I believe that this is truly a better approach for a permanent installation. Using this approach, the Twine can be powered locally and you can monitor multiple doors with a single Twine. Have fun automating your home with the Twine.
]]>
Parts for Optional Ribbon Cable & Connector (below)
Assembly instructions can also be found on John's website: http://mypishop.com/Pi%208%20LED%20&%208%20Button.html
;)
The kit includes the following components:
In addition to the parts provided in the kit, I also used a right-angle 26P male box header socket for connecting a 26P ribbon cable to the Raspberry Pi.
TIP: Click any image to enlarge and view a high-resolution photo.
STEP 1 > Insert the 26P male header socket in the position at the edge of the board and then solder the pins in place on the bottom side of the board. NOTE: If you are not using this optional IDC box socket connector and you are using the supplied female header, then be aware that it should be mounted to the bottom of the board and soldered in place on the top.
;)
;)
STEP 2 > Insert one of the A102J resistor networks into the RP1 position on the top of the board. Solder in place on the bottom of the board. You can bend the pins over to help hold the component in place while you solder.
;)
;)
STEP 3 > Insert the second A102J resistor network into the RP3 position on the top of the board. Solder in place on the bottom of the board.
;)
;)
STEP 4 > Next we will install the 8 LEDs. The LEDs have a short lead (cathode) and long lead (anode). The long lead (anode) should be insterted into the hole closest to the 26 pin header connector. See the photos below to make sure you have them in the correct orientation.
;)
;)
Insert the 8 LEDs in position and then carefully flip the board and solder each LED in place. TIP: You may find it easier to solder just one lead of each of the LEDs and then check the LEDs from the top and adjust any for final positioning.
;)
;)
After soldering each of the LEDs use a pair of wire snips to trim the excess lead wires.
;)
;)
STEP 5 > Next we will install the momentary buttons. Each button has four pins that will insert into the board. Press each switch in place firmly to fully seat the switch.
;)
;)
Once the switches are placed, flip the board and solder each of the pins on all the switches.
;)
That's it. Now you have a complete assembled board ready for use with your Raspberry Pi.
;)
;)
;)
;)
The 8 LEDs are controlled by positive 3.3 VDC TTL voltage on each of the corresponding GPIO pins. Setting a GPIO pin to HIGH will cause the LED to turn ON and setting a GPIO pin to LOW will turn the LED OFF.
When depressing one of the 8 input buttons, the closed circuit will provide a ground drain for the GPIO pin thus causing it to go LOW. When an input button is not depressed the circuit on the GPIO pin will remain floating; therefore, each of the GPIO pins used with these buttons should be configured to set their internal resistors to pull up. In software, this means that the button will remain in the HIGH state when it is not pressed and will go LOW while a button is pressed.
The 8 LEDs are mapped to the P1 header on the Raspberry Pi as depicted in the diagram below.
;)
The 8 buttons are mapped to the P1 header on the Raspberry Pi as depicted in the diagram below.
;)
Below is a cross reference chart to better help define the GPIO pin numbers used for each button and LED.
;)
If you are interested in native C sample code, please check out this article on Gordon's Project Blog:
https://projects.drogon.net/more-buttons-and-leds/
Gordon provides a sample program based on the WiringPi library.
Below is a sample Java program for monitoring the 8 buttons on this board.
Below is a sample Java program for creating a cylon effect that cycles through the 8 LEDs on this board.
Assembling this kit was simple and takes about 30 minutes. This kit is a very convient tool to have on hand while testing and developing software for the Raspberry Pi. This kit is also a very good educational kit to begin interacting with the Raspberry Pi's GPIO pins.
The wiring for this project is quite simple. All we need are two wires to connect from the GPIO (P1) header on the Raspberry Pi to the PowerSwitch Tail power controller. Using male-to-female jumper wires make the task truly plug-n-play ... we don't need to solder or stip any wires.
The PowerSwitch Tail power controller works by turning on the high voltage AC circuit when a DC input of 3-12 VDC (3-30ma) is detected on its input terminal. When no input voltage is detected, the high voltage AC circuit turns off.
;)
;)
Fortunately the PowerSwitch Tail power controller input can be triggered directly by the Raspberry Pi's TTL 3.3 DC voltage supplied on its GPIO pins. This means that no additional transistors, relays, or other circuitry is needed to perform the switching.
In this project, we will use Raspberry Pi P1 header pin #12 (which is GPIO #1 in the Pi4J/WiringPi pin numbering scheme) as the positive control signal and we will use Raspberry Pi P1 header pin #6 for GND (ground). See the wiring diagram below. Insert the female end of the jumper wire on the Raspberry Pi GPIO header pins and then insert the male end of the jumper wire in the PowerSwitch terminal and tighten the captive screw to secure the wire in place. Make sure that your Raspberry Pi is not plugged in while attaching wires to prevent accidental shorts.
Below are photos of the completed and assembled project. Click any image to enlarge.
;)
;)
;)
The software that determines sunrise and sunset times and controls the GPIO pins is Java based, therefore you must install a Java runtime to use this software.
To install the OpenJDK, simply enter this command via the Raspberry Pi's console:
> sudo apt-get install openjdk-7-jdk
(If you would prefer to install the Oracle JDK, please click here and read this article.)
The source code is provided as open source software and you can download the entire project from Github.
To run the software, a pre-compiled JAR is made available so that you don't have to compile the software on your own. Simply use the following command on the Raspberry Pi console to download the software to the current working directory on your Raspberry Pi.
> wget https://github.com/downloads/savagehomeautomation/raspi-sspc/raspi-sspc-1.0.0.jar
This software program also uses the Pi4J Project to manipulate the GPIO pin states on the Raspberry Pi; therefore, you must also download this prerequisite library to your working directory.
> wget https://github.com/downloads/Pi4J/pi4j/pi4j-core-0.0.3-SNAPSHOT.jar
To launch the program, use the following command:
> sudo java -classpath classes:./'*' SSPC
When the program starts it will prompt you for your longitude and latitude. These coordinates are used to calculate the sunrise and sunset times for your specific geographical location. You can use this web page to determine your specific longitude and latitude: http://itouchmap.com/latlong.html
At this point the program will continue to run and it will turn the power controller ON or OFF depending on the current time and it will schedule the next power event on the next available sunrise or sunset time.
Re-entering the longitude and latitude coordinates every time would be annoying, so you can also use command line arguments to start the program with specified coordinates. You could include this in a shell script to launch the program with the proper command line argument every time.
> sudo java -classpath classes:./'*' SSPC -longitude=-73.985538 -latitude=40.748362
;)
(click to enlarge)
Also note that while the program is running, you can manually force the power controller power state ON or OFF using the "on" or "off" commands via terminal.
The "help" command will display all the supported command options provided by the software:
Just leave the program running and it will automatically turn ON and OFF the power controller at the sunrise and sunset times for your location.
;)
Final ThoughtsAs you can see this is a very simple project to build and the software can be easily modified if you need some unique behavior. You can additionally take steps to include launching this program with a startup script if you want to ensure that it is automatically restarted each time the Raspberry Pi boots up.
This is an excellent example of an embedded Java application running on the Raspberry Pi and making use of the Pi4J project to control the hardware. This Java project includes a Maven build so you can easily re-build the project directly on the Raspberry Pi or your desktop if needed using Maven commands.
I hope you enjoyed this article and maybe thought of a few creative modifications that you can do in your home. Please add a comment if you find this project helpful or would like to share any modifications that you add to it.
Merry Christmas!
Related Holiday Projects:
More Raspberry Pi Projects and ArticlesThis page lists the articles posted on this blog about the Raspberry Pi
Oracle announces EA builds for Linux ARM hard float ABI will be available by the end of the year. #javaonebrasil
— Java (@java) December 4, 2012
This is great news for Java programmers on the Raspberry Pi! See this earlier post on JVM benchmarks using the current Oracle JDK for soft-float.
I will post updates to the Oracle JVM installation instructions and benchmarks articles when the new JVM for hard-float becomes available.
]]>The installation is quite simple. All you need to do is attach the Twine unit to the garage door. I used the hole that is provided on the twine and a single 6-32 x 1-1/2" machine screw to attach the twine to the garage door just under the garage door opener connector arm.
;)
;)
;)
I placed my Twine on the top panel of the garage door; however, if you open leave the garage door slightly open for your pets to come and go, then you may prefer to place the Twine on a lower panel.
So, basically the way this will work is than when the garage door is shut, the twine will have an orientation of "BACK".
And when the Twine has an orientation of "BOTTOM", this indicates that the garage door is open.
;)
;)
If you have not previously performed the initial setup configuration on your Twine, then please visit this article and perform the configuration steps before continuing.
Open a web browser and login to the Twine management web application:
https://twine.supermechanical.com/
Next, select the specific Twine device that you have connected to the water level sensor from the drop-down menu at the top of the screen.
Next, we are going to create a new RULE to issue notifications when the twine's orientation is on "bottom" for at least 5 minutes indicating that the garage door is open. (If you have any existing rules defined, you may want to delete them first.) Use the Add Rule button to create a new rule.
The new rule should be applied as follows:
WHEN
> "orientation" changes to "bottom"
THEN
> send SMS text message (and/or email and/or twitter post)
Also make sure to define the number of seconds for the trigger time and reset time under the "Options" section of the "When" trigger. I am using 300 seconds which is 5 minutes. So the garage door must be open for 5 minutes before triggering the notification.
Below is rule I am using:
;)
After creating the rules, make sure to click the Save to Twine button at the bottom of the screen. It will prompt you to flip the twine on its back to immediately save the new rule to the Twine unit. Now just wait until the save is complete. It takes around 20-30 seconds to complete.
You are done, that's all that is needed to setup notifications from the Twine. We will now move on to testing.
Now that we have mounted the Twine to the garage door and configured the logic rule, let's test the system. Simply open the garage door and wait the configured delay time, five minutes in my case, and you should receive the text notification (or email / or tweet).
;)
;)
This project was the simplest Twine project I have put together thus far. The fact that the only needed sensor is already embedded inside the Twine hardware meant that the only installation step required was just to mount the Twine on the garage door. This project is a very useful electronic reminder for your garage door.
You could also add (with the Twine breakout board) an external switch to act as an override for the cases when you purposefully want to leave the garage door open for an extended period of time. Just add the switch and add an "AND" condition to the "WHEN" part of your rule to include the breakout condition.
;)
;)
;)
;)