Tag Archives: GSM

IoT Projects Is Now Easier With Bolt IoT Platform

Internet of Things (IoT) is one of the most important technologies these days. It became an essential component of many hardware projects core. And in order to make it easier for developers, Bolt IoT platform appeared as a complete solution for IoT projects.

Bolt is a combination of hardware and cloud service that allow users control their devices and collect data in safe and secure methods. It also can give actionable insights using machine learning algorithms with just some few clicks.

The platform consists of three main components, Bolt hardware module, Bolt cloud, and analytics. The hardware module is a WiFi chip with a built-in 80 MHz 32-bit RISC CPU that operates at 3.3v. It also works as an interface for a set of sensors and actuators through GPIO and UART pins to collect data and react with it.

Bolt Hardware

The next part is Bolt cloud which used mainly for configuring, monitoring, and controlling connected devices. It is a visual interface enables users to setup hardware and prepare the system easily and quickly. In addition, there is a code editor to write and edit codes for the hardware. The special feature is that you can reprogram the system remotely!

Finally, the analysis and monitoring unit provide visualized insights based on machine learning algorithms. The collected data are stored securely on the cloud, and the reports are presented as graphs, charts, or any customized visualization.

Bolt IoT Platform Features

  • A Wifi or a GSM chip
    An easy interface to quickly connect your hardware to cloud over GPIO, UART, and ADC. Also, connects to MODBUS, I2C, and SPI with an additional converter.
  • Robust Communication
    Bolt is equipped with industry standard protocols to ensure a Secure and fast communication of your device data with cloud.
  • Security
    Bolt has built-in safeguards to secure all user data from unwanted third party intrusions and hacks.
  • Machine Learning
    Deploy machine learning algorithms with just a few clicks to detect anomalies as well as predict sensor values.
  • Alerts
    Utilize Bolt’s quick alert system providing invaluable information sent directly to your phone or Email. You can config the contact details and set the threshold.
  • Mobile App Ready
    Customize and control your devices through Mobile apps. Bolt gives you full freedom to design your own mobile app centered around your requirements to monitor and control.
  • Global Infrastructure and Easy Scalability
    Bolt lets you scale from prototype to millions of devices in just a few weeks time.
  • Over the air updates
    Simultaneously program or update all your Bolt powered IoT devices wherever they are. Bolt offers you unparalleled scalability and elasticity to help your business grow.

The scope of applications that may benefit from using Bolt is very wide, including environmental applications, smart cities, electricity management, and much more. Bolt is available for ordering in two packages, the first is for developers and the other is for enterprises. Developers option contains one Bolt unit with three free months of cloud services, and its cost is about $75.

At last, Bolt makers are launching a Kickstarter campaign on the 3rd of November 2017. If you are interested and want to know more about this platform, take a look at the official website and read this detailed features document. Update 6-11-2017 – They achieved the goal of $10,000 USD funding in just 5 hours from launch!

Lightweight GSM Mobile With Arduino UNO and Nextion Display

Avishek Hardin at Arduino Project Hub designed a lightweight mobile using a GSM module, an Arduino UNO, and a Nextion touch screen display. The lightweight mobile has the following features:

  • Make calls
  • Receive calls
  • Send SMS
  • Receive SMS
  • Delete SMS

In this project, he uses a GSM SIM900A module to establish the cellular communication. The GSM SIM900A is an all-in-one cellular module that lets you add voice, SMS, and data to embedded projects. It works on frequencies 900/1800MHz and uses the RS232 standard to communicate with MCUs. Baud rate of this module is adjustable from 9600 to 115200 through specific AT Commands.

This GSM mobile features a Nextion touch display to take input from the user and visualize the GUI. Its easy-to-use configuration software (Nextion Editor) allows you to design your own interfaces using GUI commands. All GUI data is stored in Nextion display instead of the master MCU. Thus, lots of program space in MCUs can be saved efficiently and it makes the development procedure effortless. The Nextion displays communicate with microcontrollers over UART which is supported by a wide range of MCUs.

Required Parts

Required pats for this project
Required parts for this project

Required Tools

Connection

Connect the Nextion display and the GSM module with your Arduino using following instructions:

  • Nextion +5V to Arduino VDD_5v.
  • Nextion RX to Arduino pin 11
  • Nextion Tx to Arduino pin 10
  • Nextion GND to Arduino GND_0v.
  • GSM Rx to Arduino pin 1
  • GSM TX to Arduino pin 0
  • GSM GND to Arduino GND_0v.
