Tag Archives: cellular

Particle E-Series Modules – LTE Connectivity designed for IoT

Building an Internet of Things based system has always been an exciting art that usually comes with one major challenge to overcome – Connectivity. A smart system or an even intelligent system that collects data without having any network capability can’t be called an IoT system and it’s that device connectivity that gives it the IoT factor. Cellular connectivity has been one of the go-to connectivity for IoT system, and 2G networks have been the umbrella for this connectivity option mostly because it is virtually available everywhere.

Particle IoT 4G ESeries LTE

Despite the success that 2G & 3G networks have brought to the adoption of Internet of Things application, they are also slowly being phased out for the more robust, better 4G networks. Countries like Australia have stopped a nationwide use of 2G networks and some other countries already making plans to do the same. Particle, a developer of networking hardware and software for connected devices that has released several IoT focused boards in the past, like the Particle Photon and Particle Cellular Modules, has recently launched new LTE modules for 4G networks. These new devices aim those people whose devices depend on 2G and 3G networks and comes with a cloud and SIM support.

The LTE modules are part of Particle’s existing E Series suite, which comes bundled with the Particle Device Cloud, Device OS, and Particle’s collection of developer tools. The E Series modules are powered by an STM32F205 ARM Cortex M3 microcontroller running at 120MHz with features a 1MB Flash, 256KB RAM, and a wealth of GPIO. The modules integrate the industry-leading u-blox Sara cellular modems that provide support for 2G, 3G, and LTE M1/NB1 radios.

The LTE E Series modules are build on their famous Electron cellular prototyping kit, and they all come with standard wireless and cellular certifications – PTCRB Certified, FCC/CE/IC/GCF Certified, and RoHS Compliant. Also, they offer an extended operating temperature range from -20 to 85C for hostile environments. The modules come in 3 family types as listed below:

  • Electron development kit
  • E Series evaluation board
  • E Series modules

(more…)

HioTron IoT Kit – A Modular and Enterprise IoT Development Kit

HioTron IoT Kit is a modular and enterprise IoT kit that is entirely pre-programmed prototyping kit for quickly building and testing IoT concepts. All modules are plug-n-play, allowing for flexible prototyping, customization & production. This set of kit is made by the Indian based company HioTron, which specializes in IoT solutions development. This Kit includes Hardware, IoT Platform & User App/Dashboard needed to build quickly any IoT application right from Scratch to Production.

Hiotron Development Kit

One of the challenges that come with embarking on IoT project is that of the platform, software, wireless standard, API, and hardware selection. We have numerous IoT enabled hardware in the market, with each having their own software stack and also several IoT platforms available to pick from. The process of going through these selection pools, valuable and productivity time could be lost and still not arrive at something that genuinely works or is efficient. Hiotron’s goal is to solve this by providing a complete package that can be used from PoC (Proof Of Concept) to Production. HioTron complete IoT solution which includes not only the hardware building blocks (Nodes & Gateway) needed to quickly prototype a wireless IoT system from scratch but most importantly hIOTron enterprise IoT™ Platform is integrated with custom mobile application & GUI dashboard that enable user to get up and run PoC of any idea as easily and quickly as possible.

The IoT Kit is ideal for makers, enthuthat siast, startups and even organization that wants to embark on IoT projects in the areas of smart cities, agriculture, industrial & smart factories, energy, healthcare, logistics, and several others. The kit is modular which means you can easily stack in add-ons on top of existing ones or add another device to the network infrastructure. The kit includes the following:

  • Hi-Node
  • Hi-Gate
  • hIOTron IoT Platform
  • Dashboard and Mobile App

Hi-Node

Hi-Node is a battery (2700 mAh Li-ion) or USB [Optional] powered wireless node which comes with 4 output channels to control real-world devices using 4 relays (Output 5A 230VAC) with 4 connectors and 4 universal (Analog/Digital) input channels to communicate with real-world sensors and transmit this information to IoT gateway using wireless (Zig-bee & BLE4.0) protocols.

Hi-Node

Hi-Node provides standard interface that offers not only remote monitoring but also control capability for managing many types of devices and it also offers advanced Edge Analytics & Local storage. The Hi-Node ZigBee is based on the Digikey Wired XBee module which boasts a range of about 80 – 100 meters line of sight and about 40 meters indoor. The Hi-Node is based around the ATmega328P with 2KB of SRAM, 32KB of Flash memory, and 1KB of EEPROM.

Hi-Gate

