Nimbits Tutorials

Machine To Machine (M2M) Communication with Nimbits in the Cloud

2011-10-10T13:19:00.000-07:00

You can use Nimbits to do much more than record sensor readings to the cloud. You can create a data point and store a history of data objects in them in any format that can be serialized into a string i.e JSON or XML. A Nimbits data point can be used to relay data between software systems, or hardware devices such as arduino, using the cloud as a back end.

You can create streams of data objects, and store them in a data point series. The data can then be accessed from anywhere, and used to shape the behavior of connected devices and software.

In other words, you can serialize a class containing any sort of data, feed it into a data point on the cloud, and then read that data from anywhere to drive software systems, or devices connected to Nimbits data points.

This tutorial shows you how I use the Nimbits SDK to relay the tell a robot how to feel. Take, for example this class called Robot - it contains three emotional states, happy, sad and angry.

public class Robot {
    Emotion emotion;

    enum Emotion {
        happy,sad,angry
    }
    
    public Robot() { //don't forget a no arg constructor
    }
    
    public Emotion getEmotion() {
        return emotion;
    }

    public void setEmotion(Emotion emotion) {
        this.emotion = emotion;
    }  
}

I have a data point on Nimbits call MyRobot. I want to transmit an emotional state to the robot, as well as GPS Coordinates of where it is, a number value ranking the level of that state, and an instance of the class above:

public void sendData() throws Exception {
 Robot robot = new Robot();
 robot.setEmotion(Robot.Emotion.happy);
 Value value = ValueModelFactory
    .createValueModel(40.111, -75.146,10, 
    "I'm a happy robot", robot);

 client.recordValue(pointName, value);
}

Let's imagine somewhere else in the world, the robot is connected to the internet and is monitoring this data point on Nimbits. It can get the latest value being sent to it, recieving the robot class and the emotion being sent to it:

