BaoFeng BF-F8HP Radio Charging System Diagram

BaoFeng BF-F8HP information here.
-----

-----

WSPR: Raspberry PI 20 Meter 100mW QRP Transmitter

The summary:
      - get a Raspberry PI
      - get a General Class FCC license (if you don't have one)
      - buy the WsprryPI hat
      - install the SW from GitHub
      - be amazed by your contact report (map above and video below) without ever talking to anyone.
-----
More detail:
There has been an amateur radio (ham) curiosity rattling around in my brain, but the urge was not enough to act on it.  Then I heard about WSPR on the Embedded.fm podcast.  WSPR stands for Weak Signal Propagation Reporter.  Basically there are WSPR beacons that transmit with very low power (100mW for my rig) to WSPR receivers located around the world.  If a WSPR receiver picks up your WSPR beacon signal the communication is logged.  It's used to help study radio frequency propagation and it's fun.  Take a look at the propagation map on WSPRnet.org.  It is amazing the distances these very low power HF signals travel.
---
We then learned that to transmit as a WSPR beacon on the HF bands a General Class FCC Amateur Radio license was needed.  That provided the motivation to get our "ticket".  The sample tests did not seem difficult and we were pleased to find that learning Morse Code (CW) was no longer required.  Fast forward a few weeks and we are graciously entrusted by our Federal Government to be an amateur radio operator.  Cost: $15.  So now what....
----
First we did what all new hams do and buy a cheap HT radio, but that's not important here....

-----

Back to the WSPR beacon...  There are many WSPR protocol transmitters that can be purchased.  We went with the 20m WSPR-Pi kit from TARP.org.

The TARP.org kit was chosen for a few reasons: 1st) we understand the RasPI and had a spare. 2nd) the 'kit' plugs right onto the RasPI GPIOs. 3rd) it seemed really simple.
-----
And, really simple it was (kinda).  We downloaded the software that runs the WSPR transmitter from GitHub and.... it didn't compile.  No worries because after installing a new, fresh, clean OS on the RasPI everything installed as planned.  Next step was to screw on two ~18 feet wires into the transmitter antenna terminals and throw those wires on the floor. The README gave us what was needed to run the software from the terminal command line.  Five minutes later and we already had several transmission confirmations.  Beer was consumed!!!

A comment of CAUTION:  Don't route the antenna or wires to the antenna directly over the RasPI.  When the WSPR beacon transmits the RF interference can cause a reboot.  Moving the position of the antenna should corrrect.
-----
Here is a 24 hour animation of our contacts:

-----
And here is the WSPR beacon signal as it appears on our Tektronix MSO5 scope: 

 -----
In our short exposure we have gotten a lot more from the ham radio hobby than expected.  Long "ragchews" probably will not be our thing, but there are so many other facets.  For example, we're currently building a Yagi antenna with the goal of communicating (briefly) through a passing satellite or capturing a SSTV image from the ISS.  Anyone that has been curious about the hobby should take another look.  There are many other things to explore (beacons, digital modes, telemetry, satellites, moon-bounce, meteor scatter, remote control, APRS, JT65, fox hunting, amateur TV, etc.) than talking on the air and that makes it interesting.
-----
73s!

Arduino / MOSFET Controlled High Bright LED Motorcycle Light

In our modern world, high bright LEDs can be purchased cheaply to provide low current draw auxiliary lighting to any vehicle.  Then it is only a simple matter of connecting the LED to 12VDC and head down the road enjoying your new found wattage.  However, there is no fun in the easy way.  Follow the instructions below to build your own custom high bright LED driver.
-----
OBJECTIVE: A high bright LED for installation on a Kawasaki KLR650 motorcycle with six programmable modes:

• OFF
• 33% bright
• 50% bright
• 100% (full) bright
• "Breathing" mode
• STROBE mode

-----
To keep the project simple, an Ardunio Nano is used to control the Gate Voltage (Vgs) of a MOSFET.  When Vgs is HIGH the MOSFET switches on and the high bright LED turns on.  By using Pulse Width Modulation (PWM) on the Arduino the brightness of the high bright LED can be easily controlled.
-----
You will need the parts in the schematic.  All are readily available from Amazon or a host of electronic parts distributors.  Of course, the 12VDC power source is provided by the vehicle. 

---
On the bench the rig will look and function something like this:

 ----
The schematic leaves out some details that could be helpful.  To control the MODE selection and the STROBE effect we used a handlebar mounted switch. I also drilled a small hole to mount the STATUS LED into the handlebar switch.  With coded flashes, the STATUS LED lets the rider know the current mode of the rig.  Pressing the GREEN button selects the next mode.  Move the turn signal switch to "R" to turn on the STROBE effect.  The image below provides some real world connection details.  If you get the same handlebar switch we recommend buzzing out the wires first to verify them because the unit came with no diagram and low cost manufactures often change these details.

----
After you use the Arduino IDE to download the source code provided below into your Ardunio Nano you will need to mount to high bright LED.  We got a mounting bracket from eBay.  In the end it came out pretty nice.

-----
Here is a video of the rig running through all the modes.  The quick strobe at the beginning is a wake up self test.  The high bright LED swamps out the camera light sensor and doesn't provide a good indication of the actual effect.  One note:  It turns out Apple has a patent on the Breathing LED pattern (well, for a sleep indicator anyway).  Use the "breathing LED" portion of the code with caution or, I guess,  risk a cease and desist order.