Wiring Diagram
Wiring Diagram of Arduino-based GSM mobile

Program The Nextion Display

First of all, you need to design an HMI file using Nextion Editor. This editor allows you to design the interfaces using plug-and-play components like text, button, progress bar, pictures, gauge, checkbox, radio box, and much more. You can set codes and properties for each of these components later.

Design GUI using Nextion Editor
Design GUI using Nextion Editor

In this project, 8 different pages are used to design the GUI. All the icons used are easily available on the internet. Icons are resized and modified using an open source tool paint.net. Touch events like press and release are also covered when components are touched. More information on Nextion display commands can be found on this wiki page.

Designing dial pad using Nextion Editor
Designing dial pad using Nextion Editor

Steps To Upload

  • Load the .HMI file into the editor. Link to the Github repository is here.
  • Compile the .HMI file (just under the menu bar).
  • Go to File > Open build folder > Copy the .tft file > Paste into SD card. Note: make sure the SD card is formatted to FAT32.
  • Once copied, insert the SD card into the Nextion display and then turn the power on.
  • Wait for the .tft to upload.
  • Power off the Nextion, securely remove the SD card and then again power on the display.
  • Now you should see your new interfaces on the Nextion Display.

Program The Arduino

The Arduino is the brain of this project. It takes input from the Nextion display, sends commands to GSM module to create the cellular connection, and shows information on the display. This project does not use any Nextion library due to lack of documentations and difficulties to understand. Moving on without using libraries seems tough but it is really not.

The code can be found on the Github repositorySimply download it and upload to the Arduino board using the Arduino IDE. If you are using some other board than Arduino UNO, then don’t forget to select that specific board in Arduino IDE before uploading.

Editing the Arduino sketch
Editing the Arduino sketch
compile and upload the sketch using Arduino IDE
compile and upload the sketch using Arduino IDE

Open the Serial Monitor, you should see the AT command log for each event triggered from the Nextion Display.

Serial Monitor shows the AT command log
Serial Monitor shows the AT command log

Important Note

By default, the GSM module has an SMS buffer size of 20. Unfortunately, this Arduino-based mobile cannot display all the 20 messages at once on the Nextion display as it gives a buffer overflow while compiling the Nextion code. Hence, the Nextion display is programmed to show maximum 10 messages at once. If 10 or more SMS are present on the GSM buffer, the Low memory warning icon will be displayed on the Nextion display.

SMS log showing received messages on Nextion display
SMS log showing received messages on Nextion display

Video

Watch the demonstration video to understand how this Arduino-based lightweight GSMmobile works.

 

Stay Connected While Travelling Without Fees With VoxEra

Mobile Roaming allows you to stay connected wherever you are and receive calls and SMSs, but with very expensive cost. So if you don’t have enough budget, you will lose your incoming calls till you are back from a travel.

A team of innovators from Egypt had developed a new device called “VoxEra” that enables you to stay connected when travelling without using roaming service. Simply, all you have to do is to put your SIM card into VoxEra and connect it to the internet, install VoxEra App into your smartphone and enjoy calling and texting with a high quality connection.

Compared with other similar products, VoxEra uses a standard GSM network instead of VoIP service, which mean that other people don’t have to install any application to connect with them. It will also use your own SIM card with the same mobile number and will give you more options forward to record incoming calls when you are offline.

Think of VoxEra as a message converter; when you receive a call, VoxEra receives a GSM call and then converts it into a VoIP call. Then, it sends that converted message to the Cloud through the Internet. In the same way, while making a call, VoxEra sends a message through the Cloud. When the device receives the message, it converts it into a GSM call, at which point, it is delivered to the number you’ve dialed.

The voice roaming killer is now live on Kickstarter and has already reached a $28K fund! Super early bird edition is still available for $79. After the campaign, the device will be available for $119 with free shipping worldwide.

PingPong IoT Development Board – Connecting Hardware to the Cloud

Germany-based Round Solutions developed the PingPong, a powerful and flexible hardware platform for IoT and machine-to-machine (M2M) applications. The PingPong can be used for both wired and wireless connections. The modular hardware design can integrate custom-specific applications and communication standards into a single solution platform that has a very small form factor.

