Open Source Flipper Zero, Thread, Matter, and Zigbee on ESP32, Arduino go Zephyr, and more!

0:00:00 / -

Watch now on YouTube Watch now

The Internet Speed-o-meter

Made by alistair / Displays

About the project

A physical display to show how much of your Internet connection is being used.

Connectivity contest winner

Project info

Difficulty: Moderate

Platforms: Espruino

Estimated time: 2 hours

License: GNU Lesser General Public License version 3 or later (LGPL3+)

Items used in this project

Hardware components

	ESP8266 Serial WIFI Module Mini ESP8266 based module	x 1
	ESP-01 Adaptor module Adaptor for the module with voltage regulation	x 1
	Micro Servo	x 1
	3mm hardboard or acrylic sheet I used a 20mm x 15mm sheet but you can be creative	x 1
	Regulated 5v power supply	x 1
	Clamp or plate stand Something to hold up your creation	x 1
	1mm Acrylic sheet I used a 10mm x 40mm sheet	x 1
	Network firewall/router Most routers that support SNMP (Simple Network Management Protocol) will work. We have a RV042G.	x 1
	Double sided sticky pads	x 1

View all

Software apps and online services

	Arduino IDE Version 1.6 or above
	ESP8266 Arduino Core Available from https://github.com/esp8266/Arduino

Hand tools and fabrication machines

	Soldering Iron	x 1
	Laser Cutter This is optional. You can use hand tools, or just a knife and cardboard if you prefer.	x 1
	ESP-01 Programmer	x 1

Story

Introduction

This is a little project to monitor the usage of a building's internet connection. There was not easy way for someone who was technically minded to monitor this never mind making the the end users. This is an answer to that problem. The hardware communicates with the central router/firewall, asks how much data has passed thought it, subtract that from the last figure it was told, and then moves a physical arrow to show that figure to everyone. Although it is called the "Speed-o-meter" in the great style of Wallace and Gromit it should more accurately be thought of as a percentage of bandwidth usage meter.

Step 1 - Programming the microcontroller

At the heart of the system is an ESP-01 module. Any ESP6266 based development board or Arduino with networking should run the code with little or no modification.

I am going to assume that you are able to load the code from this listing to the microcontroller. If you don't know how to do that you can find plenty of tutorials online.

You will need to change three settings in the supplied code. First you will need to replace {wifi_ssid} and {wifi_password} with your wifi details. Next you need to change

{top_connection_speed} to the

maximum speed of your connection. Note that this needs changing in two locations.

The current code will monitor both upload and download rates and pick the highest to show. If your connection is

asymmetric (has a different upload rate to your download rate) then you can tweak the

updateServo() function to reflect this. This is completely optional and only for programmers how are obsessive compulsive about accuracy. Basically if you are like me.

Once these settings have been changed and the code uploaded you are ready to go on to the next step.

Step 2 - Assembling the hardware

Rather than create a new circuit board or have many cables all crammed together at the back I decided to "hack" the fairly common ESP-01 adapter. This has the main advantage of regulating the power down from the 5V supply we are going to use down to the 3.3v required by the ESP-01 module. If we use the TX pin as a data pin for controlling the servo then by pure luck the GND/SVV/DATA pins on the adapter are in the correct order for a standard servo.

I removed the RX pin to reduce the risk of the servo being plugged in incorrectly but this is optional.

It is worth noting that the ESP8266 sends some serial data is sent out of the TX pin on boot and that can crash some servos. If this is the case you will need to modify the design to use the RX pin instead, or try another servo.

As we have used the VCC and GND pins to connect the servo we need to inject power another way. This is a simple hack with the power cable being soldered on the underside of the board.

The power supply is a 5v "wall wart" with a power cord on. I extended it with some speaker cable but the original was long enough for most projects.

Step 3 - Assembling the display

The last significant step is to add the electronics and mechanics to a board and create the physical display.

This listing has some CAD drawings that can be used to laser cut and board and arrow although this is where your creativity can flow. Why not create your own design?

