Tag Archives: GSM

MobileNode is a circular IoT board


This open source, Arduino-compatible GSM/GPRS and GPS/GLONASS device provides real-time data anywhere, about anything.


The MobileNode is an open source IoT board, which was named a semi-finalist in last year’s Hackaday Prize and is now live on Indiegogo. Measuring just seven centimeters in diameter, the circular device is equipped with an ATmega32U4 MCU at its core, a GPS/GLONASS module for tracking and a GSM/GPRS chip for data transmission.

8529621442857319307

Makers can easily attach a variety of sensors to the MobileNode, including air quality (CO, CO2, O2, etc.), temperature, humidity, fire and motion, as well as add lights, servo motors and other electronic circuits. This enables the Arduino-compatible board to monitor air pollution, reduce energy consumption, collect real-time data, and even control food production machinery. What’s more, there are four holes for M1.2 or M1.4 screws, making it possible to house the MobileNode inside a box or case.

9986351442857553734

Every MobileNode comes with an attached tag, which contains both a public and private key. As its creators Oscar Rojas and Camilo Rojas reveal, you can push data to the cloud with the private key, while accessing such information via the public key. Meanwhile, GPS coordinates are shown in a Google Map along with the board’s orientation data given by its e-compass.

mobileNodeSch

Aside from all that, MobileNode features an electret microphone that lets users hear what is happening nearby, a Nano SIM card socket, TVS diodes and Bluetooth. It is also possible to connect an external antenna to the GPS module, since some applications call for the MobileNode to be used indoors.

Intrigued? Head over to its Indiegogo page here, or watch the video below.

Hacker builds an impressive ProxyHam alternative


ProxyGambit boasts twice the radio range of the ProxyHam, as well as unlimited reach with GSM.


While many of us have been scratching our heads as to what happened to the ProxyHam following its sudden disappearance, Samy Kamkar has surfaced with his own take on online anonymity. The hacker has created what he calls an “advanced resurrection of ProxyHam,” also known as ProxyGambit — a device that enables users to access an Internet connection from anywhere on Earth without ever revealing their IP address or location. 

proxygambit-640x449

The news of ProxyHam demise came over Twitter when Rhino Security, the consultancy run by the project’s creator Ben Caudill, announced that the was being pulled from the DEFCON agenda. The tweet stated, “Effective immediately, we are halting further dev on #proxyham and will not be releasing any further details or source for the device.”

The $238 ProxyGambit has one-upped its predecessor, given that its direct line-of-sight point-to-point link boasts a range of up to six miles, more than double ProxyHam’s two-and-a-half miles. And impressively, it can work anywhere on Earth via 2G. It can use a reverse-tunneled GSM bridge that connects to the Internet and exits through a wireless network anywhere in the world.

“While a point to point link is possible, the reverse GSM bridge allows you to proxy from thousands of miles away with nothing other than a computer and Internet with no direct link back to your originating machine,” Kamkar explains.

all

Both methods proxy connection through local Wi-Fi networks near the gadget, shielding and making it more difficult to determine one’s true whereabouts, IP and identity. The ProxyGambit consists of two Adafruit FONA GSM breakout boards, any two ATmega328 Arduino boards and two Raspberry Pis. The FONA uses a SIM800 chip to link the Arduino to the GSM to produce a 2G Internet connection. Meanwhile, the Arduino serves as a serial connection over a reverse TCP tunnel and provides a software proxy layer between the Raspberry Raspberry Pi’s UART and the FONA. One of, if not, the most vital parts of the project is the Pi, which drives the Linux serial link and bridges the public Wi-Fi and radio connection.

Beyond all that, Kamkar employs a 2.5A USB hub, an SD card to host the operating system and data, a Wi-Fi card depending on how far a user would like the ProxyGambit to reach, and a LiPo battery to power the FONA.

IMG_3139sm

When all is said and done, the hacker does emphasize that this is merely a proof of concept and recommends that any potential builders proceed with extreme caution.

“The fragmentation of data through alternate mediums is a useful and effective concept and those interested in privacy, anonymization, or deanonymization should explore this area further. Entropy is both gained and lost with these methods and many risks are involved when deploying any system of this nature,” he concludes.