public void getData()  {
  
 Robot robot = (Robot) client.getCurrentDataObject(pointName, Robot.class);
 if (robot.getEmotion() == Robot.Emotion.angry) {
   destroyAllHumans();
 }
 else {
   eatHerringSandwiches();
 }

Our Robot downloads the current emotional state from the cloud and carries out it's instructions. In this case, the robot is happy so the human race is lucky.

What's happened here is this:

The data was recorded to the cloud
All of the things Nimbits does when it gets a new value in a Point is available, such as alerts, compression, calculations and so on.
The stored value is instantly accessible from anywhere
The current value can be tied into other systems to trigger behavior.

Learn more at nimbits.com

[Data In] Linux Command Line Data Logging

2011-08-24T07:41:00.000-07:00

Nimbits provides you with an SDK (software development kit) that allows you to develop your own software using libraries we provided. These libraries simplify the use of the REST API which are web services you can also use to access Nimbits data.

Nimbits has a collection of REST web services you can use to create data points, categories, and read and write data to data points. These services use Nimbits' built in authentication process using a secret key, or you can use Google account credentials. The SDK just saves you the trouble of figuring out google's authentication process and gives you easy to use functions to automate your use of Nimbits.

Debian and Ubuntu users can write scripts that use Nimbits by installing the SDK from our repository. This simply installs the java nimbits library JAR on your system and puts a shell script called nimbits in your path so you can script against nimbits at the command line like this:



 $nimbits action=recordvalue point=foo value=42.0 email=test@example.com password=secretpassword

Installing

Before installing Nimbits, you'll want to install Java and ensure it's on your class path. You can know this by opening a teminal and typing

$java -version

You can install java using a command like this:

$sudo apt-get install openjdk-6-jdk

You can install the Nimbits SDK using aptitude from our repository. This will keep you up to date with new versions of the SDK. Learn more about debian repositories here:

https://help.ubuntu.com/community/Repositories/Ubuntu

Simply edit your /etc/apt/sources.list file and add the following line to the bottom

deb http://deb.nimbits.net/packages/ ./

then run:

sudo apt-get update

sudo apt-get upgrade

You will be prompted to install nimbits. (you may also get a warning that you are unable to authenticate us, please enter Y To continue).

You can add /opt/nimbits/nimbits.jar to your java programs and use all of the methods in there to program against a Nimbits Server, or you can use the command line interface to write bash scripts. The SDK provides a tools for storing URL, password and account information in a hash file on your system.

Please visit the Nimbits SDK WIKI for more samples and information.

Example

Here is an example command the records a value to a data point using the hashed credential file mentioned above. The file contains the url of the Target Nimbits Server and credentials.

#!/bin/bash

KEY=[path to my key file]
nimbits -point=foo -action=recordvalue -value=1.0 -i=$KEY

Process Diagrams with SVG

2011-07-03T10:23:00.000-07:00

Whenever you walk in to manufacturing or process control centers, you see the giant overhead displays and monitors with graphics on them used to monitor systems.

These graphics were drawn by engineers using very expensive tools that then connect those graphics to data historians and process control systems. It was my desire to have this kind of interface for a home, small business, or hobbyist that first inspired me to develop Nimbits.

You can create a Process Diagram in Nimbits in SVG format to make a visual representation of your systems and display changing point values, color changing alerts and link to other diagrams and web pages.

I use InkScape to draw my diagrams. It is a free and open source project that runs on Windows and Linux. You can install it on Ubuntu right from the repository, or download it on windows, macs and Linux systems from http://inkscape.org/. Nimbits can display most SVG Diagrams, and the official doc for adding live point data to them is available here on the Nimbits Wiki.

I like to use my aquarium as an example for Nimbits, even though it can do much more than monitor fish. First, it's a simple, closed system with a lot of moving parts. Secondly, i'd like to see if I can make my fish tank a tax deduction.

Since Nimbits diagrams can be made public, so anyone can see them. Feel free to take a look at my Fish Tanks current status right now here: Link to My Aquarium's Process Control Diagram. You should see something like this (if your using IE, you may need to install Chrome Frame):

This graphic demonstrates the following features:

Try clicking on the F Temp to see a live chart of current values.
Check out the Temp C value. This is the result of a real time calculation that converts my F reading to C.
The two charts, one showing a water level and the other showing the Temp F are just Google Charts using the Nimbits Chart API. You can create any type of chart and embed them in your diagram.
Check out the light, indicating the light is on or off. If you load this graphic at night on the east coast of the US, the light should be black.
Click on the Pump. It will take you to a drill down graphic to see some data about the pump.
Click on the links, they will take you to external web sites.
The Data points in this diagram are shared as public points, you can mix private and public points, Nimbits will only show you what you're authorized to see.
Some of these values are entered manually. The Nitrate value expects a new value once a week, if I forget, the point goes Idle and turns red to remind me to do a test.

Here is how you can do this:

Check out the youtube video that walks you though creating a graphic with a single value.

Log into Nimbits and create your Data Points.
Download InkScape and start a new drawing.
Add a Text Box to your drawing
Click on the Text Box and Select Edit - Edit XML
Add a point=pointname value, and an action=[value,onoff,alert,idle]
Based on the action=value, Nimbits will do the following when the graphic is viewed:

value - show the current value in the box
onoff - if the value is zero, turn the shape black, else turn it yellow
alert - turn the shape red if the point is in an alert state.
idle - turn the shape red if the point is idle.

You can also draw a shape and add diagram=diagramName action=self to add a link to another diagram.

On the Nimbits Portal, select the "Upload Diagram" button above the Point tree to upload the diagram just like a Point, you can drag it into folders and organize it with your point.

You can then configure that graphic to share it publicly, or with your connected users.

When you are in the Nimbits Portal, you can click on the graphic to add it to the data display, enter values and trend by clicking on values.

Here is an XML snippet from my SVG diagram that shows the format of a Nimbits XML Node it is all generated by the drawing program, it's just a matter of adding the action and point properties.



<text action="idle,value" point="PH"  y="187.78877" x="-119.55978"  id="tspan3034-1" id="tspan3198" /></text>

Please visit www.nimbits.com to learn more.

The Nimbits Annotated Timeline chart

2011-05-11T08:16:00.000-07:00

The Nimbits Server UI uses the Google Visualization API to display data in the main portal. You can use the Annotated timeline to slice and dice your data by selecting time ranges and dragging other points into it.

What's interesting about Nimbits and time ranges, is that it uses one logical algorithm to attempt to understand what time range you are requesting. This algorithm is used anywhere a timespan is being requested. So if you are pulling data from the chart API web service, downloading a series, or entering a time range into the chart, you can use the same date formats and nimbits will understand.

Some examples of timespan requests are a unix epoch time in milliseconds or seconds, a text date, or even an abstract date like "now" or "*" for the current time, and -1d for one day in the past from the end time.

Nimbits interprets all date requests as a start and end time. Start times can be relative to end times when using an abstract like -7d (the last 7 days) as above.

When you double click on a data point in Nimbits, the portal opens with a point control window with the current value of the data point in it and the chart control. In order to show useful information right away, Nimbits gets the date of the last recorded value for that point, and the last 100 recorded values from that date.

Chart Features

Enter a start and end timestamp boxes integerate into Nimbit's date interpretation algorithm. Many combinations of date entiry is possible, including a Unix time, * or now in the end date for the current time, -1d -5h etc in the start time for a relative range to the start time. Read more here.
Annotations. Any recorded value with a text value in the note field will show as an annotation. Shown here as "Hello"
Drag and drop. Drag your points or those from your connections into the chart to compare them on the same display.
Click the unpin button to move the chart, or maximize to full screen.
The zoom selection will zoom into the current data. Note that you must select a time range and click the refresh button to first download the data you want, then use the zoom options to zoom into that data. The zoom options do not download data outside the selected time range.
MinY and MaxY selections for changing the Y axis.
Zoom slider at the bottom for zooming in.

Using Nimbits to log unit test performance metrics

2011-04-19T12:13:00.000-07:00

Alternate title: Application, heal thy self.

This article will show you how to add a couple of lines of code to your Unit Tests to change them from simply telling you if your code passes or fails, to all singing all dancing integrations tests that log execution times, enforce SLAs, and even warn you if the test isn't running.

The reason for the alternate title above is that as I was writing the Nimbits source code, I realized that there was an incredible useful aspect to the Nimbits server: I could actually use the server to record how long my tests took to run, and see the history of this performance metric. Nimbits was actually using itself to improve performance. So I could see if changes I made to the code was improving performance or not.

Take, for example this test, which writes 10 random values to a data point called b1.



@Test

public void testLoadRandom() throws IOException {

Random r = new Random();

for (int i = 0; i < 10; i++) {                 Value v = nimbitsSDK.recordValue("b1", (r.nextDouble() * 100), new Date());

Assert.assertNotNull(v);

 Assert.assertTrue(v.getKey() > 0);

}

}

Good, this test will run once an hour on my Hudson server and fails if any of the 10 values do not get recorded into the b1 data point. This of course, can be any test you are running on any project. In my example here i'm using Nimbits to test and tune Nimbits which I know is a little creepy.

You can add a couple of lines of code to this test to time how long it takes to write these 10 values - that is to make 10 round trips to Nimbits, waiting for each response. We're then going to record how long the test took to run and save that time in another time series Data Point on a Nimbits Server. This way, we can better understand how our system is performing. What's more, there are many built in features we can take advantage of. Check this out.

Here is the same unit test with references to the Nimbits SDK, and some code to time the test. We then write the result to the data point



@Test

public void testLoadRandom() throws IOException {

Date start = new Date();

Random r = new Random();

for (int i = 0; i < 10; i++) {              Value v = Common.client().recordValue("b1", (r.nextDouble() * 100), new Date());              Assert.assertNotNull(v);              Assert.assertTrue(v.getKey() > 0);

}

Date end = new Date();

long time = (end.getTime() - start.getTime()) / 1000;

nimbitsSDK.recordValue("Time to record 10 values to b1", time, new Date());

}

I have a data point setup called "Time to record 10 values to b1" that holds the time each test took to run. Let's take a look at some of the value Nimbits brings to the table besides being able to see how our system performs.

Alerts: A data point can be configured to send you an email, text message, twitter etc if a value exceeds a threshold.

Why yes, I'd like to know if the time is over 20 seconds or below 0, both indicating something was wrong.

Idle Alarms: Nimbits can alert you if a data point is idle when it should have received a value.

Sure, the build can fail on an error, but what if the whole build server or Hudson is down? Nimbits can alert you if a point has not received a new value. Yes, i'd like to know if my hourly tests are not generating data.

See the impact of your code changes:

The test I wrote above has been humming away for several weeks. Here is a snapshot of the resulting times that spanned the upgrade of the Test Nimbits Server Instance to Nimbits 3.1, being released this week on www.nimbits.com. Imagine going into your boss's office with a chart like this showing real improvement as a result of a code change. (Yes, Nimbits Server 3.1 is way faster)

Obvious improvement with the upgrade, one of the many uses of a Nimbits Server. You can use the live nimbits server, download your own, and get the Nimbits SDK for java and .net on www.nimbits.com

Chat with your Nimbits Data Points over IM

2011-03-06T08:52:00.000-08:00

You can chat with your Nimbits data over any XMPP compatible instant messenger client, And there are a lot of them! Chances are, the IM client on your phone, desktop or browser can talk to a Nimbits Server.

Using IM, you can create points, get current values, record values and list points just like a command prompt at a terminal.

To get started, log into your Nimbits Server - if you are using the public server, just log into app.nimbits.com. Click the "Request IM Invite" button on the top menu, and then check your IM client. You should get a request authorize the Nimbits Server to send you instant messages.

From there, you can send an IM to Nimbits with the following commands

? - Help - list these commands
c foo - create a new data point called foo
foo=42 - set the current value of foo to 42
foo=bar - set the current text value of foo to bar
ls - list all points and categories
foo? get the current value of foo.

Your chat session may look like this:

After you authorise Nimbits to send you instant messages, you can also configure a data point to send you an alarm using IM, or just send you an IM any time a point gets a new value.

To set this up, log into Nimbits and double click on a point, you can select the Point Properties menu to configure that data point. You can then check off the box to receive an instant message from Nimbits any time that point records a new value or, under the alarms tab, get an IM if the value is above or below a limit you set.

Then, when a new value comes into that data point from anywhere, you'll get an IM from Nimbits.

Connecting Spreadsheets To Nimbits

2011-03-05T13:00:00.000-08:00

There are many ways to record historical values into Nimbits. You can either write software interfaces using the SDK, or record data manually to points using the Portal, Data Acquisition Studio, or the Android Data Logger.

The fun starts when you use all of the exiting ways to visualize your data as it changes. The posting will help you get your data into popular spreadsheets.

The posting assumes you have logged into Nimbits http://app.nimbits.com and created a data point. For this tutorial, i'm using the point FProbe1 - the point i created in my blog posting showing how to feed a temperature into a data point using a Temp Probe.

You'll also want to set the point to public. Double click on the point to bring up it's properties and check off "Public." This lets anyone see the current value of your point. There are ways to securly access your non-public points using a Secret key. But for this demo, let's keep it simple. Since your points and data are connected to your google account, and spreadsheets like excel can't log into Google, we have to either skip the authentication process, or provide nimbits with a secret key so it knows who you are.

Making the point public really simplifies things for you, so for this demo let's do just that: (click to enlarge)

Now that I have a data point, and it's public. It's value can be accessed using a URL in this format:

http://app.nimbits.com/service/currentvalue?point=TempF&email=bsautner@gmail.com

You can go to that URL right now since my point is public. You'll get one little http response from the system with the current value of that point.

You'll want to replace the point name and your email address. You should be getting excited at this point realizing that if your data is available this way, there are a lot of fun ways to connect to Nimbits.

In Excel 2007

1. Click on the cell you want your value to show up in
2. Select Data from the Ribbon and click the From Web icon in the Get External Data section
3. Enter your url like the one above and click and click Go.
4. There is no XML, the result of this service is just the value of the point, so the result page isn't pretty. It's ok, just click the yellow arrow next to your current value:

5. Click import and you're done!

6. Let's also setup excel so your values will update automatically. In my case, i have a temp probe feeding values into this point, so i want to see the changing values in excel

On the Data Ribbon, select Properties. Check off Enable Background refresh and to refresh the data every 5 minutes.

You can now use your data feed in your spreadsheet calculations and graphs. Imagine having a master spreadsheet at your office and seeing value coming in as your staff enter data on their Android based phones.

In Google Docs

1. Create a new spreadsheet in Google Docs.
2. Past this in a cell with your url:
=ImportData("http://app.nimbits.com/service/currentvalue?point=TempF&email=bsautner@gmail.com")

You should see your value load. Google Docs will automatically reload your data. Enjoy!

[Data In] Email bulk data into Nimbits

2011-01-20T09:22:00.000-08:00

At Nimbits, we're all about trying to give you as many ways to get data in and out of the data logging engine as possible. Now, you can send an email to Nimbits and have it's contents processed and recorded into your data points. When the email is received the data is processed and all of your configured calculations, alerts, Instant Messages, Facebook posts etc will fire.

Since your Nimbits account is tied to your email address, the data is handled based on the email address the system receives the email from.

Besides being able to bulk load historical data, you can also use this method to feed data into Nimbits from Linux shell scripts, powershell or any other system that can send an email.

To make use of this feature, just send an email to: data@nimbits1.appspotmail.com

If you're running your own Nimbits Server instance on appspot, just replace Nimbits1 with your app id.

You do not have to include a subject. In the message body add the point name (case sensitive) and a value separated by commas and the different points separated by semi-colons like this:

Point1,3.14;Point2,5.6

and so on. Values are recorded with the current time (UTC) when the value is processed. If you want to specify a time stamp you can do so by including the time you want in UNIX time format. You can do a bulk load of point data to a single point by providing values like this:

Point1,45.4,1278448474000;Point1,89.3;127844000000;Point1,44.324,12784480000

Please note the time is in milliseconds, not seconds since the unix epoch.

There are many ways to get the current time in UNIX time - Java developers can use the Java.util.date getTime() function. I posted a handy way C# developers can work with UNIX time here.

Nimbits Server 3.0.x Updates

2011-01-19T06:20:00.000-08:00

Nimbits is a collection of software designed for managing time series data, such as reading from a temperature probe, on the cloud. Nimbits Server is a data logging service that provides storage, compression, alarms, relay and calculation services with a REST inspired API for feeding data in and out of the system.

We've been releasing minor updated to the Nimbits Server 3.0 that includes improvements in the user interface and back end performance. This summarizes what's new in version 3.0.5 - 3.0.9rc. 3.0.9rc is currently running on the public server, with 3.0.8 available for download.

More Mem Cache - commonly accessed data is held more often in memory rather than hitting the data store. This includes the most recent value for every data point, which gives us significant performance improvements.
Point Property Panel - A redesigned point property panel makes it easier to manage how a point behaves when it is written to.

Installation in the Chrome App Store - we enhanced Nimbits to run in the Chrome Web Store.
Trending Enhancements - we were hearing of some limitations users were experiencing when trying to chart large amounts of data. We addressed this by splitting data download requests into smaller chunks - which means you should be able to trend any amount of data that your computer can handle.
Added Motion Chart - watch a video of your data with bubbles changing over time with zoom, line and bar charts as well.

New Google Chart Api Options - Nimbits can generate any type of chart imaginable using your data with the Google Chart API. You have more options to request a date range and use the current time to get your chart data. A URL formated like this: http://app.nimbits.com/service/chartapi?point=TempC&email=bsautner@gmail.com&cht=lc&chs=200x200&chxt=x,y&st=-1h&et=now which will show you a chart of my aquarium's current temperature in Celsius like this:

Improved calculation engine. Performance improvements to the calc engine allows you to create a data point that will trigger a formula to be calculated each time the point is written to with a new value. The result of the calculation can then be stored in another point, further triggering alarms, other calculations etc. Supported symbols include *, +, -, *, /, ^, %, cos, sin, tan, acos, asin, atan, sqrt, sqr, log, min, max, ceil, floor, abs, neg, rndr.

Nimbits 3.1 is getting ready for a March release which will include:

A new Multi-tenant architecture that isolates point data into seperate slices on the cloud, which will give us a huge performance boost
A new feature where a point will go into alarm when it doesn't receive a new value in a set amount of time
Enhancements to the IM Chat feature. You can already interact with Nimbits using an IM Client. We're adding a bunch of new commands for getting your point data.

Nimbits REST API and SDK

2010-12-30T11:13:00.000-08:00

You can develop your own software using any platform or programming language you like, and use a Nimbits server as a back end for storing your time series data; taking advantage of all of Nimbit's services.

Most of Nimbits' functionality can be accessed using a REST API Interface and making simple HTTP post, get, put and delete requests. Nimbits supports using a secret key, OAuth, OpenID and Google Authentication.

Documentation on the REST API is available on the Nimbits Server Source Code page on Google Code under featured downloads:

https://code.google.com/p/nimbits-server/

Taking this a level down, I have a Java Jar file that all of our java based client apps use (including the Android App). This project: Nimbits4J.jar has all of the code needed to authenticate a request with Google, and make requests to Nimbits such as getting a current value, recording values, getting charts, history, creating points etc.

The source code for Nimbits4J is available here:

http://code.google.com/p/nimbits4j/

We do have a .net client package as well but it's not posted for download. If you'd like to get your hands on the .net client for Nimbits, just ask and we'll help you out.

Happy Coding

[Data Out] Data Logging output on Twitter

2010-12-17T11:20:00.000-08:00

You can configure a Nimbits time series data point to send a tweet on your twitter account each time it is written to or when it is in an alarm state. This means that any changing time series value you are recording into Nimbits (be it through a web service call, the API, on your phone etc) the new value will get broadcast through your twitter account.

Since tweets add a hash # flag to your point name, it's easy to see all of that point's tweets just by clicking on it. You can also view #Nimbits to see everyone else's tweets!

To do this, just log into http://app.nimbits.com and click on the "Enable Twitter" menu option on the top. This will direct you to twitter.com where Nimbits is a registered application. Log into Nimbits and authorize the app to post to your twitter account. You'll then be directed back to the Nimbits Portal and you'll be ready to go.

Double click on the point and select the properties menu where you'll see the options to enable tweeting whenever a value is recorded or when the point is in alarm.

Record a new value and you'll see the message appear on your twitter feed!

You can also have Nimbits Send you an instant message, post to facebook or email you as your data changes.

Nimbits Android Update

2010-12-15T12:38:00.000-08:00

We're excited to release a major upgrade to the Android Interface for Nimbits Data Logger. You can download the Nimbits Android App to your phone by visiting the Android Marketplace and searching for Nimbits or Data Logger.

Nimbits Server provides powerful data logging services for recording your time series data into Data Points stored on a global cloud computing infrastructure. The Nimbits Android App provides a window into your data allowing you to:

Create Data Points and Categories
View Charts and Snapshots.
View GPS data on maps.
Record New Values.

Many developers are using our free and open source code to write their own interfaces to feed data from devices into Nimbits Data Points and then monitor those devices from Android. If you still want to access your data but your phone isn't running Android, you can update and retrieve current values using most instant messenger clients.

Besides using a local database to improve performance, gesture recognition to fling between screens, the latest version has the following enhancements:

1. Switch between Nimbits Servers.

There is a free, public server on app.nimbits.com you can use to create and manage data points and feed your low impact data into. If you want, you can also build your own Nimbits Server by downloading and installing the package from www.nimbits.com. If you are running your own Nimbits Server, the Android interface can be configured to use it instead. You can even jump between multiple servers. Please note that the latest version of the App requires Nimbits server 3.0.5 or higher.

2. Alarm Flags

You can log into a Nimbits Server and set alarms for points. A point can be either high or low. Now, you can see points that are in an alarm state with a red (high) or blue (low) flag. For example, these 5 Radon meters, with one over the safety limit.

3. Better Charts

Deep integration into the Google Chart API means the sky is the limit on visualizing your data. We have some exciting new features on the drawing board that will allow you to customizes the way your points are displayed on your phone i.e bar, pie, scatter charts etc. In the meantime, here is one cool chart:

Also, the charts now auto-refresh every 10 seconds.

4. Hey, Developers

All communication between the Nimbits Server and the client code on the phone is done using the Nimbits4J.jar - which is published as open source software on http://code.google.com/p/nimbits4j/

Nimbits4J is a Java library that simplifies Authenticating the Android App to Google, and calling the REST API. This just means I've done most of the work for you for writing the client apps to get recorded values, create points etc. A Nimbits server can be coded against in any Language using the REST API services documented under featured downloads on the Nimbits Server Download Page.

Nimbits 3.0.4 is live

2010-12-02T11:13:00.000-08:00

Nimbits Server, running on http://app.nimbits.com is now running version 3.0.4 and that version is also available for download. The archive NimbitsServer-3.0.4.zip and the installation instructions are listed under the featured downloads on the source code repository

https://code.google.com/p/nimbits-server/

In this release:

Barcode Support
Redesigned Data Screen
Upgrades to Google Map API resolved issues with API key prompts
Fixes and improvements to the Bulk Email in feature.
Various bug fixes.

Enjoy!

[Data Out] Barcodes!

2010-11-30T11:49:00.000-08:00

Every Nimbits Data Point has a unique identifier; a UUID. If the data point is configured to be public (the default) anyone can load it's current values, GPS data, and charts using a URL in this format:

http://nimbits1.appspot.com/?uuid=96c55c29-d60f-42a1-82a9-98d8a76960bd

This makes it easy to share your data, post to your Facebook wall etc.

Clicking the above link will load my reef aquariums temperature that i'm recording onto the cloud through an Arduino device. (Learn how I do that here). Since this data point is public, you can click on that link above and view it's data.

The Data Point is hosted on the public Nimbits server (app.nimbits.com). If you are running your own Nimbits server, the url is just your app ID in place of my nimbits1.appspot.com.

Now that every data point can be references using that format, it is easy to convert the url into a QR Bar Code:

That Bar code is contains the same information as the url above, just presented in a different format. If you were to take your smart phone that was capable of reading bard codes, such as an Android Phone with Google Goggles, and point it at your screen right now, you would be able to browse right to this data point.

There are many uses for this feature, such as printing out stickers to attach to real world objects that are having values fed into a Nimbits data point. I am seriously considering getting a tattoo of some of my more personal data points (kidding....sort of)

To get the Barcode and UUID of any of your Data Points

1. Log into Nimbits by browsing to http://app.nimbits.com (or your installation of a Nimbits server most likely hosted on yourappid.appspot.com)

2. Double Click on a data point or category and then select that point from the point settings menu.

3. The Point properties screen will show you the bardcode and a link for viewing that data using the UUID

Anyone can see this screen and data using this url or barcode

http://nimbits1.appspot.com/?uuid=96c55c29-d60f-42a1-82a9-98d8a76960bd

Enjoy!

Nimbits is an Open Source Data Logger

2010-11-13T09:10:00.000-08:00

The Nimbits Development Team is pleased to announce that you can now Download your own Nimbits Data Logger Server to install and run on your Google App Engine account.

Nimbits is a free and social data logging service. By creating "Data Points" you can feed any values that change over time, such as a changing temperature or stock price, into that point for storage online. That point can then be visualised and shared using many open source software interfaces and processed using many built in features.

Nimbits also provides data relay services, triggered by schedules and data changes, Nimbits will relay new values to other URLs, Facebook, Twitter, or even another Nimbits Server instance.

Over the past several years, Nimbits has been an online resource for feeding time series data into Data Points. We're very excited to announce the completely open source version of Nimbits Server for download. All of the functionality you've been hearing about can now be further customised to meet your needs, and scaled to any level you desire.

Nimbits runs on Google's App Engine providing exceptionally high uptime and reliability, and automatically propagates your data over a global infrastructure. A public version of Nimbits is available on app.nimbits.com, all of the functionality you have on the public server can now run on your own App Engine account.

Learn more at www.nimbits.com

[Data In] Connect Arduino to the Cloud

2010-11-01T12:28:00.000-07:00

Here is a fun project to log Arduino data directly to the Google Cloud using your local network without any middle tier. That is, your data goes right from the Arduino and then out to Google to be logged as a Nimbits Data Point.

You may want to download and setup a copy of the Nimbits Data Logger Server on your own app engine account. Learn More Here

Nimbits is a free, open source data logging server. You can use the public server (with some limitations) on app.nimbits.com or setup your own running instance.

The circuit is very simple and only requires an LM35 temperature sensor and three wires. I went as far as to waterproof my LM35 by soldering it to the end of a cat5 cable and then sealing it in shrink wrap tubing. This is then connected to the ground, 5v and analogue pin 0. There are many examples of this circuit online like this one: http://pscmpf.blogspot.com/2008/12/arduino-lm35-sensor.html

Here is mine using the Ethernet Shield and my waterproofed LM35

With the code below, i'm sending temp reading directly into a nimbits data point. Since Nimbits integrates into the google chart api, i'm able to generate all kind of charts with this data that I can then embed into emails, web pages, docs etc. Like this:

This chart really is the current reading from my Arduino device, since the image is being loaded from the Nimbits Chart Service.

Here is all of the Arduino code you need to feed your device readings into the Cloud. You'll just need to modify the service url with your server secret (if you are running your own server) or make your point public, and provide an email and user key.

This code posts the temp reading to google with the host header nimbits1.appspot.com. If you are using the public nimbits server then you keep that. If you set up your own copy of Nimbits on your app engine account. You just replace nimbits1 with your app id.

Because we are proving the host header, we can send this request to google.com's IP and our request will be relayed to the correct service. From there, we can configure nimbits to relay out data to any other url, facebook or twitter.

#include <SPI.h>

#include  <Ethernet.h>
 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 1, 17 }; // a valid IP on your LAN