The basic hardware platform of PingPong has a 32-bit 200MHz Microchip PIC32MZ microcontroller unit (MCU) running C/C++ code. It supports RTOS or Real Time Operating System which is available as Open Source Software so that developers can adapt their applications individually and bring them to market more swiftly. The base board of PingPong has following features:

  •  A high-speed cellular module
  • A component for high-precision Global Navigation Satellite System (GNSS)
  • An Internet connectivity module
  • USB
  • CAN-Bus and many other components

    PingPong - The IoT Development Board RTOS 3G Version
    PingPong – The IoT Development Board RTOS 3G Version

One amazing feature is, the high-speed cellular module and the numerous interfaces can be controlled over the cloud. So, you don’t have to keep it wired all the time in order to control all those modules.

Technical Information:

Having an area of 85×52 mm², the PingPong is really tiny in size compared to its features. It has a booming 4 MB flash memory which is perfect for IoT purpose. PingPong beats other IoT modules with the wireless technologies it possesses – 2G, 3G, Galileo E1, GLONASS, and GPS. Supported bands(MHz) for cellular communication are 1800, 1900, 2100, 850, and 900. It communicates with other MCUs over I²C protocol which is widely used by almost all types of MCUs.

The greatest strength of PingPong is its expandability. The developer can overcome all the limitations of PingPong by adding a variety of expansion cards to the PingPong platform. Some examples of expansion cards are, wireless local area network (WLAN), Bluetooth, input/output (I/0), Iridium satellite communications, ISM/RF, SigFox, near-field communication (NFC), radio-frequency identification (RFID), and camera connectivity.

Applications:

  • Send and receive data: Pingpong offers different possibilities for sending and receiving data. Whether it’s wired over Ethernet or on the go with built-in GSM/GPRS module, PingPong does its job of exchanging data continuously.
  • Remote control: The PingPong can be used to control processes remotely via its outputs. Using the digital output with a relay can either enable or disable the power supply of an application.
  • Positioning: With its built-in GNSS and GPS module, the PingPong can also be used to determine position, motion, speed and acceleration.
  • Telemetry: The PingPong can be connected to a wide variety of sensors to process digital and analog measurements. Thus, for example, temperature values collected from a temperature sensor can be transferred via analog input to the PingPong.

And there are much more applications. From hobby projects to industrial development, sensor data collection to the smart home project – anywhere you can use this versatile board.

PingPong supports numerous expansion cards
PingPong supports numerous expansion cards

Important Links:

To learn more on this amazing IoT board, watch these three videos:


Conclusion:

The PingPong is a surprisingly powerful IoT module. It’s a developer’s dream. Having all these features in one package is truly outstanding. The feature of adding expansion cards makes it even stronger.

You can purchase your own PingPong from roundsolutions.com at €199.00. It may seem to be a bit overpriced, but it’s really not. Just consider the features you are getting in a single package and you’ll realize it.

Send Texts or Make Calls With This Tiny GSM Board

@ blog.tindie.com

This quad band GSM board is claimed to be the worlds smallest of its kind. We have no way to verify this bold claim but let’s all agree that this is a pretty small board that lets you send texts and make calls. The GSM feature is an addition to the OLEDiUNO Cube range that we have mentioned previously on the blog.

Send Texts or Make Calls With This Tiny GSM Board – [Link]

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.

$3.6 GPRS GSM Module from Ai Thinker

ShenZhen Ai-thinker CO.,a leading enterprise in the Internet of Things (IoT) industry and the maker of the ESP-12E module, had launched a new killer module: $3.60 GSM GPRS A6 Module!

Providing a chip cheaper than the popular ESP8266 seems to be promising and opens doors for future IoT inventions. This module seems to be a big competitor for SIM900 series module.

This chip is considered the cheapest platform that connects to the internet via GSM/GPRS and at the same time works as a traditional GSM module.

a6-ai-gsm-module-my-electronics-lab

a6-gsm-gprs-ai-thinker-breakout-board-with-antenaThis module is coming in market as a SMT package, like ESP12E, but there are many vendors already making breakout board with antenna out and SIM card slot, for an extra dollar.