Intrigued? Head over to Kamkar’s page, where he has made all of the ProxyGamit’s source code and instructions available.

Turning an old rotary phone into mobile handset


Project iRotary is one man’s quest to turn an old rotary phone into a mobile device.


When Stavros Korokithakis was refused a landline in his new office space by the phone company, he decided to channel his inner anger by modding the inner workings of an antiquated rotary phone into a modern-day mobile handset. Not to mention, being a vexed person and all, the Maker sorely missed the tactile sensation of slamming the phone on someone’s face — something that would once again be possible.

irotary

“My ultimate goal with this is to be able to take it out to the coffee shop, place it on the table and look crazy because I’m talking on an old-timey rotary phone with no cable even coming out of it,” he writes.

To accomplish this, the Maker used an Arduino, a GSM shield and a 25-year-old Seimens rotary phone, along with some open-source code. The project itself took just two days from start to finish, and only set him back about $150. Now completed, Korokithakis’s device connects to a mobile network via its shield, while the Arduino allows him to make and receive calls. That’s pretty much it — no web browsing, no SMS messages, no Facebooking.

Korokithakis did remove its bell (responsible for that infamous brngggg-ing soundin order to make room for the handful of electronic components inside the orange shell. A short Arduino script was also employed to convert the pulse dial method of the rotary pad to actual digital numbers that can be dialed by the system. The sketch is set up so that after the 10th digit is read, the call is placed through the GSM shield and its associated library.

internals-1

Beyond that, the retrofitted gadget features an authentic hang-up button and an indicator LED to reveal when the phone is booting or ringing. In order to connect these controls, the Maker developed an event-driven architecture with the help of a little programming that enables it to ignore inputs when at rest, answer calls when lifted from the hook, and of course, end calls when slammed down.

“Achieving this is easy with a state machine. That simply means that there’s one variable that always contains the current state of the phone, i.e. whether it’s idle, in a call, ringing, dialing, etc. Then, any events that pop up (such as ‘button pressed’) can just check what state the phone is in, and either perform the necessary action or do nothing,” Korokithakis notes.

Designed with portability in mind, the DIY handset is powered through a small 5V battery and a USB charging circuit. As for what the future holds for this device, Korokithakis hints at a possible Kickstarter campaign in the coming weeks. Until then, those wishing for one of their own are in luck. The Maker has made his project and its code available on Github.

Connecting an Arduino to a mobile cellular network


PubNub’s Ian Jennings demonstrates how to connect your Arduino to a mobile cellular network with a GSM/GPRS shield.


There’s a ton of tutorials out there on hooking your Arduino up to the LAN, whether it be Wi-Fi, an Ethernet, or other. But what about beyond the LAN? What if you want to connect your Arduino to the Internet in the wild?

In this tutorial from PubNub’s Developer Evangelist Ian Jennings, we’ll show you how to connect your Arduino to a mobile cellular network with a GSM/GPRS shield. This enables you to stream data bidirectionally or trigger device actions anywhere with a cellular network.

And, that’s powerful for any mobile IoT implementation (think connected car or drones) or apps without a Wi-Fi signal (think irrigation or weather sensor networks). Like like the many other DIY Arduino projects out there, it’s easy, affordable, and powerful.

So let’s get the tutorial started!

arduino mobile cellular network

What You’ll Need

  • Arduino UNO Rev3 (ATmega328)
  • Seeed Studio GPRS Shield V2.0
  • AT&T SIM Card (standalone)
  • C size batteries (x5)
  • C size battery holder (x5)
  • Smartphone
  • Laptop

Setting up the SIM Card

iphone-activation-card-600The first thing you’ll need to do is unlock the SIM card and make sure it has a data plan associated with it (hence why we included the smartphone on the list above).

Put the SIM card into your phone and read the instructions on the package. In the case of an AT&T SIM card, you may have to dial a series of numbers to activate the card, then configure the plan online, but this may vary depending on the carrier.

Note: Make sure your mobile plan supports data transfer and not just calls and texts.

Then, connect to a website on your mobile phone. If it works, you have data and the SIM card will work on your Arduino.

Setting up Arduino GPRS

Plug in your now-activated SIM card to your Arduino GPRS Shield. For how to do this, Seeed Studio has a great tutorial. Follow the tutorial, but stop and come back to this tutorial before uploading code in “Test Setup.”

Arduino Libraries

There are a fair amount of libraries needed to get setup on Arduino, but at the end, it’ll make it all a lot easier. The specific libraries for the Seeed Studio GPRS Shield v2 can be found here. In the docs, you’ll see the three libraries you’ll need to connect to a mobile network.

Import all three libraries into the Arduino setup.

Software Serial

Now that our shield and Arduino environment are ready, let’s move onto the fun part of this tutorial: playing with the cell networks. We need a way to talk to the SIM900 chip on the Arduino. Instead of using a hardware serial and talking directly to it, we’re going to use Arduino’s software serial.

Open up the SIM_900_Serial_Debug example from your Arduino examples folder.

This example is pretty simple. All we’re doing it proxying the serial data from Arduino’s serial port into SIM900’s. This enables us to use the included Arduino serial debug tool to interact with our SIM900.

void loop(){
  if(gprs.available()){
    Serial.write(gprs.read());
  }
  if(Serial.available()){     
    gprs.write(Serial.read()); 
  }
}

Call Yourself

To test everything out, we’re going to attempt to call ourselves with the Arduino GSM shield. First, load the software serial example onto the Arduino and then open up the serial debugger. Be sure to power the SIM card on the Arduino GPRS shield using the button on the side.

Power up the SIM900 by pressing the power button for around 2 seconds. The red LED will turn on. The green one beside it will begin blinking. If the shield joins the network successfully, the green LED will blink every 3 seconds. Wonderful!

Make sure you put your old SMS card back into your phone after testing the Arduino SIM. Now, type the following into your Arduino serial window.

AT

Serial output should show something like:

RDY
 
+CFUN: 1
 
+CPIN: READY
 
+PACSP: 0
 
Call Ready

If you don’t see the messages in the serial monitor, click the “send new” option that will add carriage return at the end of AT command, and then send AT command “AT+IPR=19200″ to set the baud rate of the SIM900.

Now try calling yourself. Enter the following command, replacing 1***8675309 with your own number.

ATD1***8675309;

If it succeeds, a message ATH OK will show up as the picture below. Otherwise, No CARRIER will show up instead. The reason might be nonexistent phone number or incorrect command format.

Connecting to the Mobile Cellular Network

Now that we’ve configured our Arduino to work over GSM, let’s get it connected to the mobile cellular network.

Make sure that the baud rate of SIM900 is 9600! You can use the AT Command(AT+IPR=9600) to set it through SerialDebug.

Load up the the GPRS_TCPConnection example from GPRS_Shield_Suli. This example makes a simple request tombed.org/media/uploads/mbed_official/hello.txt HTTP/1.0\r\n\r\n

However, it probably won’t run when you load it on your Arduino. This is because it’s not configured to work with your specific cellular network.

In my case I’m using AT&T, so I needed to change the following lines to configure my GPRS connection:

GPRS gprs(PIN_TX, PIN_RX, BAUDRATE,"cmnet");

This line isn’t sufficient in most cases. We’ll also need to supply an APN, username, and password. These parameters are omitted from the example but you can simply supply them on your own. You can find the relevant code here.

GPRS(int tx, int rx, uint32_t baudRate = 9600, const char* apn = NULL, const char* userName = NULL, const char *passWord = NULL);

To connect to AT&T, use the following config:

GPRS gprs(PIN_TX, PIN_RX, BAUDRATE, "wap.cingular", "WAP@CINGULARGPRS.COM", "CINGULAR1");

Now run the code. You should be able to obtain an IP and issue the request. However, the app will probably crash (SIM turns off) when the request has been issued. This might be confusing, but there’s an easy fix.

Battery Considerations

The Seeed Studio and a variety of other shields advertise to be “plug and play” with Arduino. However, this isn’t always the case. This shield in particular doesn’t have enough power from the single 5v USB supply to successfully complete TCP requests.

This is easy enough to fix though, all we need to do is give it more power! Online forums suggest adding 5 C-cell batteries to power the GSM chip, which is what we did below:

The batteries should be wired in series, with the positive end wired into the VIN input and negative wired into the GND. After you’ve added batteries, try the example again. It should connect successfully.

Great! Now we’re ready to signal with PubNub.

Signaling with the PubNub Data Stream Network

We’re going to use the PubNub Data Stream Network as our backend messaging layer for signaling our Arduino. This enables you to send and receive data bidirectionally between your Arduinos and signal to trigger device actions.

Load the following example onto your Arduino, changing the GPRS gprs() configuration as mentioned previously.

#include 
  #include 
  #include 
  #include 
 
  #define PIN_TX    7
  #define PIN_RX    8
  //make sure that the baud rate of SIM900 is 9600!
  //you can use the AT Command(AT+IPR=9600) to set it through SerialDebug
  #define BAUDRATE  9600
 
 
  GPRS gprs(PIN_TX, PIN_RX, BAUDRATE, "wap.cingular", "WAP@CINGULARGPRS.COM", "CINGULAR1");
 
  void publishData(String data) {
 
    Serial.println("attempting to publish");
 
    while (false == gprs.join()) {
      Serial.println("gprs join network error");
      delay(2000);
    }
 
    String str = "GET /publish/demo/demo/0/pubnub_gprs/0/\"" + data + "\" HTTP/1.0\r\n\r\n";
 
    // Length (with one extra character for the null terminator)
    int str_len = str.length() + 1; 
 
    // Prepare the character array (the buffer) 
    char http_cmd[str_len];
 
    // Copy it over 
    str.toCharArray(http_cmd, str_len);
 
    char buffer[512];
 
    if (false == gprs.connect(TCP, "pubsub.pubnub.com", 80)) {
      Serial.println("connect error");
    } else {
      Serial.println("publish success");
      Serial.println(data);
    }
 
    gprs.send(http_cmd, sizeof(http_cmd) - 1);
 
    gprs.close();
 
  }
 
  int counter = 0;
 
  void setup() {
 
    Serial.println("starting");
 
    Serial.begin(9600);
    // use DHCP
    gprs.init();
    // attempt DHCP
 
    while(true){
      publishData(String(counter));
      counter++;
      delay(1000);
    }
 
    gprs.disconnect();
 
  }
 
  void loop() {
 
  }

This example connects to PubNub and publishes a message every second. It works just like the previous example, but instead of retrieving data, this example streams information to the PubNub network where it’s accessible from anywhere.

Rest Client

You can see how the message is assembled by looking at the publishData() function.

See how the url is created here:

String str = "GET /publish/demo/demo/0/pubnub_gprs/0/\"" + data + "\" HTTP/1.0\r\n\r\n";

It may be confusing at first, but let’s break it down. The url is formatted according to the PubNub REST Push API.

http://pubsub.pubnub.com
/publish
/pub-key
/sub-key
/signature
/channel
/callback
/message

The domain pubsub.pubnub.com is defined later in the function. The publish key refers to is the pubnub command (you can also subscribe). The pub-key and sub-key come from your own PubNub account, but you can use thedemo keys for now. Don’t worry about signature.

The channel is really important. This is like an IRC channel for your PubNub devices to talk to each other.

Show Me the Data

Since we don’t have any other device listening for messages from the Arduino, let’s use the PubNub console to observe our channel activity.

If you’re using the default code above, you can use this link to view channel activity for your GPRS chip.

If your demo is running you should see a count like 1, 2, 3, 4 appear in the “message” pane.

We’re able to view the data coming out of the Arduino because we plugged the same publish and subscribe key into the PubNub console as we did into the Arduino. Since we’re using the demo keys the channel is shared publicly, but if you create your own account your data will be privatized.

Additional Resources and More Information

This is just one of our many Arduino-PubNub implementations. We’ve also connected Arduino Yún to the Internet, as well as showing you how to connect Arduino Uno and Seeed Studio Ethernet Shield v2. For all our Arduino related posts, here’s the full feed.


Ian Jennings is a developer evangelist at PubNub, a secure global data stream network for IoT, mobile, and web applications. He cofounded Hacker League, a site devoted to simplifying the organization of intensely collaborative tech events known as “hackathons.” Jennings recently pretty much guaranteed that he’ll always be able to keep himself stocked up on techno-gadgets with the sale of Hacker League to Intel’s Mashery subdivision for the price of more than a few PCs. But he’s not done. In fact, his latest invention, Mote.io, is a remote that connects your web browser with various music platforms like Pandora, Youtube, and Rdio, and has gotten raves on tech sites like GigaOM; he’s also in the midst of developing the Reddit app for the uber-hyped tech accessory Google Glass.

MicroLink is like a tiny Arduino with GSM

Sydney-based AALER Engineering has officially launched a Kickstarter campaign for its new development board, MicroLink. Equipped with an Atmel ATmega328 MCU, the Arduino-compatible board is capable of automation, alerts, cellular data, phone calls, SMS messages and more.

photo-main-3

The MicroLink is more than just a tiny Arduino with GSM; in fact, its on-board USB and battery charging capabilities provide Makers with the capacity to implement professional quality wireless remote-monitoring and control. An ATmega328 allows for constant control, while a SIM800H quad band GSM module makes communication with wireless devices simple. Measuring just 50x32mm, there truly isn’t a place where the MicroLink couldn’t fit!

c5c6416038de2f30a4921d825d26553e_large

One of the most unique features of the MicroLink is that it comes ready to use out of the box with a true plug-and-play dynamic. “Each MicroLink comes with an SMS sketch pre-loaded – so you get the capacity to do remote monitoring and remote control, using SMS text messages, out of the box, a company rep explains on the Kickstarter page.

The simplicity of GSM communications offers an extremely valuable and reliable rapid-prototyping tool for an endless number of projects. Indeed, the uses for this device are really only limited by your imagination. Some suggestions from AALER include sound or motion detectors, an SMS car alarm, a homemade phone, or even a fall alert system for an elderly individual. Each of these projects, plus countless others, are made possible due to the unique nature of the MicroLink build components.

c37409a54e8ce9f222decee2a308181d_large

There are two versions of the MicroLink currently in the development pipeline: Standard and Extra Flash.

The Extra Flash model boasts extra memory – an additional 4 MB 104MHZ SPI FLASH chip, which is attached to the back. The extra chip enables extra data-logging, and over-the-air wireless reprogramming. According to its creators, the ability to upload programs over-the-air will be particularly useful in circumstances where continuous physical access is problematic, such as deployed in other dwellings, industrial installations and remote locations, as well as embedded within toys, appliances and other devices. Moreover, the Extra Flash version sleeps at 11 µA, while the Standard sleeps at a very low 6 µA. The team notes that a standard implementation that sends data every 48 hours could last more than year on a coin-cell battery.

2c332adc6d950a9f55c403de5c53f9ce_large

“The initial design originated from a genuine need — the key attributes of very-small size, GSM, ultra-low power consumption and USB give an incredibly useful, versatile and valuable tool that can be used for a broad range of tasks,” its team adds.

Currently seeking $40,000, the AALER Engineering is already a quarter of the way to achieving its goal. The team hopes to have the first batch of MicroLinks shipped to its backers by this Christmas.

This biomedical device is going open source

This August, a team of researchers from FabLab Pisa and the University of Pisa’s Center for Bioengineering and Robotics will kick off an exciting new project known as OS4BME, or Open Source for Biomedical Engineering.

The project’s goal? Introducing the medical device world to a DIY & Makers philosophy. Indeed, OS4BME wants to help facilitate the development of simple, low-cost and high-impact biomedical devices such as neonatal baby monitors.

According to the official Arduino blog, the course is slated to take place at Kenyatta University (Nairobi) and will involve a number of staggered tracks, including configuring a 3D printing system, developing a neonatal monitoring device, using open source and designing solar-powered electronics based on the Atmel-powered Arduino platform.

“Participants will play an active role in the identification of components, design, assembling and testing of the device and in the discussion of regulatory issues in its development,” the Arduino blog explained. “Close attention will [especially] be paid to safety, ergonomic aspects and regulatory standards for biomedical devices.”

Arduino has announced its official support for the project, sending the research team a number of UNO boards, along with Wi-Fi and GSM shields to be used during the course. The components will subsequently be donated to the Kenyatta University and Fablab Nairobi.

OS4BME was created by Prof. Arti Ahluwalia (Univ. Pisa), Daniele Mazzei and Carmelo De Maria (Fablab Pisa, Centro E.Piaggio).