byte server[] =  {72, 14, 204, 104}; // Google.com or Appspot.com's IP
Client client(server, 80);
int pin = 0; // analog pin
int tempc = 0,tempf=0; // temperature variables
int samples[8]; // variables to make a better precision
int i;


void setup()
{
  Ethernet.begin(mac, ip);
  Serial.begin(9600);
}
void loop()
{
  for(i = 0;i<=7;i++)
  {  
    samples[i] = ( 5.0 * analogRead(pin) * 100.0) / 1024.0;
    tempc = tempc + samples[i];
    delay(1000);
  }
  tempc = tempc/8.0;  
  tempf = (tempc * 9)/ 5 + 32; 
  tempc = 0;
  String s = String(tempf,DEC);
  if (client.connect()) {
     client.println("GET /service/currentvalue?value=" + s + "&point=test&email=bsautner@gmail.com&format=double&secret=yournimbitssecet HTTP/1.1");
     client.println("Host:nimbits1.appspot.com");  //here is your app engine url - app id with appspot.com
     client.println("Accept-Language:en-us,en;q=0.5");
     client.println("Accept-Encoding:gzip,deflate");
     client.println("Connection:close");
     client.println("Cache-Control:max-age=0");
     client.println();
     client.stop();
  } 
 
}

Enjoy!