Finally the project needs mounting somehow. You could mount it on the wall or place it on the mantelpiece. I have used picture frames and plate stands to do this with other projects, but for this on I decided to simply add a workshop clip to the back to hold it upright on the workshop shelf.

Step 4 - Sit back and enjoy

That is it all done. When you power it up it will take a free seconds to settle down and then you will see how much data is going through your network. If not a lot is happening then run a speed test and see how much of your bandwidth you can use.

Schematics, diagrams and documents

Overall Schematic

CAD, enclosures and custom parts

Scale

The design for laser cutting the scale.

Pointer

The design for laser cutting the pointer.

Code

Main Arduino (ESP8266) code

The main code for the project. You will need to change the wifi details ({wifi_ssid} and {wifi_password}) and update the speed for your Internet connection ( {top_connection_speed} in Mbps).

/*
 *  This sketch to monitor gateway usage vis SNMP and
 *  to move a servo to show traffic.
 *  
 *  Configured for the Cisco RV024G via the LAN port
 *
 *  Alistair MacDonald 2018
 *  
 */

#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <WiFiUdp.h>
#include <Servo.h>

// Create wifi, networking and servo interface objects
ESP8266WiFiMulti WiFiMulti;
WiFiUDP Udp;
Servo myservo;

// Create a buffer for UDP communications
int const incomingBufferSize = 128;
char incomingPacket[incomingBufferSize];

// Specify the request packets
// Kudos to http://www.rane.com/note161.html and http://www.net-snmp.org/ for helping understand the SNMP packet

int const requestSize = 42;

byte uploadRequestPacekt[requestSize] = { 0x30, // Sequence Complex Data Type
                                         0x28, // Request Size (less this 2 byte header)
                                         0x02, // Version Type Integer
                                         0x01, // Version Length 1
                                         0x00, // Version Number 0
                                         0x04, // Type Octet String
                                         0x06, // Length 7
                                         0x70, // p
                                         0x75, // u
                                         0x62, // b
                                         0x6C, // l
                                         0x69, // i
                                         0x63, // c
                                         0xA0, // SNMP PDU Type GetRequest
                                         0x1B, // PDU Length
                                         0x02, // Request ID Type Integer
                                         0x01, // Request ID Length
                                         0x0A, // Reuest ID Value LSB (using 10 to id upload)
                                         0x02, // Error Tyne Integer
                                         0x01, // Error Length 1
                                         0x00, // Error Value 0
                                         0x02, // Error Index Type Integer
                                         0x01, // Error Index Type Length 1
                                         0x00, // Error Index Type Value 0
                                         0x30, // Varbind List Type Sequence
                                         0x10, // Varbind List Type Length
                                         0x30, // Varbind Type Sequence
                                         0x0E, // Varbind Type Length
                                         0x06, // Object Identifier Type Object Identifier
                                         0x0A, // Object Identifier Length
                                         0x2B, // ISO.3
                                         0x06, // 6
                                         0x01, // 1
                                         0x02, // 2
                                         0x01, // 1
                                         0x02, // 2
                                         0x02, // 2
                                         0x01, // 1
                                         0x0A, // 10 (Upload)
                                         0x07, // 7 (eth0/lan on RV024G)
                                         0x05, // Value Type Null
                                         0x00 }; // Value Length 0