-----
Here is the Arduino source code for the rig.  Good luck!
//------------------------------------------------------------------------
/*
KLR650 Aux LED Driver
July 2019
WhiskeyTangoHotel.Com
Ardunio Nano (should work with other Arduinos)

Program controls a IRF510 MOSFET to drive a High Bright LED Array
(I recommend a heat sink on the MOSFET, but it should be fine without it)
A button switch selects between modes
A switch sets the LED to fast strobe mode
*/

// MODES:
// 0 = OFF, Bright Examples (vars set below):
// 1 = Low% Bright
// 2 = Higher% Bright
// 3 = FULL BRIGHT
// 4 = Breath

int Number_of_Modes = 4;  // Needed for program control.
int LED_Mode = 1;  // LED_Mode sets the startup condition and is changed with button pushes in the main loop.
int Status_LED = 3;   // PWM output pin for the LED status light.
int FET_Drive = 5;  // PWM output pin to drive the gate on the MOSFET.
int mode_buttonPin = 4;  // Mode changing push button (wired to GND via 10K)
int strobe_buttonPin = 8;  // Mode changing push button (wired to GND via 10K)
boolean buttonState = LOW;  // for the mode_ and strobe_ detect

// Percent brightness of the 3 modes.  Example:  35% = .35, 100% = 1.00
// LED_Mode = 0 is OFF
float MODE1_Bright = .20;
float MODE2_Bright = .50;
// LED_Mode = 3 is FULL Bright: digitalWrite(Status_LED, 255);  // 255 turns LED FULL BRIGHT
// LED_Mode = 4 is Breath

int Breath_Rate = 15;  //Higher is faster
int Breath_Max_Bright = 170;
int Breath_Min_Bright = 20;
int Flash_delay = 50;  // sets delay for strobe mode and self test (50 is a good start)

void setup()
{
  // Serial commands are for debugging
  //Serial.begin(9600);
  //Serial.print(LED_Mode);
  //Serial.println();
  pinMode(Status_LED, OUTPUT);      // sets the digital pins as output
  pinMode(FET_Drive, OUTPUT);
  pinMode(mode_buttonPin, INPUT); // initialize the mode pushbutton pin as an input.  If HIGH change modes
  pinMode(strobe_buttonPin, INPUT); // if HIGH quick stobe/flash mode

  digitalWrite(Status_LED, 0);  // 0 turns the LED OFF
  digitalWrite(FET_Drive, 0);  

  // Self test loop.  Quick flash the status and high bright LED
  for (int i = 0; i <= 4; i++) {
    digitalWrite(Status_LED, 255);  // 255 turns LED FULL BRIGHT
    digitalWrite(FET_Drive, 255);
    delay(Flash_delay);   
    digitalWrite(Status_LED, 0);  // 0 turns the LED OFF
    digitalWrite(FET_Drive, 0);
    delay(Flash_delay);
  } // endSelf Test Loop
}   //end Setup

void stobe_on_button () {  // strobe/flash the LED when HIGH
  int buttonState = digitalRead(strobe_buttonPin);   // check if the pushbutton is pressed.
  if (buttonState == HIGH) {   // button is pressed, strobe the LEDs
    Serial.println(buttonState);
    digitalWrite(Status_LED, 255);  // 255 turns LED FULL BRIGHT
    digitalWrite(FET_Drive, 255);
    delay(Flash_delay);
   
    digitalWrite(Status_LED, 0);  // 0 turns the LED OFF
    digitalWrite(FET_Drive, 0);
    delay(Flash_delay);
    stobe_on_button ();  // check to see if strobe button is still pressed HIGH
  } // endif strobe_button HIGH 
}  // end of strobe_button function

void mode_change_button() {    // function to dectect the mode_buttonPin press to change modes (increment the state machine)
  int buttonState = digitalRead(mode_buttonPin);   // check if the pushbutton is pressed.
  if (buttonState == HIGH) {   // button is pressed, advance to next LED_Mode
    digitalWrite(Status_LED, 255);  // 255 turns LED FULL BRIGHT
    for (int x = 0; x < 25; x++) { // Quick flash the Status LED to confirm button press.
      digitalWrite(Status_LED, !digitalRead(Status_LED));  // toggle state of the on board blue LED. Shows program is running
      delay(100);  
    }  // endfor quick toogle Blue LED
     
    if (LED_Mode >= Number_of_Modes)  {  //  reset state machine to zer0 to recycle LED_Modes
      LED_Mode = 0;
    }
    else {
    LED_Mode = LED_Mode + 1;
    } 

  if (digitalRead(strobe_buttonPin) == HIGH) {
    LED_Mode = 0;  // this is a fast cycle to OFF.  The flash button AND the mode button are HIGH
  }
 
  }  // endif state_mode button pressed
}  // end of mode_change_button function