[Data Out] Nimbits integrates into the Google Chart API

2010-11-01T10:07:00.000-07:00

You can generate countless types of charts using the Google Chart API Service. Check out the enormous options here: http://code.google.com/apis/chart/

Nimbits is deeply integrated into the Google Chart API. Outside of Nimbits, you can load a chart from the google api using a URL that contains the chart types, format and data. Like this:

You can even generate things like bar codes with your data like this (and much much more):

As you feed time series data into a Nimbits Data Point, you can also call a web service with the same parameters you would feed into the Google Chart API. Instead of the data parameter cht=t:12,34,34 (for example) simply provide a point name and your Nimbits Authentication information, calling the Nimbits Service instead. http://app.nimbits.com/service/chartAPI

Nimbits will tack on the data from your points to the request you are making and deliver your chart as a PNG image. This means you can embed your Nimbits Data in a web page, document or anything that can load an image from a URL.

Here is a sample URL for a line chart using the google api directly

http://chart.apis.google.com/chart?cht=lc&chs=200x100&chd=t:25,23,33,33,45,32,70,80,90&chxt=x,y&chxl=0:|Apr|May|June|1:||50+Kb

If you load that URL in a browser you'll see:

Notice the chd=t parameter. The Numbers next to it are the values that go into the chart. You can provide the same chart format parameters to the Nimbits chart service, but include a data point name and your credentials and you'll get the same chart but with live data from your Nimbits Data Point.

