The Pole Vaulter

    I aim to make some blog posts and accompanying videos to present some intermediate level concepts for micro-controller hobbyists.

    There are lots of resources online for beginners.  I learned starting with the Adafruit Arduino Lessons and I have heard good things about the Paul McWhorter Youtube series, to name a few. The Arduino forum, Stack Exchange and Reddit forums are good resources for asking questions.  However, I see some questions come up over and over, so I hope to help address them.

    I've adopted a philosophy toward the projects I am presenting because of one problem in particular that I see on the Arduino Reddit, the Pole Vaulter. The Pole Vaulter has gotten it into their head that 1. a thing called Arduino exists and 2. it can't be that hard.  Armed with this knowledge and unwarranted confidence, the Pole Vaulter grabs their pole (i.e. someone else's project that has been posted online), attempts to vault (recreate that project) and is quickly confronted with their own inadequacies ("Why doesn't it work?!?").

As a reasonable person would not expect to grab a pole and succeed at pole vaulting on their first try, a novice should not attempt to build someone else's project without first learning the fundamentals.

    Because pole vaulters exist, I have specifically made projects that illustrate the lesson of the day but that are not useful for any practical purpose.  My aim is that a pole vaulter might look at what is presented in these projects and find them boring, just a bit of blinking lights and turning knobs.  This would hopefully spare me from having to lecture them on the importance of a solid foundation.  

    By contrast, the Arduinist that has taken time to work through the beginner lessons, hopefully would have, at some point, realized that if they can light a light they can do a little code swapping and make a motor move, turn on a camera, send a bit of data to a database or whatever, and if they can trigger those actions from a potentiometer then the same sort of code swapping can be done with a load cell, a PIR sensor, button input or whatever else.  That is, these lessons use LEDs as generic actuators and Potentiometer wiper position as generic sensors. They exist to make a point, and it is on the intermediate micro-controller hobbyist to take example code and put them together to make something for the pole vaulter to spectacularly fail at reproducing.

ESP NOW Bidirectional data passage between ESP 8266 and ESP 32

The Random Nerd Tutorials tutorials (here and here) for bidirectional communications using ESP NOW have a bit of unnecessary added complexity, in adding humidity sensors, and in the case of ESP32 a OLED screen.  This post presents pared down sketches demonstrating bidirectional data exchange between an ESP 8266 and ESP32.  These are the same development boards used on the previous ESP NOW post, where each processor is installed on a NODEMCU type breakout board.

As in the previous post, I got the MAC address of each device using the sketch provided on the Random Nerd Tutorial links above.  

These MAC addresses are needed for each board to know where to send messages.  Besides this, the Random Nerd Tutorial sketches were changed to replace the humidity sensors with a potentiometer (and remove the screen).  This allows simplification of the data structure, and I added a little logic to trigger a couple LEDs based on the potentiometer position.  This way I don't need to be connected to serial monitor to know that the sketch is working.

Each board takes input from the wiper of their respective potentiometer and the data read is sent to the other board using ESP NOW.  Two LEDs are connected to each board, one for the local pot and one for that connected to the other board.  

ESP 8266 wiring is as follows:

• 3.3 V -> Pot high side (red wire)
• GND -> Pot low side (black wire)
• A0 -> Pot wiper (yellow wire)
• D6(GPIO12) -> Green LED anode (green wire)
• Green LED Cathode -> 150 Ohm Resistor -> GND
• D7(GPIO13) -> Red LED Anode (white wire)
• Red LED Cathode -> 150 Ohm Resistor -> GND

ESP 32 wiring is similar:

• 3.3 V -> Pot high side (red wire)
• GND -> Pot low side (black wire)
• G34(GPIO 34) -> Pot wiper (yellow wire)
• G16(GPIO16) -> Green LED anode (green wire)
• Green LED Cathode -> 150 Ohm Resistor -> GND 
• G17(GPIO17) -> Red LED Anode (white wire)
• Red LED Cathode -> 150 Ohm Resistor -> GND 

The LEDs illuminate if the pot wiper is past the halfway point.  Below is when the ESP 32 pot is turned up:

... and when the ESP 8266 wiper is turned up:

Maybe I will make a video later, as the images aren't terribly exciting.

Below is the ESP 8266 sketch:

/*
  This sketch is rework of a sketch first written by Rui Santos and presented on:
  https://RandomNerdTutorials.com/esp-now-two-way-communication-esp8266-nodemcu/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <esp8266wifi.h>
#include <espnow.h>


// REPLACE WITH THE MAC Address of your receiver 
uint8_t broadcastAddress[] = {0x58, 0xBF, 0x25, 0x31, 0x9D, 0xE0};

int arriving_data=0;
int local_data=0;
const long interval = 200; 
unsigned long previousMillis = 0;

//Structure example to send data
//Must match the receiver structure
typedef struct struct_message {
    int reading;
} struct_message;

// Create a struct_message to hold sensor readings
struct_message outbound;

// Create a struct_message to hold incoming sensor readings
struct_message inbound;

// Callback when data is sent
void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) {
  Serial.print("Last Packet Send Status: ");
  if (sendStatus == 0){
    Serial.println("Delivery success");
  }
  else{
    Serial.println("Delivery fail");
  }
}

// Callback when data is received
void OnDataRecv(uint8_t * mac, uint8_t *incomingData, uint8_t len) {
  memcpy(&inbound, incomingData, sizeof(inbound));
  Serial.print("Bytes received: ");
  Serial.println(len);
  arriving_data = inbound.reading;
}

void read_pot(){
  local_data = analogRead(A0);
  Serial.print("Pot reading: ");
  Serial.println(local_data);
}

void printIncomingReadings(){
  // Display Readings in Serial Monitor
  Serial.println("INCOMING READINGS");
  Serial.println(arriving_data);
}
 
void setup() {
  // Init Serial Monitor
  Serial.begin(115200);
  pinMode(12,OUTPUT);
  pinMode(13,OUTPUT);
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();

  // Init ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Set ESP-NOW Role
  esp_now_set_self_role(ESP_NOW_ROLE_COMBO);

  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Trasnmitted packet
  esp_now_register_send_cb(OnDataSent);
  
  // Register peer
  esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_COMBO, 1, NULL, 0);
  
  // Register for a callback function that will be called when data is received
  esp_now_register_recv_cb(OnDataRecv);
}
 
void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    // save the last time you updated the DHT values
    previousMillis = currentMillis;

    //Get pot readings
    read_pot();

    //Set values to send
    outbound.reading = local_data;

    // Send message via ESP-NOW
    esp_now_send(broadcastAddress, (uint8_t *) &outbound, sizeof(outbound));

    // Print incoming readings
    printIncomingReadings();
    
  }
  if(arriving_data>2048)
  {
  digitalWrite(12, HIGH);
  } 
  else
  {
    digitalWrite(12, LOW);
  }
  if(local_data>512)
  {
    //Serial.println("writing local led high");
    digitalWrite(13, HIGH);
  }
  else
  {
    //Serial.println("writing local led low");
    digitalWrite(13, LOW);
  }
}

...and the ESP32 sketch:

/*
  This sketch is rework of a sketch first written by Rui Santos and presented on:
  https://RandomNerdTutorials.com/esp-now-two-way-communication-esp32/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <esp_now.h>
#include <wifi.h>

// REPLACE WITH THE MAC Address of your receiver 
uint8_t broadcastAddress[] = {0xBC, 0xFF, 0x4D, 0x4A, 0x4D, 0x6A};

int arriving_data=0;
int local_data=0;
const long interval = 200; 
unsigned long previousMillis = 0;

//Structure example to send data
//Must match the receiver structure
typedef struct struct_message {
    int reading;
} struct_message;

// Create a struct_message to hold sensor readings
struct_message outbound;

// Create a struct_message to hold incoming sensor readings
struct_message inbound;

esp_now_peer_info_t peerInfo;

// Callback when data is sent
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("\r\nLast Packet Send Status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

// Callback when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
  memcpy(&inbound, incomingData, sizeof(inbound));
  Serial.print("Bytes received: ");
  Serial.println(len);
  arriving_data = inbound.reading;
}

void read_pot(){
  local_data = analogRead(34);
  Serial.print("Pot reading: ");
  Serial.println(local_data);
}

void printIncomingReadings(){
  // Display Readings in Serial Monitor
  Serial.println("INCOMING READINGS");
  Serial.println(arriving_data);
}
 
void setup() {
  // Init Serial Monitor
  Serial.begin(115200);
  pinMode(16,OUTPUT);
  pinMode(17,OUTPUT);
 
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Trasnmitted packet
  esp_now_register_send_cb(OnDataSent);
  
  // Register peer
  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  
  // Add peer        
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  // Register for a callback function that will be called when data is received
  esp_now_register_recv_cb(OnDataRecv);
}
 
void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) 
  {
    previousMillis = currentMillis;
    
  read_pot();
 
  // Set values to send
    outbound.reading = local_data;

  // Send message via ESP-NOW
  esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &outbound, sizeof(outbound));
   
  if (result == ESP_OK) {
    Serial.println("Sent with success");
  }
  else {
    Serial.println("Error sending the data");
  }

  }
    if(arriving_data>512)
  {
  digitalWrite(16, HIGH);
  } 
  else
  {
    digitalWrite(16, LOW);
  }
  if(local_data>2048)
  {
    //Serial.println("writing local led high");
    digitalWrite(17, HIGH);
  }
  else
  {
    //Serial.println("writing local led low");
    digitalWrite(17, LOW);
  }
}

Surely this circuit could be made even simpler.  As a learning exercise, the novice may consider replacing the potentiometer with a switch and  taking a digital reading rather than powering the local LED by GPIO.

ESP NOW sender and receiver basic project

ESP Now seems to be a link layer protocol for the ESP 32 and ESP 8266.  It is easy to use for a simple project passing data between an ESP 8266 with a sensor attached, to an ESP 32 with an actuator.

randomnerdtutorials.com has example ESP NOW code for the ESP8266 and ESP32, which form the basis for this project.

The addressing of ESP NOW uses MAC addresses.  In this project, the ESP 8266 is sending data to the ESP 32.  So, the MAC address of the ESP 32 is needed.  There is a code snippet in the link above that can be loaded into the ESP 32, and the MAC address retrieved from Arduino Serial Monitor.  In my case this address was 58:BF:25:31:9D:E0

This was put into the example code from the link above, for the ESP 8266:

/*
  Original Code by Rui Santos, edited for illustration of sensor data forwarding via ESP NOW on ESP 8266
  Complete project details at https://RandomNerdTutorials.com/esp-now-esp8266-nodemcu-arduino-ide/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <ESP8266WiFi.h>
#include <espnow.h>

// REPLACE WITH RECEIVER MAC Address
uint8_t broadcastAddress[] = {0x58, 0xBF, 0x25, 0x31, 0x9D, 0xE0};

// Structure example to send data
// Must match the receiver structure
typedef struct struct_message {
  char a[32];
  int b;
  float c;
  String d;
  bool e;
} struct_message;

// Create a struct_message called myData
struct_message myData;

unsigned long lastTime = 0;  
unsigned long timerDelay = 250;  // send readings timer

// Callback when data is sent
void OnDataSent(uint8_t *mac_addr, uint8_t sendStatus) {
  Serial.print("Last Packet Send Status: ");
  if (sendStatus == 0){
    Serial.println("Delivery success");
  }
  else{
    Serial.println("Delivery fail");
  }
}
 
void setup() {
  // Init Serial Monitor
  Serial.begin(115200);
 
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != 0) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Trasnmitted packet
  esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER);
  esp_now_register_send_cb(OnDataSent);
  
  // Register peer
  esp_now_add_peer(broadcastAddress, ESP_NOW_ROLE_SLAVE, 1, NULL, 0);
}
 
void loop() {
  if ((millis() - lastTime) > timerDelay) {
    // Set values to send
    strcpy(myData.a, "THIS IS A CHAR");
    myData.b = analogRead(A0);
    myData.c = 1.2;
    myData.d = "Hello";
    myData.e = false;

    // Send message via ESP-NOW
    esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));

    lastTime = millis();
  }
}

The only changes made to the original code are inputting the MAC address of the ESP 32, changing the value of the 'timerDelay' variable, and changing assignment to mydata.b from 'random(1,20);' to 'analogRead(A0);'.  The wiring is as follows:

• ESP8266 3.3 V Pin to Potentiometer High
• ESP8266 Gnd Pin to Potentiometer Low
• ESP8266 A0 Pin to Potentiometer wiper

Once flashed, the ESP8266 is powered by a 5V lithium battery, intended for use as a cellphone battery charger.

The ESP 32 code from the link above also has minor changes:

/*
  Original code by Rui Santos, minor additions made to actuate an LED upon receipt of ESP
  NOW data exceeding an arbitrary threshold.
  Complete project details at https://RandomNerdTutorials.com/esp-now-esp32-arduino-ide/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

#include <esp_now.h>
#include <WiFi.h>

// Structure example to receive data
// Must match the sender structure
typedef struct struct_message {
    char a[32];
    int b;
    float c;
    bool d;
} struct_message;

// Create a struct_message called myData
struct_message myData;

// callback function that will be executed when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
  memcpy(&myData, incomingData, sizeof(myData));
  Serial.print("Bytes received: ");
  Serial.println(len);
  Serial.print("Char: ");
  Serial.println(myData.a);
  Serial.print("Int: ");
  Serial.println(myData.b);
  Serial.print("Float: ");
  Serial.println(myData.c);
  Serial.print("Bool: ");
  Serial.println(myData.d);
  Serial.println();
}
 
void setup() {
  // Initialize Serial Monitor
  Serial.begin(115200);
  pinMode(4, OUTPUT);
    digitalWrite(4, HIGH);
    
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  
  // Once ESPNow is successfully Init, we will register for recv CB to
  // get recv packer info
  esp_now_register_recv_cb(OnDataRecv);
}
 
void loop() {
if(myData.b>512)
{
  digitalWrite(4, HIGH);
  }
  
  else
  {
    digitalWrite(4, LOW);
    }
}

The only changes made to the original code is addition of the 'if' and 'else' statements within the loop, and 'pinMode(4,OUTPUT);' and 'digitalWrite(4,HIGH);' in setup to make pin 4 ready to actuate an LED. The wiring is as follows:

• ESP32 Pin 4 to LED Anode
• LED Cathode to 150 Ohm resistor
• 150 Ohm Resistor to ESP32 Gnd Pin

Once flashed, the ESP 32 is powered by my PC USB port.  I can monitor the data received on Arduino Serial monitor, and confirm that the LED illuminates when the potentiometer wiper passes the 512 position.

Note "Int: 770", the wiper is past the threshold, the LED is on: 

Now the wiper is below the threshold ('Int: 390') and the LED is off:

Paring down the data structure to only send data that is necessary to function is an exercise left to the reader.

Multi-serial with software serial on Arduino Uno, Nano, etc

A problem an Arduino novice may face is the inclination to connect to a serial device (such as a Loadstar Loadcell read by their proprietary serial interface or a Benewake TF-LC02 Lidar Sensor) to an Arduino board with only one hardware serial interface (such as Arduino Uno or Nano) and then open the Arduino IDE Serial Monitor with hopes of using it to communicate with the serial device. This novice would (hopefully) notice right away that things aren't going as hoped. 

This post explains why this doesn't work.  My own experience is that I could send to the device but not get anything back, which is a little different that what is posted in that link, though I make no claim to knowing why.

The best solution allowing connection of Serial Monitor for input/output to a serial device, in my opinion, is to use an Arduino board with multiple hardware serial interfaces, such as an Arduino MEGA2560. The sample code here allows connection of a serial device to a second serial interface, relays all input and output to the Serial Monitor and vice versa.  This allows for testing of commands to the device, and a more involved sketch can be built out from there.

Unfortunately, the notional novice may be disinclined to buy new hardware.  Arduino does have at least one library for implementing a serial interface via software.  The code below adapts the code from the link above for use with boards with only one hardware serial interface, by using the Arduino Software Serial Library.  

The code:

  /*
  Multiple serial test with software serial

  Receives from the main serial (Serial 0), sends to software serial port configured in the code.
  Receives from software serial port, sends to the main serial port.

  This example works with boards with only one serial like Arduino Uno, Nano etc.

  The circuit:
  - any serial device attached to software serial pins defined below
    -device tx connects to Arduino pin 2
    -device rx connects to Arduino pin 3
    -device GND connects to Arduino GND
    -use own discretion about powering device (Device Vcc to 5v Arduino pin if safe)

  - Serial Monitor open on Serial port 0

  Adapted 10 Nov 2022 from Arduino multi serial code found at:
  https://docs.arduino.cc/built-in-examples/communication/MultiSerialMega.

  Original code:
  created 30 Dec 2008
  modified 20 May 2012
  by Tom Igoe & Jed Roach
  modified 27 Nov 2015
  by Arturo Guadalupi

  This example code is in the public domain.
*/


#include <SoftwareSerial.h>
const byte SSrx = 2;
const byte SStx = 3;

SoftwareSerial SoftSerial (SSrx, SStx);

void setup() {
  // initialize both serial ports:
  Serial.begin(115200);
  pinMode(SSrx, INPUT);
  pinMode(SStx, OUTPUT);
  SoftSerial.begin(115200);
}

void loop() {
  // read from software serial, send to built in serial:
  if (SoftSerial.available()) {
    int inByte = SoftSerial.read();
    Serial.write(inByte);
  }

  // read from built in serial, send to software serial:
  if (Serial.available()) {
    int inByte = Serial.read();
    SoftSerial.write(inByte);
  }
}

My experience is that the software serial connection generally works OK, but can't be relied upon 100% of the time.  Some bytes (or whole strings of bytes) may come through as the wrong characters, which is why I suggested the better solution is to use a board with more than one hardware serial connection.

Still, the sketch above may meet the novice's needs for demonstrating the serial connection and testing out a few commands.  Wiring should be as follows:

• Device TX to Arduino pin 2
• Device RX to Arduino pin 3
• Device GND to Arduino GND pin

If the device accepts 5V and current draw is within the limits of what can be supplied by the Arduino board, and powering from the Arduino is desired, then also connect

• Device Vcc to Arduino 5V pin

Below shows an Arduino Uno running the sketch above connected to an Arduino MEGA2560 (clone) using multi serial.

Output is shown in the screen capture below.  

As can be seen, the Arduino Uno seems to send just fine, but its receiving leaves something to be desired.

The barest fundementals

This post is written to be a pre-introduction to Arduino for an absolute novice (i.e. someone without a background in computer science, engineering, or calculus based physics).  We will discus the simplest electrical concepts that will be expanded upon as future lessons progress.

The water in pipes analogy

Imagine a water tower with a water wheel at the base, piping between the tank and the water wheel, and a valve to allow or stop flow.

Let's start by saying the valve is closed.

In physics, the water in the tower is said to possess 'potential energy.'  The water isn't doing anything; it is just sitting there.  But it is up high, and because of gravity it has the potential to be used below to turn the water wheel.

Now suppose we open the valve.

When the valve is opened, the speed of the water coming down the pipe will depend on the height of the tower and the water level in the tank, as well as whether the valve is fully open or only part way.

The speed of the water flow will influence how fast the water wheel turns, and correspondingly, how much energy can be extracted from it (if, for instance it were connected to a generator, or a device used for grinding grain, or whatever one uses a water wheel for).  

Here we have already touched on the fundamentals necessary to talk about electricity.

• Voltage is a measure of electrical potential, similar to the height of the water level.
• Current is a measure of how much electricity is flowing, similar to the rate of water flow through the pipe.
• Resistance is a measure of how much the wires and electrical components slow down the electrical flow (current) similar to the way the valve passes more or less water based on how open it is.

Circuits

A circuit is a loop.  Outside of the field of electronics, a race car might be said to be completing a circuit as it goes around a loop-shaped track. When talking about electrical systems, the term circuit is used to describe the path the electricity travels on when moving from a location with higher potential (voltage) to one of lower potential, and a simple diagram will show that that path is also a loop.



The circuit diagram above is for a flashlight.  A legend for the icons is bellow. 

Switch



Resistance

Light Bulb

Battery



The lines connecting the icons are the flashlight's wiring. 


Current flows on the wiring out of the positive side of the battery (marked "+"), through the switch (when the switch is closed), and through the light bulb to the negative side of the battery (marked "-").  So altogether it forms a loop or circuit.

Although in the diagram the resistance is marked as a single icon, in real life there is resistance all along the wire, inside the battery, in the switch and in the light bulb.  The resistance is marked as a single icon because it makes analysis of the circuit easier; if you want to know why, ask how in the comments, but it requires a bit of explanation that I didn't intend to get into here.

Bringing it all together

The concept of a circuit diverges from the water in pipes analogy a bit: In the water tower example, the water could just dump out on the ground after hitting the water wheel, and maybe it would run into a river or wherever.  A loop could be formed by having a collecting pool and a pump that charges water back to the tower, perhaps, but that does nothing to illustrate a fundamental difference between water and electricity: If a circuit is not connected by wire or some other current carrying material (light bulb filament, or the material from which the switch is made) the break is equivalent to an opened switch: current won't flow.  In terms of water flowing through pipes, if a pipe is severed, water will blow everywhere until a valve is closed stopping flow into the pipe upstream. 

In physical terms, a disconnected circuit experiences infinite resistance to (electrical current) flow, whereas a severed pipe presents zero resistance to (water) flow.  The implication of this is that when we are working with electricity, for anything to happen the current will need a way in (a path from high potential), and a way out (a path to low potential)



 





How to make Retropie work

This post is for visitors to my family's VRBO house.

In the downstairs bedroom I've provided a RetroPie, a Raspberry Pi micro-computer configured to emulate Nintendo Entertainment System and Super Nintendo for playing each respective systems' video games.

The RetroPie is fairly straightforward to use, but these instruction may help if any problems are encountered.

• Turn on the TV, tuned to video input and plug in the micro USB cable.
• If nothing happens, unplug and try again, as sometimes it doesn't take on the first power up.
• When plugged in you can see a couple LEDs shining through the vent on the side.  When it is working right the red will be illuminated, as well as the green; when it isn't working the red will be on but not green.
• If things are going correctly, a screen with four raspberries will be displayed, followed by some computer script, a 'Retropie' splash screen, a bit more script, an 'Emmulation Station' splash screen, and finally the main interface.
• On rare occasions a guest may be prompted to configure the controller.  Follow on-screen prompts to configure the buttons.  The 'L' and 'R' shoulder buttons should be configured to the 'bottom L' and 'bottom R' buttons, respectively.  Buttons not found on the controller can be skipped by holding down any button for a few seconds.
• On the main interface you can use either USB controller to select Nintendo Entertainment System or Super Nintendo by pressing left or right on the controller 'D' pad, and pushing the 'A' button. You will find long lists of games you can try.  
• If you get tired of one game while playing you can press 'start' and 'select' at the same time to exit from that game.
• The other options probably won't be of much interest to a casual user, but if you find something you like please leave me a comment, as I haven't spent a lot of time exploring the games and such that come with the default RetroPie distribution.  I think there is Doom and Minecraft, but I haven't spent any time on them.

All Super Nintendo and Nintendo Entertainment System ROMs are legal copies of games from my collection, procured between ~1987-2005.

Fully configured devices are available for purchase on my ebay store (link), but the micro SD card that comes with it will necessarily not contain the game ROMs (we aim to avoid unlawful distribution of those files).   If the micro SD card goes missing during your stay a $20.00 replacement fee will be assessed from the credit card that was used to make the deposit for the house.  If the entire system is removed the replacement fee is $100.00.

Incidentally, this system is capable of playing games from systems as powerful as the original Playstation.  A more powerful version capable of emulating Nintendo 64 titles will be made available when the Raspberry Pi 3 becomes more available.

Arduino Pro Mini Clones Part 2

Continuing my investigation of cheap Chinese knock offs of Sparkfun's Arduino Pro Mini design...

As mentioned in Part 1, I purchased one of each of what I called the Common, Two Row and Big Oscillator PCB designs.  Since Part 1 I went ahead and bought the other two common designs as well, the old and new Sparkfun designs.

Of course the first difficulty a novice will find when graduating to using pro mini clones is overcoming the lack of USB port.  Anticipating this I ordered the Two Row board as a package deal that came with three different kinds of USB to Serial converters: PL2303, CH340 and CP2102.

All three converters required drivers, found at the following sites (I was using a Mac, for other OSs you may have search around):

PL2303 - http://www.prolific.com.tw/US/ShowProduct.aspx?p_id=229&pcid=41
CH340 - http://www.wch.cn/downloads.php?name=pro&proid=5
CP2102 - https://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx

The wiring between any converter and board should be as follows:
5V to VCC
Ground to Ground
TX to RX
RX to TX

After loading up drivers and figuring out the correct wiring, the next problem I ran into was that all three of these USB converters have no support for automated resetting of the board during programming.  This results in an error while programming almost every time (I can't say why, but on the first try the program went through perfectly without any messing with reset, but later attempts almost always failed).

I started searching for the reason and was pretty disappointed by the level of detail in the answers (basically, answers were along the line of "reset before/during upload").  One suggestion was to turn on verbose output,

which I found helpful at slowing down the upload process, but I still couldn't figure out exactly when to press reset, whether to hold it for a little while or release immediately and so forth.  After a bit of trial and error I did get the timing figured out and I will post a video of the process so that it is perfectly clear how to get a good load.  Hopefully a video can save any intrepid readers that same trial and error, as pushing and releasing the reset button has a certain rhythm to it that works for me.

Once the timing was sorted out, the converters all work fine, and now that the drivers are loaded on my computer I could grab one indiscriminately when I want to load a sketch.

Ultimately, it should be noted that this is a super scrimp-and-save approach that led to extra headaches which an FTDI USB to serial converter would avoid for just a little more money spent, as the FTDI converters support automated resetting during sketch uploading.  After having so much fun figuring out how to use the others I went ahead and purchased an FT232RL FTDI USB to serial converter.  I intend to use it as my go-to programmer, allowing upload without this rhythmic button pushing nonsense.  It didn't need any drivers, though I use a Mac and I think I heard mention of needing drivers for windows.  Good luck finding them.

Finally, I did see some suggestions to solder headers to the 6 pins of the pro mini used in uploading, and while I agree that it is good engineering practice, I don't tend to have the patience for it.  I usually can still get a good load if I hold the header with the wires to the converter in contact with the board just so.  Your mileage may vary; break out the soldering iron if you think you need it.