void loop()  {
  //Serial.print(LED_Mode);
  Serial.println(buttonState);
  Serial.println();

  // LED_Mode - OFF, no lights
  if (LED_Mode == 0) {
    analogWrite(Status_LED, 0);  // 0 turns the LED OFF
    analogWrite(FET_Drive, 0);   // 0 turns the MOSFET
  } // endif LED_Mode = 0

  // LED_Mode - Percent Brightness
  if (LED_Mode == 1) {
    analogWrite(FET_Drive, (255 *  MODE1_Bright));   // Percent Brightness = MODE1_Bright
    for (int x = 0; x < LED_Mode; x++) { // Flash rate Status LED to match mode
      digitalWrite(Status_LED, 255);  // 255 turns LED FULL BRIGHT
      delay(100);      // endfor quick toogle Blue LED
      digitalWrite(Status_LED, 0);  // 0 turns LED OFF
      delay(100);      // endfor quick toogle Blue LED
    } //for match Status_LED with mode
    delay(600);
  } // endif LED_Mode = 1

    // LED_Mode - Percent Brightness
  if (LED_Mode == 2) {
    analogWrite(FET_Drive, (255 *  MODE2_Bright));   // Percent Brightness = MODE2_Bright
    for (int x = 0; x < LED_Mode; x++) { // Flash rate Status LED to match mode
      digitalWrite(Status_LED, 255);  // 255 turns LED FULL BRIGHT
      delay(100);      // endfor quick toogle Blue LED
      digitalWrite(Status_LED, 0);  // 0 turns LED OFF
      delay(100);      // endfor quick toogle Blue LED
    } //for match Status_LED with mode
    delay(600);
  } // endif LED_Mode = 2

  // LED_Mode - Full Brightness
  if (LED_Mode == 3) {
    digitalWrite(FET_Drive, 255);   // FULL BRIGHT
    for (int x = 0; x < LED_Mode; x++) { // Flash rate Status LED to match mode
      digitalWrite(Status_LED, 255);  // 255 turns LED FULL BRIGHT
      delay(100);      // endfor quick toogle Blue LED
      digitalWrite(Status_LED, 0);  // 0 turns LED OFF
      delay(100);      // endfor quick toogle Blue LED
    } //for match Status_LED with mode
    delay(600);
  } // endif LED_Mode = 3
 

  // LED_Mode - LED BREATHING
  if (LED_Mode == 4) {
    // Ramp up the brighness of the LED
    for (int i = Breath_Min_Bright; i <= Breath_Max_Bright; i++) {
      analogWrite(Status_LED, i);
      analogWrite(FET_Drive, i);
      float Breath_Delay = (exp(sin(i/2000.0*PI*10)) - 0.36787944)*108.0;
      delay(Breath_Delay/Breath_Rate);
      if (buttonState == HIGH) {   // check if the pushbutton is pressed.
        i = Breath_Max_Bright;
      }
    } 

    mode_change_button();  // check to see if mode_change button is pressed
    stobe_on_button ();   // check to see if strobe_button is pressed
   
    // Ramp down the brightness of the LED
    for (int i = Breath_Max_Bright; i >= Breath_Min_Bright; i--) {
      analogWrite(Status_LED, i);
      analogWrite(FET_Drive, i);
      float Breath_Delay = (exp(sin(i/2000.0*PI*10)) - 0.36787944)*108.0;
      delay(Breath_Delay/Breath_Rate);
      if (buttonState == HIGH) {   // check if the pushbutton is pressed.
        i = Breath_Min_Bright;
      }
    }
  } // endif LED_Mode 4

  mode_change_button();  // check to see if mode_change button is pressed
  stobe_on_button ();   // check to see if strobe_button is pressed

}
-----

ToF Laser to Monitor Cat Food Levels

 -----
We live in great times.  There was once a day when the only way to determine if the cat feeder needed more kibble was to actually look at it with your own eyes like some Neanderthal.  Thankfully technology and the magical world of IoT has changed all of that.
----
For this project we use a WiFi enable ESP8266 and a STMicro VL53L0X ToF Sensor mounted to a breakout board.  If you don't find a need to measure feline food consumption the project still provides Arduino code that can be extremely useful for your other IoT projects:

• Logging data to a Google Drive Spreadsheet (via IFTTT)
• Logging data to AT&T's M2X machine to machine servers (think nice graphs)
• Sending SMSs to your mobile device (via IFTTT)

All of the above services are free but; of course, you will need to establish an account if you do not have on.
----
What's happening?
The ESP8266 runs in Arduino mode (source code below) in an endless loop.  Every hour it polls the VL53L0X ToF Sensor mounted on the lid of the cat food feeder.

-----
Since we know how many centimeters the food is from the ToF sensor at full and at empty we are able to scale those values and report/log "percent full" status.  Those values are posted to a Google Drive Spreadsheet and to AT&T's M2X machine to machine servers for logging.  If the food level is considered CRITICALLY LOW a SMS message goes out to our mobile device.  Just to increase the geek factor, CRITICALLY LOW alerts are also displayed on our Pebble watch.
----
The Google Drive Spreadsheet looks like this:

-----
Here is the bad ass AT&T M2X machine to machine server graph (note the increase after we filled the feeder):

-----
The IFTTT SMS alerts are sent if the rig determines food levels critically low:

-----
So..... How's it done?  You will need these:

• WiFi enable ESP8266
• STMicro VL53L0X ToF Sensor mounted to a breakout board 
• Some wire and a breadboard.

Easy; hook it up like this:

 And it will look something like this:

-----
 Mount it to the cat feeder and you end up with this:

-----
Now all that is left is to copy/paste the code below into the Arduino IDE.  Upload it to the ESP8266 and your cats will never go hungry again!
-----
/*
 *  AUG2017
 *  STMicro VL53L0X ToF Sensor for
 *  Cat Food Level Monitoring
 *  WhiskeyTangoHotel.Com
 * 
 *  Logs % full values to:
 *    Google Drive (as an appending spreadsheet)
 *    AT&T M2X for historical graphing
 *    Send SMS to cell phone if level condition is RED/CRITICAL
 * 
 *  uC setting for Ardunio IDE
 *  NoderMCU 1.0 (ESP-12E Module), 80MHz, 921600, 4M (3M SPIFFS)
 * 
*/