http://app.nimbits.com/service/chartapi?point=TempF&email=bsautner@gmail.com&cht=lc&chs=200x100&chxt=x,y&chxl=0:|Apr|May|June|1:||100+F

Here is a live chart of the temperature of my aquarium that feeds into my TempF data point:

This really is the live feed from my aquarium right here in my blog! Check out how I do this using Arduino. I set up the TempF point to be public, so everyone can see it.

How this works: When you pass Google chart api parameters into the Nimbits service, Nimbits tacks on the chd:t parameter with your data point's values and then feeds you the chart you requested. The visualization possibilities are endless.

[Data In / Out] Pushing and Pulling Data with URL Fetch

2010-10-30T08:15:00.000-07:00

A Nimbits Data Point represents a thing, such as a temperature probe, stock price, anything. That point can become part of a system of connected objects, it's value can be used in calculations, alarms, triggers or anything else.

Further, when you make a data point public. It can be found on the Nimbits Data Point Search Engine so other users can connect their points to yours. If you wish, any http capable data logging system you have can be easily connected to the Nimbits Cloud using this method.

A Data Point can be configured to either push or pull (HTTP GET or POST) to a specified url on on a schedule or as an event. URL Fetch is an app engine service, take a look at Google's guide to this for more details.

To familiarize yourself with this, try logging into the public Nimbits server on http://app.nimbits.com and create a new data point. Double Click the data point to bring up its data screen. Then, use the Point Settings Menu to bring up the properties of this data point.