Hi-Gate is the brain of this kit which is fully Modular & Enterprise IoT gateway and which doesn’t only translate the protocol [RF/ NON-RF –To– REST/MQTT] but has TI CC3200 at its heart. The Gateway device comes with Zig-Bee and BLE4.0 to support its local network infrastructure with the Hi-Nodes and an outbound connectivity for connecting to the outside world using Wi-Fi 802.11 B/G/N Radio, Ethernet, and Cellular connectivity (2G, 3G, and 4G).

Hi-Gate

The Gateway device supports dual mode of operation – As a Node or Gateway. The Hi-Gate can support up to 25 wireless Hi-Nodes and offers an auto-reconnect for Wi-Fi and GSM network.

The following are the specification of the Hi-Gate:

Hardware System
  • Controller: ARM Cortex-M4 Core at 80 MHz
  • Flash: 1MB Serial Flash Memory
  • RAM: 256KB
  • EEPROM: 512KB External
Interface
  • Power input: 9-12V DC
  • 2-GPIO Port Pins
  • 2-Analog Port Pins
  • RTC
WiFi Specs
  • IEEE 802.11 b/g/n
  • Frequency Band: 2.4 ~ 2.462 GHz

HioTron IoT Platform

The hIOTron IoT Platform supports five major D’s such as Device Management, Device Connectivity, Data Storage, Data Analytics and Dashboard/Application enabled for the management of an IoT project life cycle. The Hi-Gate stream data to the hIOTron platform where all the analytics, storage, automation will be carried out.

The Hiotron IOT Platform

Dashboard & Mobile App

You can monitor & control your project application through the Dashboard & Mobile Application provide by HioTron and do unlimited customization from anywhere, anytime.

The Modular & Enterprise IoT development kit comes in 3 versions are Standard, Advance & Customized which can be selected based on applications requirement. The kit pricing is currently not disclosed. More information about the Kit can be found here and for more details on about getting started with the kit can be found here.

Epiq Solutions Develops Wideband RF Transceiver SDR Module Running Linux On Zynq SoC

Epiq Solutions, a company from the USA, has included a new member of its Sidekiq line of Software-defined radio (SDR) add-on cards called the Sidekiq Z2. Dimensions of this card are only 51 x 30 x 5mm, the size of a full-size mini-PCIe card, the Sidekiq Z2 computer-on-module is advertised as “the world’s smallest wideband RF transceiver + Linux computer in a product-ready module”. The module is most suitable for handheld RF testing and measurement, remote RF sensing, wireless security applications, and CubeSat/UAS datalinks. A carrier board is also available with this module.

Sidekiq Z2 SDR Module
Sidekiq Z2 SDR Module

Unlike previous Sidekiq cards, the Sidekiq Z2 can act as a standalone computer, running Linux on a Xilinx Zynq-7000 series Arm/FPGA SoC. Like the original Sidekiq, which is available in mini-PCIe or M.2 form factors, the Sidekiq Z2 operates at 70MHz to 6GHz. There’s also a Sidekiq X2, which uses the VITA57.1 FMC form factor, which supports 1MHz to 6GHz frequencies.

Epiq claims, the new Sidekiq Z2 can boot Linux in under two seconds, with a typical system power consumption under 2 Watts. The Zynq comes with 512MB DDR3L RAM and 32MB QSPI flash. The SoC drives USB 2.0 OTG, serial UART, JTAG, and GPIO signals to a carrier board.

The shielded AD9634 1Rx + 1Tx transceiver has a 4-band Rx pre-select filter bank and an up to 61.44 Msamples/sec sample rate. The 40MHz TCVCXO ref clock features +/- 1 PPM stability. The 3.3V, 8-gram module supports -40 to 85°C temperatures. The module also offers many U.FL antenna connectors.

The company offers a Sidekiq Z2 Evaluation Kit (EVK) that includes two Sidekiq Z2 cards pre-loaded and supported by Analog Devices’ open source IIO reference design, along with two simple carrier cards. An optional Platform Development Kit (PDK) offers enhanced support and an optimized FPGA reference design to maximize processing capability of the FPGA. Epiq Solutions also presents applications for embedded RF spectrum analysis as well as 2G/3G/4G cellular network survey.

The Sidekiq Z2 is available now at a price of $649 for 1,000+ unit orders. The Sidekiq Z2 EVK and PDK also appear to be available, with pricing undisclosed. More information may be found in the Epiq Solutions Sidekiq Z2 announcement and product page.

Arduino-Based Two-Way Pager

This Arduino-based pager by  Mike Schaus will allow you to send and receive real SMS text messages. This messaging device has its own SIM card and phone number.

In order to build this project you need the following parts:

And you will need to use this software to run the project: Hologram Data Router.

This project was made possible as part of Hologram’s Hacker-In-Residence program, The Hologram Global SIM Card allows you to connect you IoT device everywhere. Paired with a powerful device management platform and API. It provides a cellular data service that works with any device that accepts a SIM card. In addition it is totally inexpensive.

GSM shield, the Hologram things, and Arduino stacked on top of each other made a good combination to build such a project. For powering the project, Mike had used a 9V battery as an option, and still, powering from USB is possible.

Mike had designed this project so it could be used by children instead of a real cell phone, or it could be used as an “SOS” button for someone working alone outdoors or even exercising.

Check this video to know how this project works:

The amazing thing about Adafruit LCD shield that it only uses 2 pins of Arduino since it works over the I2C bus, which results with many places left for future features.

This is the schematics of the project: It is super easy, the wires mean putting the pieces on top of each other.

And here is the Arduino code used:

#include <GSM.h>

#define PINNUMBER ""

// include the LCD library code:
#include <Wire.h>
#include <Adafruit_RGBLCDShield.h>
#include <utility/Adafruit_MCP23017.h>

// The shield uses the I2C SCL and SDA pins. On classic Arduinos
// this is Analog 4 and 5 so you can't use those for analogRead() anymore
// However, you can connect other I2C sensors to the I2C bus and share
// the I2C bus.
Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();

// These #defines make it easy to set the backlight color
#define OFF 0x0
#define ON 0x1

// make the arrow special character on the LCD
const byte arrow[8] =
{
 B00000, B00000, B01000, B01100, B01110, B01100, B01000, B00000
};

// initialize the GSM library instance
GSM gsmAccess(false); // include a 'true' parameter for debug enabled
GSM_SMS sms;

// char array of the telephone number to send SMS
// change the number 12125551212 to a number
// you have access to
char remoteNumber[20]= "12125551212";

// Array to hold the number a SMS is retreived from
char senderNumber[20];

// char array of the possible outgoing messages to choose from the menu
char* responses[]={"Mike=Awesome!", "Yes", "No", "Howdy!"};
//#define NUMRESPONSES 4 // if someone knows how to calculate this instead, I'm all ears
#define NUMRESPONSES (sizeof(responses)/sizeof(char *)) // thanks to Steve Kemp's comment!

int position=-1; // this way the first button press will always show first option of the menu

int inByte = 0; // incoming serial byte for keyboard interface

boolean backlight = true; // track backlight status for toggling

unsigned long previousMillis = 0; // will store last time messages were checked
#define CHECKINTERVAL 1500 // how often to check for text messages

void setup() {
  // put your setup code here, to run once:

  // initialize serial communications
  Serial.begin(9600);
  Serial.println(F("SMS Message Sender -- starting up..."));

  // set up the LCD's number of columns and rows: 
  lcd.begin(16, 2);

  // Print a message to the LCD
  lcd.print(F("Hello, Hologram!"));
  lcd.setCursor(0, 1);
  lcd.print(F("Starting up..."));
  lcd.setBacklight(ON);

  // set up the arrow character for display
  lcd.createChar(0, arrow);

  // connection state
  boolean notConnected = true;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while(notConnected)
  {
    if(gsmAccess.begin(PINNUMBER)==GSM_READY) {
      notConnected = false;
      Serial.println(F("GSM is connected because you are so awesome"));
      Serial.println(F("Waiting for messages, or send with \"s\""));
      Serial.println();

      lcd.clear();
      lcd.setCursor(0,0);
      homeScreen();

    }
    else
    {
      Serial.println(F("Not connected"));
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print(F("Not connected"));
      delay(1000);
    }
  }
}

// this is the menu system function
void showResponses() {
//  Serial.println(position); // only for debugging menu system

  lcd.clear();
  lcd.setCursor(0,0);
  
  // make sure cursor position is legal
  if (position<0) position=0;
  if (position>NUMRESPONSES-1) position = NUMRESPONSES-1;

  // write current selection and next option if there is another option
  lcd.write(0); //arrow character
  lcd.print(position+1);
  lcd.print("-");
  lcd.print(responses[position]);
  if (position < NUMRESPONSES-1) {
    lcd.setCursor(0,1);
    lcd.print(" ");
    lcd.print(position+2);
    lcd.print("-");
    lcd.print(responses[position+1]);
  }
}


void homeScreen() {
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("SMS Messenger!");
  lcd.setCursor(0,1);
  lcd.print("Ready; up/dn snd");

  position=-1; //reset response selection
}