// For the STMicro VL53L0X ToF Sensor
// I2C SDA to ESP8266 Pin D2.  SCL to ESP8266 Pin D1
#include "Adafruit_VL53L0X.h"   // Thanks again ADAFRUIT!!!
Adafruit_VL53L0X lox = Adafruit_VL53L0X();

// For the Wireless
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

// WiFi Connection Information
const char* ssid = "YourNetworkHere";    // PRIVATE: Enter your personal setup information.
const char* password = "YourNetworkPasswordHere"; // PRIVATE: Enter your personal setup information.
ESP8266WebServer server(80);

// IFTTT Information for WebHook widget
String MAKER_SECRET_KEY = "YourIFTTTCodeHere"; // PRIVATE: Enter your personal setup information. Your IFTTT Webhook key here
String TRIGGER_NAME_google_drive = "Cat_Food";  // this is the Maker IFTTT trigger name for google drive spreadsheet logging
String TRIGGER_NAME_M2X = "cat_food_mx";   // this is the Maker IFTTT trigger name for M2X logging
String TRIGGER_NAME_SMS = "CriticalFoodLevel_SMS";  // this is the Maker IFTTT trigger name to send SMS if low is level is CRITICAL.
const char* host = "maker.ifttt.com";
String url_google_drive;  // url that gets built for the IFTTT Webhook logging to google drive spreadsheet
String url_M2X;   // url that gets built for the IFTTT Webhook logging to AT&T M2X service
String url_SMS;   // url that gets built for the IFTTT Webhook sending SMS if food level is critical

// Define and set up some variables
float Range_inches;  // How far the sensor is from the food at time of reading.  Sensor is on roof of feeder.
float Min_level = 5.0;   // Distance in inches before low food alarm level.  Food is far from sensor on feeder roof
float Max_level = 0.5;   // Distance in inches from sensor for full feeder level.  Food is close to sensor on feeder roof
float Percent_full;  // How full in xx.x% is the food based on the Min/Max_levels defined above
float Caution_alarm = 35.0;  // at xx.x% food level is considered low.  String Status YELLOW
float Critical_alarm = 25.0;  // at xx.x% food level is considered critically low. String Status RED
String Status = "***_Starting_with_Caution_at:_" + String(Caution_alarm) + "%_and_CRITICAL_at:_" + String(Critical_alarm) + "%";  // Update to Out of Range, NORMAL, LOW, CRITICAL, etc. "spaces" will error IFTTT Webhook; use "_"
int Run_number;  // how many times the sensor has been read

// Output pins
const int led = 2;  // Blue on board LED is on PIN2 for this NoderMCU 1.0 ESP8266.  Blink it between reads

// Program control variables
int Seconds_between_posts = 60 * 60;  // how often to post the results of the sensor read. NOT EXACT due to post delays, Sensor reads, LED flashing, etc.
int logging = 1; // If 1 then log to cloud.  Any other value (0) turns it off.  ESP8266 "Start/Restart" message is always logged. 


void setup(void){  // This is run once.
  pinMode(led, OUTPUT);  // set up the onbaord LED pin as an output. 
  Serial.begin(115200);  // turn on the serial monitor for debug

  // wait until serial port opens for native USB devices
  while (! Serial) {
    delay(1);
  }

  // Is the ToF sensor connecting via I2C?
  Serial.println("STMicro VL53L0X test");
  if (!lox.begin()) {
    Serial.println(F("Failed to boot VL53L0X!!!"));
    while(1);
  }
  // power
  Serial.println(F("VL53L0X Passed... \n\n"));
 
  // Is the WiFi working?
  WiFi.begin(ssid, password);
  Serial.println("");
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print("Trying to connect to ");
    Serial.print(ssid);
    Serial.print(" on ");
    Serial.print(WiFi.localIP());
    Serial.println(".");
  }
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.println(WiFi.localIP());

  if (MDNS.begin("esp8266")) {
    Serial.println("MDNS responder started");
    Serial.println(" ");
  }

  // Use WiFiClient class to create TCP connections for WiFi logging
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");  // Boo!!!
    return;
  }

  server.begin();
  Serial.println("HTTP server started");  // Woo Hoo!!!

  // Write to Google Sheet via IFTTT Maker channel that the ESP8266 has started/restarted
  // Trigger the IFTTT Webhook Channel to update a Google sheet with the activity of the server starting/restarting
  // This can help log power outs, etc.  For first run we defined String Status for identify a startup condition.
  // Create the request for IFTTT google drive
  url_google_drive = "https://maker.ifttt.com/trigger/" + TRIGGER_NAME_google_drive + "/with/key/" + MAKER_SECRET_KEY + "?value1=" + String(Status);
  Serial.println("Status: " + Status);
  Serial.println(" ");
   
  // This sends the request to the IFTTT server
  client.print(String("POST ") + url_google_drive + " HTTP/1.1\r\n" +
  "Host: " + host + "\r\n" +
  "Connection: close\r\n\r\n"); 
  delay(500);  // Delay for web traffic; maybe not required. 
}