There is a tab for selecting URL Fetch Settings:

With these options, every time a program requests the current value of a data point, it can be configured to attempt to pull a new value from the source URL. If you are hosting your own Nimbits Server on App Engine, you can set yourself up to fetch a new value on a schedule using CRON.

That source url can be anything, a server on your network (with the ports open on your firewall). It can be a call to a Nimbits web service requesting the current value of another point. You can use the Nimbits Data Point Search Engine to find public points on other Nimbits Servers and pull that data into your system.

The relay service will take whatever value is written to that point and do an HTTP Get to the specified URL with the current value included in the parameters. This way, a newly recorded value can act as a trigger to call another URL, triggering further events.

Please note the caveat that fetch events occur when a new value is actually recorded, which means the value falls out of any compression tolerance settings you configured for a point. Typically, Nimbits only records new values. If the same number sent into the system over and over it is ignored and will not trigger an event.

When a URL is fetched, Nimbits is expecting a raw number value in the result. HTTP headers are ignored, there shouldn't be any HTML or XML. If you load the URL browser, you should only see the number value. You can also provide a full JSON representation of a value object, which can include text annotations, GPS Coordinates, and a timestamp:

{"lat":0.0,"lng":0.0,"d":104.0,"note="hello world","timestamp":"Oct 29, 2010 9:48:28 PM"}

If this is what Nimbits pulls from your URL in a fetch, it would record the value 104.0 to the point with this timestamp with "Hello World" in the note annotation.

Deep Dive: What is a Data Point

2010-07-29T10:58:00.000-07:00

In Nimbits, everything revolves around a Data Point. A Point represents a single collection of time series data. A single temperature reading and any single value that changes over time.

Your personal collection of data points are connected to the account you were logged in with when you created them.

To create a new Data Point, simply log into Nimbits and select Green Plus sign in the data point tree. You'll be prompted to give the point a name. When a point is created, it is initialized with a zero value at the time of it's creation UTC.

From there, you can double click on that point to view it's chart, map, gauges and anything else. Also, a drop down menu is available to configure the point's properties.

Here is an overview of some of the more important properties a point can have:

Compression

As a value is recorded into a Data Point, the Compression value is referenced. Nimbits only records changes in values. So if a Data Point has a current value of Zero (0) and a Zero value is recorded, there will not be two zeros in the database, the new value will be ignored since the value has not changed.

If a Data point has a compression setting of 1 (One) and a current value of 3.14 and a new value is entered of 3.5, the value will be ignored. Only values that are higher or lower than the current value +/- the compression setting will be recorded as new values.

A Compression setting of 5 and a current value of 100 will ignore all recorded values less than 105 and greater than 95. A if the value 106 is recorded into the same point, future recordings less than 111 and greater than 101 will be ignored.

Alerts

All data points can be configured to send alerts. Set a high and/or low value in the alert settings and turn the high or low alert on and any recorded value greater than the high alert or lower than the low alert will trigger an email to the owner of that point.

Calculations

When a data point is written to with a new value, the event of recording a value can trigger a calculation. The formulas basic arithmetic will be executed and the resulting value will be recorded into the target point – all compression, alerts and other functionality will then be executed.

A Data Point can be a trigger, parameter or target for a formula.

If a point is a trigger and a new value is written to it (see the record value diagram – the new recording must be outside compression settings etc) the formula assigned to that data point will be executed. Usually, the trigger data point is also the X parameter in the formula.

After the formula executes successfully, the resulting double value is stored in the target point and all Record Value settings are processed (Such as Alerts, Compression etc)

Example

A Point is created that has a temperature of degrees F being record to it. The point is set to be a trigger and is also the X variable in this formula (X-32)*(5/9) which is the formula for converting F to C.

A New Data point is created for storing the result of this formula and is then set as the target for this formula in the F Point’s settings. Now, each time the F point is written to, this formula will be executed using the new value as the X Parameter and the result will be stored in the new C Point.

[Date In] Logging Text Data

2010-07-29T09:54:00.000-07:00

Throughout the Nimbits System we've added support for logging text and GPS data along with each value you record. When you record a value to a data point, that value has a time stamp and numeric value. Such as a Temperature reading of 80 degrees at a specific moment in time. Now, each recorded value can also have a text based note and GPS location coordinates recorded with it.

Every day, when I go jogging, I stop at the end to record how far I jogged in Miles using Nimbits for Android. on my phone. With these new features I also can add some text such as where I was Jogging to produce a chart like this one on the Nimbits Portal:

I like to annoy my friends with this information, so I configured my data point to post new values to twitter and Facebook, producing a wall post like this the one below each time I record a value. Coincidently, my data point that tracks a servers backup time was also posted next to my jogging post, so i'm including that here too:

On my Phone, I'm capturing GPS Location coordinates. Those can be recorded to the data point as well, producing a display of point data on a map like this:

Nimbits is now a full featured GPS Data Logger for text and numeric data. Enjoy!

Nimbits For Android 2.0 Released!

2010-07-29T07:40:00.000-07:00

Nimbits is a General Purpose Data Logging System for any values that change over time. It allows you to record text or numeric data into "Data Points" so that data can be shared, charted, calculated against and visualized from anywhere in the world.

We're proud to announce a new release of the Nimbits Android App that is now available for download on the Android Marketplace. It's build on Android 2.2 (Google API 8) so if you do not see it listed in the marketplace when you search for "Data Logger" or "Nimbits" perhaps you need to update your phone's OS.

Version 1.0 of Nimbits simply allowed you to view existing points you created on the Nimbits Portal. Besides the cosmetic enhancements to the interface, Version 2 allows you to:

Create New Points and Categories on your phone
View your points on Google Earth (if they have GPS coordinates)
Record values to data points (both numeric and text) using your phone
Use your phone's GPS unit to record the location on earth of your data entry.
Enhanced account authentication uses your phone's credentials to log into Nimbits; you do not need to enter your Google account and password.
Better performance by caching points on your phone's local database.

We're very happy with the way the app can use the Google credentials on your phone to authenticate to the Nimbits cloud instead of requiring you to log in with your credentials.

Nimbits has grown beyond simple numeric data logging into a full featured GPS Data Logger. You can use your phone's GPS to assign coordinates to your readings as well as log textual data with your entries. That data will show up on your Nimbits Portal, Google Earth etc.

An example making use of Nimbits' GPS Logging capabilities can be demonstrated with these data points that are logging Radon levels in the basement of several homes. Each Radon Monitoring device feeds data into a Nimbits Data Point. Each Data Point is configured with an Alarm Setting of 4.0 or higher. Further, each data point has GPS coordinates set to the location on earth where the monitor physically is located.

Using my Nexus One phone I can see the current values of my Data Points. Here, I also pressed the menu button to show what options are available on this screen:

I can select an individual point to manually log a new value and see a thumbnail chart:

The GPS Enabled message means that when I record this value, the current physical location of the phone be recorded with the current value, and the data point itself will be set to that location. I can now see my changes on the map with the points that are in an alarm state shown in red.

We may want to check on the people living in the house with a radon reading over 6! (this is of course for demo purposes)

I hope you get some use out of the Android App, and please let me know if you have any questions or comments.

[Data In] Connect Arduino to Nimbits Data Logger

2010-07-16T12:21:00.000-07:00

It's very easy to have an Arduino device feed data up into the Nimbits Data Logger cloud. This is a fun and simple example where a push button that is wired to an Arduino board sends the fact that it was pressed to a listening .net program. In this example, every time the push button (my house's doorbell) is pressed, a Nimbits data point gets updated and the event is broadcast on Twitter and Facebook.