byte downloadRequestPacekt[requestSize] = { 0x30, // Sequence Complex Data Type
                                         0x28, // Request Size (less this 2 byte header)
                                         0x02, // Version Type Integer
                                         0x01, // Version Length 1
                                         0x00, // Version Number 0
                                         0x04, // Type Octet String
                                         0x06, // Length 7
                                         0x70, // p
                                         0x75, // u
                                         0x62, // b
                                         0x6C, // l
                                         0x69, // i
                                         0x63, // c
                                         0xA0, // SNMP PDU Type GetRequest
                                         0x1B, // PDU Length
                                         0x02, // Request ID Type Integer
                                         0x01, // Request ID Length
                                         0x10, // Reuest ID Value LSB (using 16 to id download)
                                         0x02, // Error Tyne Integer
                                         0x01, // Error Length 1
                                         0x00, // Error Value 0
                                         0x02, // Error Index Type Integer
                                         0x01, // Error Index Type Length 1
                                         0x00, // Error Index Type Value 0
                                         0x30, // Varbind List Type Sequence
                                         0x10, // Varbind List Type Length
                                         0x30, // Varbind Type Sequence
                                         0x0E, // Varbind Type Length
                                         0x06, // Object Identifier Type Object Identifier
                                         0x0A, // Object Identifier Length
                                         0x2B, // ISO.3
                                         0x06, // 6
                                         0x01, // 1
                                         0x02, // 2
                                         0x01, // 1
                                         0x02, // 2
                                         0x02, // 2
                                         0x01, // 1
                                         0x10, // 16 (Upload)
                                         0x07, // 7 (eth0/lan on RV024G)
                                         0x05, // Value Type Null
                                         0x00 }; // Value Length 0

// Variables to store the last read values and times
unsigned long uploadValueLast = 0;
unsigned long downloadValueLast = 0;
unsigned long uploadTimeLast = 0;
unsigned long downloadTimeLast = 0;

// Variables for storing the derived values
double uploadRate = 0;    // Result in Mbps
double downloadRate = 0;  // Result in Mbps

int currentServoPos = 0;
int newServoPos = 0;

// Procedure to request upload data from the gateway
void sendUploadRequest() {
//  Udp.beginPacket(IPAddress(192, 168, 0, 1), 161);
  Udp.beginPacket(WiFi.gatewayIP(), 161);
  Udp.write(uploadRequestPacekt, requestSize);
  Udp.endPacket();
}

// Procedure to request download data from the gateway
void sendDownloadRequest() {
//  Udp.beginPacket(IPAddress(192, 168, 0, 1), 161);
  Udp.beginPacket(WiFi.gatewayIP(), 161);
  Udp.write(downloadRequestPacekt, requestSize);
  Udp.endPacket();
}

// Calculate the servo's new position and set it
void updateServo() {
  double pos = _max(uploadRate, downloadRate);
  pos = _max(0, _min({top_connection_speed}, pos));
  newServoPos = pos/{top_connection_speed}*180;
}