void loop(void){
  // Loop forever.  Read the sensor and post based on the delay values set above.
  // The blue onboard LED will blink between ToF reads.
 
  // Read the ToF.  Distance in mm  returned. 
  for (int x = 0; x < 10; x++) { // Quick toggle blue on  board LED to show measurement being taken.
    digitalWrite(led, !digitalRead(led));  // toggle state of the on board blue LED. Shows program is running
    delay(100);    }  // endfor quick toogle Blue LED
  VL53L0X_RangingMeasurementData_t measure;

  Serial.println("-------------------------------------");
  Serial.println("Reading a measurement... ");
  lox.rangingTest(&measure, false);
  // Convert to inches because the USA, for some reason, doesn't want to adopt the metric system...
  Range_inches = measure.RangeMilliMeter/25.4;
  Run_number = Run_number + 1;

  // Scale and normalize the Min Max levels to 0% to 100%.  Clip the range in case of a the Max fill limit was exceeded or a misread.
  Percent_full = ((Range_inches - Min_level) / (Max_level - Min_level)) * 100.0;
  if (Percent_full > 100) {
    Percent_full = 100.00;
  }
  if (Percent_full < 0) {
    Percent_full = 0.0;
  }

  //Serial.println(String(Range_inches));  // Debug use
     
  // Is the ToF Sensor reading 'anything' for a distance?
  if (Range_inches > 100 ) {  // Something's weird.  Ranging error.  The ToF sensor is NOT over 100 inches fron the food. EVER!!!
      Status = "Run:" + String(Run_number) + "__ERROR:_***_Out_of_Range_***";
  } else {  // ToF made a successful reading so log the food level   
    if (Percent_full >= Caution_alarm) {  // above CAUTION LEVEL, All's good
      Status = "Run:" + String(Run_number) + "___GREEN---GOOD";
    } // endif GREEN---GOOD
 
    if (Percent_full < Caution_alarm && Percent_full > Critical_alarm) {  //  CAUTION Zone, YELLOW---REFILL_SOON
      Status = "Run:" + String(Run_number) + "___~~~YELLOW---REFILL_SOON~~~";
    } // end if YELLOW---REFILL_SOON"
 
    if (Percent_full <= Critical_alarm) {  //  CAUTION Zone, RED---REFILL_ASAP"
      Status = "Run:" + String(Run_number)+ "___!!!_RED---REFILL_ASAP_!!!";
      if (logging == 1) { // is logging turned on? Maninly for debug...  Typically would be set = 1
        // Set up IFTTT Webhook Channel to send the SMS. 
        // Use WiFiClient class to create TCP connections for IFTT SMS
        WiFiClient client;
        const int httpPort = 80;
        if (!client.connect(host, httpPort)) {
          Serial.println("connection failed");
          return;
        }     
        url_SMS = "https://maker.ifttt.com/trigger/" + TRIGGER_NAME_SMS + "/with/key/" + MAKER_SECRET_KEY+ "?value1=" + String(Percent_full);
        Serial.println("Critical Level: Sending SMS with payload:.");
        Serial.println(url_SMS);
        Serial.println(" ");
        client.print(String("POST ") + url_SMS + " HTTP/1.1\r\n" +
        "Host: " + host + "\r\n" +
        "Connection: close\r\n\r\n");
        //Serial.println("GOOGLE DRIVE URL:");
        //Serial.println(url_google_drive);
        delay(500);   // pause for webservices   
      }         
    } // endif RED---REFILL_ASAP
     
  }

  // Serial print to the monitor for debug
  Serial.println(String(Range_inches) + " inches down / " + String(Percent_full) + "% full");
  Serial.println("Status: " + Status);
  // Create the request for IFTTT Google Drive and M2X updates
  url_google_drive = "https://maker.ifttt.com/trigger/" + TRIGGER_NAME_google_drive + "/with/key/" + MAKER_SECRET_KEY + "?value1=" + String(Percent_full) + "%" + "&value2=" + Status;
  url_M2X = "https://maker.ifttt.com/trigger/" + TRIGGER_NAME_M2X + "/with/key/" + MAKER_SECRET_KEY + "?value1=" + String(Percent_full);
 
  // This sends the request to the IFTTT server.
  //Serial.println("Requesting URL...");   // debug
  //Serial.println(url);   // debug
  if (logging == 1) { // is logging turned on? Maninly for debug...  Typically would be set = 1
    //Serial.println("Logging is ON."); 
    // Set up IFTTT Webhook Channel to update a Google sheet with the activity. 
    // Use WiFiClient class to create TCP connections for IFTT Webhook logging
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
      Serial.println("connection failed");
      return;
    }     
    client.print(String("POST ") + url_google_drive + " HTTP/1.1\r\n" +
    "Host: " + host + "\r\n" +
    "Connection: close\r\n\r\n");
    Serial.println(" ");
    Serial.println("IFTTT url payload to Google Drive:");
    Serial.println(url_google_drive);
    Serial.println(" ");
    delay(500);   // pause for webservices
 
    // Set up IFTTT Maker Channel to update a AT&T M2X Server with the activity. 
    // Use WiFiClient class to create TCP connections for IFTT Webhook logging
    //WiFiClient client;
    //const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
      Serial.println("connection failed");
      return;     }     
    client.print(String("POST ") + url_M2X + " HTTP/1.1\r\n" +
    "Host: " + host + "\r\n" +
    "Connection: close\r\n\r\n");
    Serial.println("IFTTT url payload for M2X:");
    Serial.println(url_M2X);
   
  } else {
     Serial.println("Logging is OFF.");
  } // endif/else logging 
 
  for (int x = 0; x < Seconds_between_posts; x++) { // Delay for next measurement.
    digitalWrite(led, !digitalRead(led));  // toggle state of the on board blue LED. Shows program is running
    delay(1000);   } // endfor delay for read measurement
}
-----
Thanks and check out our other stuff!!!

------

micro:bit Tilt Angle Controls Servo Motor