This is a simple example to give a basic understanding of how to send output from an Arduino device to Nimbits Data Points.

Make sure you log into Nimbits and create a data point. In this example, my data point is called "doorbell".

Double click on the data point and edit it's properties from the menu on the top left. Here is where you can set the point up to broadcast new values to twitter, facebook or to send you an IM. Make sure you use the menu items to enable these features on your account.

The Circuit

The circuit is right out of this tutorial on the Arduino Home Page: http://www.arduino.cc/en/Tutorial/Pushbutton

The Arduino Code:

A small mod to the code on the sample page will wait until the button is pressed and released before sending the "Ding Dong" message up the serial (USB) connection.



 int inPin = 7;   // choose the input pin (for a pushbutton)

int val = 0;     // variable for reading the pin status

boolean pressed = false;



void setup() {

Serial.begin(9600);

pinMode(ledPin, OUTPUT);  // declare LED as output

pinMode(inPin, INPUT);    // declare pushbutton as input



}



void loop(){



val = digitalRead(inPin);  // read input value

if (val == HIGH) {         // check if the input is HIGH (button released)

if (pressed)

{

//must have just been release

pressed = false;

Serial.println("Ding Dong");

}

digitalWrite(ledPin, LOW);  // turn LED OFF

} else {

pressed = true;

digitalWrite(ledPin, HIGH);  // turn LED ON

}

}

The Windows Program.

You can download Visual Studio 2008 Express to write this simple console application. Create your new project and add the NimbitsSDK as a refrence. [Download the Nimbits SDK] [Source code]

The SDK simplifies logging in securely with your google account.

Now it's just a matter of running this code to monitor our com port. You'll need to add the credentials you used to log into nimbits, the target data point, and the com port your Arduino is on.:



 using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO.Ports;

namespace NimbitsDoorBell

{

class Program

{

static SerialPort ComPort;

private static string PortName = "COM4"; // Check device Manager for Port Number

private static NimbitsSDK.client SDK1 = new NimbitsSDK.client("example@gmail.com", "password");

private static String pointName = "doorbell";

private static int timesPressed = 0;



static void Main(string[] args)

{



ComPort = new SerialPort(PortName, 9600);

ComPort.Parity = Parity.None;

ComPort.StopBits = StopBits.One;

ComPort.DataBits = 8;

ComPort.DataReceived += OnSerialDataReceived;

ComPort.Open();

while (true) { }



}

public static void OnSerialDataReceived(object sender, SerialDataReceivedEventArgs args)

{

string data = ComPort.ReadLine();

Console.WriteLine(  data);

timesPressed += 1;

SDK1.RecordValue(pointName, timesPressed, DateTime.Now, "Doorbell Rang");

Console.WriteLine("Ding Dong" + timesPressed);

}

}

}

That's it! Now every time the button is pressed nobody will be out of the loop!

Nimbits as a Parallax Data Logger

2010-06-28T15:05:00.000-07:00

This post will walk you through how to get a value from a Parallax Basic Stamp (BS2) micro-controller and feed it into the Nimbits Data Logger cloud using a bit of C#.

Your reading from any number of Parallax sensors can then be viewed in a Visio Diagram, Spreadsheet, and your Android Phone. You can even have alerts or current readings posted to your Facebook Wall. Remember, your data is being fed up to the Google App Engine Cloud computing platform, so the data being fed up from your computer's USB port can be accessed from anywhere in the world.