// Function to check for and read new SNMP data
int checkForReply(unsigned long inNow) {

  if (Udp.parsePacket()>0) {
    int lengthRead = Udp.read(incomingPacket, incomingBufferSize);

    lengthRead++; // A quick fix for when Udp.read returns [wrongly] one short
    if (lengthRead>incomingBufferSize) { return false; } // Range check for quick fix

    int pointer = 0;

    // Check the expected message type
    if (pointer>=lengthRead) { return false; } // Range check
    if (incomingPacket[pointer]!=0x30) { return false; } // Chech value is Sequence
    pointer += 1;
    
    // Check the message is the right size
    if (pointer>=lengthRead) { return false; } // Range check
    if ((incomingPacket[pointer]+2)>lengthRead) { return false; } // Chech value is Sequence
    pointer += 1;

    // Skip the version
    pointer += 1;
    if (pointer>=lengthRead) { return false; } // Range check
    pointer += incomingPacket[pointer];
    pointer += 1;

    // Skip the community string
    pointer += 1;
    if (pointer>=lengthRead) { return false; } // Range check
    pointer += incomingPacket[pointer];
    pointer += 1;
    
    // Check the DPU header is for a GetResponse DPU
    if (pointer>=lengthRead) { return false; } // Range check
    if (incomingPacket[pointer]!=0xA2) { return false; } // Chech value is an integer
    pointer += 1;
    pointer += 1;
    
    // Read the request ID
    if (pointer>=lengthRead) { return false; } // Range check
    if (incomingPacket[pointer]!=0x02) { return false; } // Chech value is an integer
    pointer += 1;
    if (pointer>=lengthRead) { return false; } // Range check
    int counterLength = incomingPacket[pointer];
    pointer += 1;
    if (pointer+counterLength>=lengthRead) { return false; } // Range check
    unsigned long requestID = 0;
    for (int offset=0; offset<counterLength; offset++) {
      requestID = (requestID<<8) | incomingPacket[pointer+offset];
    }
    pointer += counterLength;
    
    // Skip the error
    pointer += 1;
    if (pointer>=lengthRead) { return false; } // Range check
    pointer += incomingPacket[pointer];
    pointer += 1;
    
    // Skip the error index
    pointer += 1;
    if (pointer>=lengthRead) { return false; } // Range check
    pointer += incomingPacket[pointer];
    pointer += 1;
    
    // Skip the varbind list header
    pointer += 2;
    
    // Skip the varbind header
    pointer += 2;
    
    // Skip the identifier
    pointer += 1;
    if (pointer>=lengthRead) { return false; } // Range check
    pointer += incomingPacket[pointer];
    pointer += 1;
    
    // Read the data
    if (pointer>=lengthRead) { return false; } // Range check
    if (incomingPacket[pointer]!=0x41) { return false; } // Chech value is a counter Counter
    pointer +=1;
    if (pointer>=lengthRead) { return false; } // Range check
    int dataLength = incomingPacket[pointer];
    pointer +=1;
    if (pointer+dataLength>=lengthRead) { return false; } // Range check
    unsigned long value = 0;
    for (int offset=0; offset<dataLength; offset++) {
      value = (value<<8) | incomingPacket[pointer+offset];
    }

    // Check what to do with the data we recieved based on the ID
    if (requestID==0x0A) { // Upload
      uploadRate = (double) 8/1000 * (value-uploadValueLast) / (inNow-uploadTimeLast); // Result in Mbps
      uploadValueLast = value;
      uploadTimeLast = inNow;
      updateServo();
      return true;
    }
    else if (requestID==0x10) { // Download
      downloadRate = (double) 8/1000 * (value-downloadValueLast) / (inNow-downloadTimeLast); // Result in Mbps
      downloadValueLast = value;
      downloadTimeLast = inNow;
      updateServo();
      return true;
    }
  }

  // We get this far but had nothing to do with the data we recieved
  return false;
  
}

// Setup routine
void setup() {

  // Connect to the WiFi
  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP("{wifi_ssid}", "{wifi_password}");
  while(WiFiMulti.run() != WL_CONNECTED) {
    delay(500);
  }

  // Start listening for SNMP messges
  Udp.begin(162);

  // Switch the TX pin for use as a GPIO pin
  pinMode(1, FUNCTION_3);

  // Connect the servo
  myservo.attach(1);  // attaches the servo on TX pin to the servo object

}

// Keep trach of when we last request data
unsigned long millisLast = 0;

// The main loop
void loop() {

  // Read the time so we only need to di it once
  unsigned long millisNow = millis();

  // Check for a new SNMP message
  checkForReply(millisNow);

  // Move the servo slowly
  if (newServoPos>currentServoPos) {
    currentServoPos++;
    myservo.write(180-currentServoPos);
  }
  else if (newServoPos<currentServoPos) {
    currentServoPos--;
    myservo.write(180-currentServoPos);
  }

  // Check if we need to send another SNMP request
  if ((millisNow-millisLast)>5000) {
    // Send the requests
    sendDownloadRequest();
    sendUploadRequest();
    // Set value to zero if a few updates have been missed
    if ((millisNow-uploadTimeLast)>15000) {
      uploadRate = 0;
      updateServo();
    }
    if ((millisNow-downloadTimeLast)>15000) {
      downloadRate = 0;
      updateServo();
    }
    // Rememebr when we did this to wait another 5 seconds
    millisLast = millisNow;
  }

  // Save a little power
  delay(40);

}

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast

The Internet Speed-o-meter

About the project

Project info