void receiveSMS(){
  
  char c;

  // If there are any SMSs available()
  if (sms.available()) {
    Serial.println("Message received from:");

    // Get remote number
    sms.remoteNumber(senderNumber, 20);
    Serial.println(senderNumber);

    lcd.clear();
    lcd.setCursor(0,0);
    backlight = true;
    lcd.setBacklight(ON);

    // An example of message disposal
    // Any messages starting with # should be discarded
    if (sms.peek() == '#') {
      Serial.println("Discarded SMS");
      sms.flush();
    }

    // Read message bytes and print them
    // because sms.read only returns one character at a time
    int i=0;
    while (c = sms.read()) {
      i++;
      Serial.print(c);
      if (i==17) lcd.setCursor(0, 1); // move to next line if needed
      if (i<33) lcd.print(c); // don't try to print more than 32 chars just in case
    }

    Serial.println("\nEND OF MESSAGE");

    // Delete message from modem memory
    sms.flush();
    Serial.println("MESSAGE DELETED");
    Serial.println();

    // wait for right button to acknowlege before letting program continue
    boolean acknowledged = false;
    while(!acknowledged) {
      uint8_t buttons = lcd.readButtons();
      if (buttons & BUTTON_RIGHT) acknowledged = true;
      delay(50); //short delay for troubleshooting -- without this it behaves strangely
    }
    homeScreen();
    delay(400); // prevent multiple presses in a row
  }
}

// function to show message options in the serial monitor
void printResponseOptions(){
  for(int i=0; i<NUMRESPONSES; i++){
    Serial.print(i);
    Serial.print("-");
    Serial.println(responses[i]);
  }
  Serial.println();
}


void sendSMS(const char* txtMsg){

  Serial.print("Message to mobile number: ");
  Serial.println(remoteNumber);

  // print sms text info
  Serial.println("SENDING");
  Serial.println("Message:");
  Serial.println(txtMsg);

  // send the message
  sms.beginSMS(remoteNumber);
  sms.print(txtMsg);
  // next, add a signature to the chosen message
  sms.print(" --Be sure to connect with me on my blog http://mschausprojects.blogspot.com");
  // call endSMS function to finish sending; it will return 1 if successful
  if (sms.endSMS()==1) {
    Serial.println("\nCOMPLETE!\n");
    homeScreen();
  }
  else {
    Serial.println("\nERROR\n");
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("error");
  }
  Serial.println();
}



void loop() {
  // put your main code here, to run repeatedly:

  uint8_t buttons = lcd.readButtons();

  if (buttons) {
    if (buttons & BUTTON_UP) {
      position--;
      showResponses();
      backlight = true;
      lcd.setBacklight(ON);
    }
    if (buttons & BUTTON_DOWN) {
      position++;
      showResponses();
      backlight = true;
      lcd.setBacklight(ON);
    }
    if (buttons & BUTTON_LEFT) {
      homeScreen();
      backlight = true;
      lcd.setBacklight(ON);
    }
    if (buttons & BUTTON_RIGHT) {
      backlight = !backlight; // toggle the backlight state
      if (backlight) lcd.setBacklight(ON);
      else lcd.setBacklight(OFF);
      homeScreen(); // have to write to screen after turning light off, otherwise it goes blank
    }
    if (buttons & BUTTON_SELECT) {
      // make sure cursor selected position is legal
      if (position<0) position=0;
      
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Sending...");
      lcd.setCursor(0,1);
      lcd.print(responses[position]);
      backlight = true;
      lcd.setBacklight(ON);
      sendSMS(responses[position]);
    }
    delay(200); // prevent multiple presses in a row
  }


  // this is for serial interface only, not related to LCD and buttons
  // send a message when I type "s" in serial monitor
  // then wait for my selection of the response number
  if (Serial.available() > 0) {
    inByte = Serial.read(); // get incoming byte
    if (inByte == 's') {
      printResponseOptions();

      while (Serial.available() > 0) {  // clear the keyboard buffer just in case
        char junk = Serial.read();
      }
  
      while (Serial.available() == 0) ;  // Wait here until input buffer has a character
      inByte = Serial.parseInt();
      // would want to check for valid choice here to be more robust
      sendSMS(responses[inByte]);
    }
  }

  // check for new messages only once every few seconds to keep interface more responsive
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= CHECKINTERVAL) {
    previousMillis = currentMillis;
    receiveSMS(); // takes about 26ms when there are no messages
  }
}
CREDITS

R3tkcxkom1pu38aqb0bh

More details about this project are available on hackster.io and Mike’s own blog post. You can learn more about his projects on the same blog.