If you're not familiar with Parallax Micro-controllers check out http://www.parallax.com for some amazing sensors and robotics projects.

I'm not going into how to actually build a sensor. I'm assuming the audience here is already familiar with stamp programming. The sample code I'm providing here shows the basics of pumping a value from a Parallax Board of Education out a the serial port which is then read by a .net client program running on the computer the stamp board is connected to.

When I tested out this tutorial, I had my old "Board of Education Development Board - Serial Version", connected to my Windows PC using a serial to USB converter. Parallax also carries a USB BOE now as well.

I was also had a spare BASIC Samp 2 Module.

Step 1 Setup your Data Point

Log into app.nimbits.com directly or through Facebook by visiting apps.facebook.com/nimbits
Create a new Data Point by clicking the + symbol on the tree.
Name the data point whatever you like.
You can double click the point from here and configure it's settings. Set up a calculation you'd like it to execute, compression settings etc.

Step 2 Setup your stamp

After setting up the hardware mentioned above. Download the Stamp Editor from Parallax's web site: http://www.parallax.com/tabid/441/Default.aspx
The COM Port my BOE is on was Com 3. Make a note of what port your stamp is actually on.
The .Net code i'm going to provide in Step 3 will receive any number coming up that port that your Stamp Module is sending as a DEBUG message. Here is a snippet of PBASIC code that will send a debug message with number 42 (my favorite number). For this demo, that's all i'm going to do - but that number can of course be a reading from any sensor code you have in place:

' {$STAMP BS2}

' {$PBASIC 2.5}



DO

DEBUG DEC 42

PAUSE 1000

LOOP

END

Step 3 Feed whatever value the Stamp is sending up to Nimbits

With this code tokenized to your stamp module, the stamp should now be sending the number 42 up the wire. The next step is to grab the reading and feed it up to the Nimbits Cloud
This code is very simple, it uses the Nimbits SDK to authenticate you to Google's infrastructure.
In Visual Studio 2008 or Higher, create a new C# Console Application project.
Download the Nimbits SDK
The NimbitsSDK is a .Net 3.5 assembly. Simply add it as a reference in your project.
The NimbitsSDK source code is also available on Google Code.
Add this code to your project. Change the PointName and PortName to your settings
Change the email and passwords that match the account you logged into Nimbits with.

using System.IO.Ports;
namespace TempProbe1
{
class Program
{
static SerialPort ComPort;
private static string PointName = "ParallaxPoint1";
private static string PortName = "COM3"; // Check device Manager for Port Number
private static NimbitsSDK.client SDK1 = new NimbitsSDK.client("example@gmail.com", "password");

static void Main(string[] args)
{

ComPort = new SerialPort(PortName, 9600);
ComPort.Parity = Parity.None;
ComPort.StopBits = StopBits.One;
ComPort.DataBits = 8;
ComPort.DataReceived += OnSerialDataReceived;
ComPort.Open();
while (true) { }

}
public static void OnSerialDataReceived(object sender, SerialDataReceivedEventArgs args)
{
string data = ComPort.ReadExisting();
double v = Double.Parse(data);
SDK1.RecordValue(PointName, v, new DateTime());
Console.WriteLine("Recorded a new value! " + v);

}

}
}

That's it! Your values are now being recorded on the Nimbits Data Logger cloud. Any connected spreadsheet and diagram will show the new readings. Also, if you add Nimbits to your Facebook by visiting http://apps.facebook.com/nimbits you can then configure your point to post new readings to your status. Facebook posts look like this:

Enjoy!

Nimbits on Facebook

2010-06-27T11:27:00.000-07:00

Nimbits is now the only data logging service that integrates with the Facebook Graph platform! You can add Nimbits Data logging to your Facebook profile by following this link: http://apps.facebook.com/nimbits

When you log into app.nimbits.com you can go to a data points property page and either configure the point to post any newly recorded value to your Facebook wall or post alerts (when the value exceeds your high or low setting. Of course, be careful. You will probably annoy your friends if you post second by second readings to your wall.

In order to use the Facebook functionality, you must add the Nimbits Facebook app to your profile. Just visit http://apps.facebook.com/nimbits and allow Nimbits access to your profile. Just note that if you are also using Nimbits with your Google account, the Facebook email account you use must match. Nimbits matches your existing email with the Facebook account. Otherwise, Nimbits will register you as a new user under the Facebook email address it found.

Here is an example of a Facebook wall post when my temperature probe read in a new value

Enjoy!

May Newsletter

2010-05-12T11:57:00.000-07:00

Back in April, we posted a new version of Nimbits that with the following new features:

· Drag and Drop from the Data Point tree to the charts and grids

· You can now re-organize your data points by dragging them around your Point Categories.

· We’ve removed limitation on the size of data trends you can request on the portal.

· New Integration with Google Earth allows you to assign GPS Coordinates to your data points and see your changes on the Map

· Subscribers can configure data points to Pull Data from a URL at a regular interval

· Continuous improvements on Data compression and Performance.

· We’ve flushed out some issues with the Android front end. We recommend uninstalling the previous version and downloading the update. The new Android App is faster and more reliable.

· We’re working on a user manual that is available now on our Open Source Repository : http://nimbits.googlecode.com/svn/trunk/Nimbits%20User%20Guide.pdf

o The manual currently documents the various REST web services that developers can use to program against the Nimbits Platform.

· Speaking of Open Source. We’re currently working towards making Nimbits an Open Source Project. The Source code for Data Acquisition Studio, the .Net 3.5 Nimbits SDK and the Android Interface are currently part of the Open Source Project under the MIT License. https://code.google.com/p/nimbits

Join Us

We’d really appreciate seeing you on our Facebook Fan Page. If you’d like to post feedback, get support or ask questions it would also be great to see you on the Nimbits News Group. Lastly, if you’d like to get updates on the tutorials and guides we post, it would be great if you would follow the Nimbits Blog.

What’s Next?

Here is what we’re working on for the upcoming versions of Nimbits

o Nimbits is a social data logging service. The next version will allow you to “Friend” other data loggers and share data with each other.

o A search engine that will allow you to find and friend other data loggers based on data point descriptions etc.

o Tighter integration into Google Earth, GPS coordinates will be received from mobile phones

o Integration with Facebook and Twitter

o Command Line tools for Linux and windows powershell.

o Arduino and Stamp support

o Deep integration into Wolfram Alpha http://www.wolframalpha.com for data modeling

o Instant Messaging Alerts to popular IM clients

If you have any questions about Nimbits or would like to see a new feature you can use, please just let me know!