The micro:bit is a simple, rugged, easy to program microcontroller aimed at the education market and you get a lot for your money.  The unit is programmed with a browser interface.  That means no huge development environments to install on your hardrive making the time from unboxing to "Hello World" literally minutes.  The simplest way to push code into the micro:bit is with the JavaScript Blocks editor.  However, Java and Python can also be used.

With three mouse drags we created a program to have a servo motor track the tilt angle of the micro:bit.  It doesn't get much easier.

-----

-----

If you are wanting to introduce someone to the magic of programming, basic electronics, and blinky lights this is a low cost/low risk way to make it happen.

-----

Measuring Fidget Spinner RPM via TEK MDO4000 Oscilloscope

-----

How fast can a Fidget Spinner spin?  Well, it depends on what spins it.  Let's use compressed air.

That sounds fast, it's actually scary to hold!!!  But how fast?

-----

To make the measurement we used a simple LED as a sensor.  A bright light shines down onto the LED.  The arms of the Fidget Spinner block the light as they move over the LED creating electrical pulses. 

-----

The sensor LED is connected to a Tektronix MDO4104C to measure the pulses.  The scope (along with a few thousand other features) allows an engineer to quickly study waveform measurements with cursors.  After a little math we get our answer; well over 10,000 RPM.

That's fast!

-----

Tweeting Cat Door (now with Rasperry PI)

-----
It is hard to believe, but it was over five years ago that we created a Tweeting CatDoor using the Electric Imp.  Basic hobby IoT was much harder back then.  The Electric Imp, being a commercial grade product, was rock solid.  It only needed to reboot twice during it's entire service.  That said, a lightening strike may have gotten the best of it.
----
Basic hobby IoT is easier today thanks to project sites like HackaDay, etc.

A look into our spare parts box prompted some changes:  The Electric Imp gets replaced by a Raspberry Pi ZERO and WiFi dongle (we didn't have a spare ZERO-W laying around).  The original magnetic reed switch implementation goes solid state and gets replaced with a A3144EUA Hall Effect Sensor.  The concept is still the same as the original; a magnet is placed on the door and when Zena or Kelso use the door a magnet swings past the stationary sensor triggering a GPIO event.

As shown in the wiring diagram above, the build is simple.  The python code straightforward.

For the python code below you will need you create your own Twitter App and establish:

      - Consumer Key (API Key) and Consumer Secret (API Secret)

      - Access Token and Access Token Secret

These Keys and Tokens are, of course, changed in the python code below for obvious reasons.  Also, to save space the 'database' of tweets listed in the code is reduced.

-----

# May 2017 / WhiskeyTangoHotel.Com
# Raspberry PI ZERO for tweeting Cat Door activity
# MagSwitch is model A3144EUA Hall Effect sensor with magnet next to it
# Activate tweet loop whenever the Hall Effect Sensor changes state

import random
import time

# Set up Auth and token ID for the twitter API
from twython import Twython
# fill in your 4 keys in following variables
C_key = "ckckckckckblaghblagckckckckck"
C_secret = "cscscscscsblaghblaghblaghcscscscscs"
A_token = "atatatatatblaghblaghblagatatatatat"
A_secret = "asasasasasblaghblaghblagasasasasas"

localtime = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
Current_day = time.strftime("%d", time.localtime()) # what day of the month is it
New_day_dawned = Current_day # 1st run after midnight send status tweet to verify program is running

###  PROGRAM VAR SETTINGS ###

# Flood control (in seconds) for debounce and not sending to many tweets
Flood_control = 180 # seconds

# Really tweet (YES) or just test/debug (NO)?
Tweet = "YES"   # YES or NO in ALL UPPERCASE

# Track how many times the door has been triggered
Counter = 0

# Set up Hall Effect Sensor
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD) # to use Raspberry Pi board pin numbers
MagSwitch = 8  # Pin from signal of hall effect sensor
#Set pin to input and set pull-up resistor to hold the pin is high
GPIO.setup(MagSwitch, GPIO.IN, pull_up_down=GPIO.PUD_UP)
print ' '
print "Program starts with Flood control of " + str(Flood_control) + " seconds."
print "Tweet set to " + Tweet
print " "

localtime = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
print "RasPI started on " + localtime + ".  Begin the mission!!!"
MagSwitch_Current = GPIO.input(MagSwitch)
#print "MagSwitch value is: " + str(MagSwitch_Current)
print ' '
if (Tweet == "YES"):
    myTweet = Twython(C_key,C_secret,A_token,A_secret)
    localtime = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
    myTweet.update_status(status="RasPI started at " + localtime + ".  Begin the mission!!!")
  
time.sleep(1)  # Whew... let's rest a bit..    Why?  Dunno...