Technical Specifications
  • Dimensions 22.8 × 16.8 × 2.5mm;
  • Working temperature -30 Celsius to + 80 Celsius;
  • Working voltage 3.3V-4.2V;
  • Power voltage> 3.4V;
  • Standby average current 3ma less;
  • Support GSM / GPRS four bands, including 850,900,1800,1900MHZ;
  • Support China Mobile and China Unicom’s 2G GSM network worldwide;
  • GPRS Class 10;
  • Sensitivity <-105;
  • SMT 42PIN
  • Support voice calls;
  • Support SMS text messaging; can use SMS to config module
  • Support GPRS data traffic, the maximum data rate, download 85.6Kbps, upload 42.8Kbps;
  • Supports standard GSM07.07,07.05 AT commands and extended commands;
  • Supports two serial ports, one serial port to download an AT command port;
  • AT command supports the standard AT and TCP / IP command interface;
  • Support digital audio and analog audio support HR, FR, EFR, AMR speech coding;
  • Support ROHS, FCC, CE, CTA certification;
  • Support up to 8 channels network connections
  • Low power consumption: standby least is 3mA
  • A6 semi-hole technology, enabling rapid production modules through standard SMT equipment, providing customers with highly reliable connection, especially for automation, large-scale, low-cost modernization of production methods.

It can be used with AT Commands like the commands for other GPRS/GSM modules SIM800/SIM900. Thus, it is possible to use the same libraries

How to use A6 GSM GPRS module:
  1. Connect UART_TXD to RX of the FTDI
  2. Connect UART_RXD to TX of the FTDI
  3. Connect GND to the GND of the FTDI
  4. Connect VCC5.0 To the PWR_KEY pin
  5. Connect a Micro Usb for the power(with any smartphone charger)
  6. After 4-5 second you can remove the connection between VCC5.0 and PWR_Key
A6 GSM GPRS Module Pinout
A6 GSM GPRS Module Pinout

You can use it with the Arduino software, just choose a port and open the serial monitor with 115200 baud. To set up the connection send ”AT”, and if you see “OK” then everything works.

A project using the module, download the software, documents, and codes from here. Also watch a test demo.

The module is said to be the smallest available industrial grade quad-band GSM / GPRS module. You can order A6 module for $3.20 from ElectroDragon store.

Datasheet is only available in Chinese. More details about the A6 – A6c – A7 family can be reached at this document and at the A6 module documentation.

A20 Plus – WIFI/GPRS/GSM/CAMERA module

cd322635060704491

Raymond Tunning shares the information he found about the new A20 modules bought from taobao.

A20 Plus – WIFI/GPRS/GSM/CAMERA module – [Link]

Send and Receive SMS with GSM SIM900 Arduino Shield

F5XE6R3IQOQRUEA.MEDIUM

In this Instructable, you will learn how easy it is to send and receive SMS messages over GSM with Arduino.

One of the essential elements of building IoT project is the ability to connect devices. Wi-Fi and Bluetooth are good low cost choices, but they work only at close ranges, or in hotspot areas. When the device needs to be at a remote location GSM is a good and easy to setup option.

Send and Receive SMS with GSM SIM900 Arduino Shield – [Link]

8V97051 Low Power Wideband Fractional RF Synthesizer

This design features a low power wideband RF synthesizer that is used in GSM receiver cards. It has dual differential and open drain outputs with frequency range of 34.375MHz to 4400MHz(in continuous range). The logic compatibility is 1.8V while the system is running on a single 3.3V supply. It has -143dBc/Hz Phase Noise (PN) performance at 1MHz Offset for every 1.1GHz output. It is also capable of mute function at RF_OUT that is accessible via mute pin or SPI command. It is low power with only 380mW average power consumption while RF_OUTB is not in used.

The design is comprised of 3 major parts. The first part consists of IDT8V97051NLGi wideband RF synthesizer/PLL supports the output frequencies with Voltage Controlled Oscillator (VCO). The temperature compensated crystal oscillator close to the RF input helps in the precision of signal while the other parts are filters that are used in various purposes like minimizing undesired noise. The second part consists of the USB 2.0 high speed to UART/FIFO IC that is used for system interface while the I2C-bus to SPI bridge IC controls the sequences, protocol, and timing of the signal. The last part is power supply management of the system in which it is provided with RC filters in every line to ensure minimal noise are included in the supply.

The design is applicable in multi-carrier, multi-mode Frequency Division Duplexing (FDD) and Time Division Duplexing (TDD) base station radio card. It optimizes multi-service base stations during its service as a local oscillator that generates a large variety of frequencies to mixers while maintaining excellent PN.

8V97051 Low Power Wideband Fractional RF Synthesizer – [Link]