while True:    # program runs 'forever'
    # First check if this is a new day.  If yes, tweet program is still active
    localtime = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
    Current_day = time.strftime("%d", time.localtime())
    if Current_day != New_day_dawned:
        print "A new day has dawned. It is " + localtime + "."
        print ' '
        if (Tweet == "YES"):
            myTweet = Twython(C_key,C_secret,A_token,A_secret)
            localtime = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
            myTweet.update_status(status="Hello, Twitter. Let's make the best of " + localtime)
        New_day_dawned = Current_day
                  
    # Now check to see if Sensor has changed state.  If so then Let's tweet
    if (GPIO.input(MagSwitch) != MagSwitch_Current):
        print ' '
        localtime = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
        print "Triggered at: " + localtime
        print '-------------------------------'
      
        Counter = Counter + 1
          
        # Load the CatQuotes; then Tweet it
        CatQuote = [
        "ZERO", #this is zero and should never be called.  just here to make counting easier 'cuz i'm stupid
        "Tweet Quote 1",
        "Tweet Quote 2",
        "Tweet Quote 3",
        "Tweet Quote 4",
        "Tweet Quote 5",
        "Tweet Quote etc...",        ]
      
        Number_of_quotes =  6 - 1
        random.seed() # seed off the CPU clock
        r = random.random()              
        r = int((r * Number_of_quotes) + 1)

        print str(Counter) + ": CatQuote("+str(r)+"): " + CatQuote[r]
        print "Flood control set to " + str(Flood_control) + " seconds."
        print "Tweet set to: " + Tweet
        if (Tweet == "YES"):
            myTweet = Twython(C_key,C_secret,A_token,A_secret)
            myTweet.update_status(status=CatQuote[r])
      
        time.sleep(Flood_control)  # pause for debounce, re-read HE sensor, keeps from tweeting all the time.
      
        # Door etc has settled after the Flood Control.  Reset and wait for next toggle
        MagSwitch_Current = GPIO.input(MagSwitch)
      
        print "Flood Control PASSED."
        print " "

-----

Good luck if you decide to build your own tweeting RasPI.

Remote Control the Alexa Echo from Anywhere in the World

-----
Seems to be a common request:  "How do I control my Amazon Echo remotely?"  As to why this needs to be done is somewhat of a mystery, but evidently; done it must be...

First off; this is a hack.  Even hackers being the hacker types they are will think it's a hack and those hackers will be right.
-----
Take a look at the diagram above.  Basically what is happening is a Raspberry PI with a speaker plugged into it is commanding the Amazon Echo via a text-to-speech program.

• The user logs into their home network via OpenVPN from anywhere in the World.
• Navigate via VNC, etc. to a RasPI with a speaker placed next to an Amazon Echo.
• From the RasPI command line use the 'festival' text-to-speech program to speak instructions to the Amazon Echo.
• Amazon Echo obeys the command.

-----
Here's a quick video demo:

 -----
Others have done the hard work, but you will need to install some software:

• If you don't have OpenVPN running, PiVPN makes this really easy on the Raspberry PI (and other platforms).  This *could* be optional if you only wanted to use the hack from inside your LAN or opened up a PORT on your router.  If you do decide to open up a PORT on your router for the whole wide world be aware of the risks.
• Install the text-to-speech program 'festival' on the Raspberry PI with the command:

$ sudo apt-get install festival festival-freebsoft-utils 

• Plug a speaker into the Raspberry PI and place it next to the Amazon Echo.
• Log into that Raspberry PI and issue a 'festival' text-to-speech command to control the Amazon Echo.  For example:

$ echo  "Alexa, what time is it" | festival --tts

 or

$ echo  "Alexa, play Super Freak" | festival --tts

•  Success! World domination!

-----

ESP8266 WiFi Garage Door Opener from any Web Browser

The 'brain' is the ESP8266 uC.  It is available with on board WiFi and plenty of I/O for smaller projects.  All this for well under $10USD with programming options for NodeMCU, MicroPython, and the Arduino IDE.
-----
There seems to be an unstoppable drive in the hacker DIY community for web based garage door openers and we were compelled to respond.  The garage door opener we have opens/shuts from a push button switch that basically creates a short to connect two terminals on the garage door opening unit.  That allows easy implementation because all that is required is a ESP8266 controlled relay wired across those two terminals to create a switch closure.

In addition to activating the door any activity is logged to a Google Sheet via the IFTTT.com Maker Channel.  This is handy to track all activation usage and ESP8266 server restarts.
-----
The main components are the ESP8266, a relay module, a BS170 N-Channel MOSFET.

 

-----
Simple.  Connect the 'stuff' as shown in the schematic:

and it will look something like this:

----
Use the Arduino IDE to load the source code below into the ESP8266 then wire the Normally Open (NO) side of relay you are controlling to the two terminals on the garage door opener that active the motor when 'shorted' together.

A few comments on the application:

• Control works from Android, iPhone, PC, etc.  Basically any browser.  In the source code below if a device can open "http://192.168.0.28/long_confusing_URL_to_activate_relay" it will activate the garage door.
• There is a "TEST" URL in the source code (http://192.168.0.28/) that confirms the ESP8266 is online but does not activate the door.
• Set a static IP for the ESP8266 in your WiFi router.  Otherwise it may be assigned a different local IP if the ESP8266 or WiFi router is restarted.
• Use long/complex URLs.  That way those that are connected to your router don't have a 'obvious' URL to activate the rig or one they can remember if you demo it.
• We only wanted control of the door when connected to the host WiFi router locally (LAN) and not from anyplace on the planet.  If you want extended control to the WWW open a port on your router, but be aware of the concerns. We wanted to limit use only to those authorized to connect the WiFi router locally (LAN).  Plus, we didn't want to risk accidentally activating the door from a remote location.
• The source code has separate IFTTT.com Maker Channel triggers to log events.  We could use one Maker Channel trigger and just pass different GETPOST variables.  However, creating multiple Maker Channel triggers would easily allow usage tracking on individuals by assigning each one a unique trigger name. (/ZenaActivate, /KelsoActivate, etc...)
• Any time the door is activated or the ESP8266 is restarted (power outage, etc) a Google Sheet is updated to log the event as shown below. 

 

-----
The Arduino IDE source code is:

/*
 *  Garage Door Opener via Web Browser and log to IFTTT.com
 *  ESP8266 NodeMCU Board using Arduino IDE
 *  WhiskyTangoHotel.Com    DEC2106
 * 
 *  Blue on board LED is active LOW on GPIO2 (D4 on silkscreen)
 *  Relay to control Garage Door is active HIGH on GPIO5 (D1 on silkscreen)
 * 
 *  Opening 192.168.0.28/long_confusing_URL_to_activate_relay is called.  Every effort is made to keep the relay off 
 *  so the door does not close/activate by accident.
 * 
 *  A 'test' message is display on browser to see if server is up by calling root at:.
 *  192.168.0.28/  This WILL NOT ACTIVATE THE RELAY.  Only tests the server
 * 
 *  The 'meat' is at 192.168.0.28/long_confusing_URL_to_activate_relay. This will send a msg to the browser AND open/close the door.
 * 
 */

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

// WiFi Information
const char* ssid = "YOUR-SSID";
const char* password = "ASCII-PASSCODE-FOR-YOUR-SSID";

// IFTTT Information
String MAKER_SECRET_KEY = "xxx-yyy-zzz-123-456-789"; // your maker key here
String TRIGGER_NAME = "IFTTT_Maker_name_to_activate_relay";  // this is the Maker IFTTT trigger name for relay activation
const char* host = "maker.ifttt.com";

ESP8266WebServer server(80);

// Output pins
const int led = 2;  // Blue on board LED
const int relay = 5;  // Relay control line

int randNumber;  // Random# generated just to show a change in the screen.  Help to verify updated page call.

void handleRoot() {
  // This is called if 192.168.0.28/ is requested.  The root.
  // The 'meat' is at /long_confusing_URL_to_activate_relay.
  // This is just here to test the ESP8266 connectivity of the WiFi network without moving the relay
  // Show a message and flash the on board LED.
  randNumber = random(1, 10000);  // Random number just to show a change on the webpage at reload.
  server.send(200, "text/plain", "Testing ESP8266.  Response is: " + String(randNumber));
  digitalWrite(led, 0);  // Active LOW.  Turn On board LED On
  delay(2000);
  digitalWrite(led, 1);  // Active LOW.  Turn On board LED Off
}

void handleNotFound(){
  digitalWrite(led, 1);  // Keep the LED off.
  digitalWrite(relay, 0);  // Keep Relay OFF
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET)?"GET":"POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";
  for (uint8_t i=0; i<server.args(); i++){
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }
  server.send(404, "text/plain", message);
}

void setup(void){
  pinMode(led, OUTPUT);
  pinMode(relay, OUTPUT);
  digitalWrite(led, 1);  // LED Off
  digitalWrite(relay, 0);  // on power to relay
  Serial.begin(115200);  // serial prints to PC for debug use only
  WiFi.begin(ssid, password);
  Serial.println("");

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.print("Trying to connect to ");
    Serial.print(ssid);
    Serial.print(" on ");
    Serial.print(WiFi.localIP());
    Serial.println(".");
  }
  Serial.println("");
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.println(WiFi.localIP());

  if (MDNS.begin("esp8266")) {
    Serial.println("MDNS responder started");
 
  // Write to Google Sheet via IFTTT Maker channel that the ESP8266 has started/restarted

  // Now we trigger the IFTTT Maker Channel to update a Google sheet with the activity of the server starting/restarting
  // This can help log power outs, etc. 
  // Use WiFiClient class to create TCP connections
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
 
  // Create the request for IFTTT GARAGE_trigger_serverstart.  This can help log power outs, etc.
  String url = "https://maker.ifttt.com/trigger/GARAGE_trigger_serverstart/with/key/" + MAKER_SECRET_KEY;
  Serial.print("Requesting URL: ");
  Serial.println(url);
 
  // This sends the request to the IFTTT server
  client.print(String("POST ") + url + " HTTP/1.1\r\n" +
  "Host: " + host + "\r\n" +
  "Connection: close\r\n\r\n");
 
  delay(500);  // Delay to for web traffic; maybe not required.
  }

  server.on("/", handleRoot);

  server.on("/long_confusing_URL_to_activate_relay", [](){
    // This is called when 192.168.0.28/long_confusing_URL_to_activate_relay is called
    randNumber = random(1, 10000);  // Random number just to show a change on the webpage at reload.
    server.send(200, "text/plain", "Relay activated @ESP8266.  Code: " + String(randNumber));
    digitalWrite(led, 0);  // Active LOW.  Turn On board LED On
    digitalWrite(relay, 1);  // Relay ON

    // Know we trigger the IFTTT Maker Channel to update a Google sheet with the activity. 
    // Use WiFiClient class to create TCP connections
    WiFiClient client;
    const int httpPort = 80;
    if (!client.connect(host, httpPort)) {
      Serial.println("connection failed");
      return;
    }
 
    // Create the request for IFTTT
    String url = "https://maker.ifttt.com/trigger/" + TRIGGER_NAME + "/with/key/" + MAKER_SECRET_KEY;
    Serial.print("Requesting URL: ");
    Serial.println(url);
 
    // This sends the request to the IFTTT server
    client.print(String("POST ") + url + " HTTP/1.1\r\n" +
    "Host: " + host + "\r\n" +
    "Connection: close\r\n\r\n");
   
    delay(2000);  // Delay to keep the relay closed.
    digitalWrite(led, 1);  // Active LOW.  Turn On board LED Off
    digitalWrite(relay, 0);  //Relay OFF
  });

  server.onNotFound(handleNotFound);

  server.begin();
  Serial.println("HTTP server started");
}

void loop(void){
  server.handleClient();
}
-----

-----