Updating a “Follow Me Cooler” Arduino project to use an ESP8266 wifi
Hello,
I came across this cool project for a “Follow Me Cooler” that uses Bluetooth on an Arduino and an old version of the Blynk platform. Since Blynk no longer supports Bluetooth, I am trying to substitute a NodeMCU 12e (ESP8266) with Wi-Fi to do the same thing.
I’ve added all required code to access the Blynk cloud and I can get a WiFi signal. All my devices are wired correctly. However, all I see in the serial monitor is this shown below.
10:24:38.079 ->
10:24:38.079 -> ets Jan 8 2013,rst cause:4, boot mode:(3,6)
10:24:38.079 ->
10:24:38.079 -> wdt reset
10:24:38.079 -> load 0x4010f000, len 3460, room 16
10:24:38.079 -> tail 4
10:24:38.079 -> chksum 0xcc
10:24:38.079 -> load 0x3fff20b8, len 40, room 4
10:24:38.079 -> tail 4
10:24:38.079 -> chksum 0xc9
10:24:38.126 -> csum 0xc9
10:24:38.126 -> v000499b0
10:24:38.126 -> ~ld
10:24:38.173 -> ------------------------------------
10:24:38.173 -> Sensor: HMC5883
10:24:38.173 -> Driver Ver: 1
10:24:38.173 -> Unique ID: 12345
10:24:38.173 -> Max Value: 800.00 uT
10:24:38.173 -> Min Value: -800.00 uT
10:24:38.173 -> Resolution: 0.20 uT
10:24:38.173 -> ------------------------------------
10:24:38.173 ->
Has anyone ever tried this? If so, what changes do you recommend? Below is my actual code. Any help is greatly appreciated.
Thank you.
//Blynk Template settings
#define BLYNK_TEMPLATE_ID "BLYNK_TEMPLATE_ID"
#define BLYNK_DEVICE_NAME "Cooler Quickstart Template"
#define BLYNK_AUTH_TOKEN "BLYNK_AUTH_TOKEN"
// Imports
#include <ESP8266WiFi.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_HMC5883_U.h>
#include <Servo.h>
#include <SoftwareSerial.h>
#include <BlynkSimpleSerialBLE.h>
#include <TinyGPS.h> // Use local version of this library
#include <CoolerDefinitions.h>
#ifndef STASSID
#define STASSID "your_network"
#define STAPSK "your_password"
#endif
const char* ssid = STASSID;
const char* password = STAPSK;
// void setup() {
// }
// GPS
TinyGPS gps;
// Lid
Servo lidServo;
// CoolerLid lidState = CLOSED;
// Master Enable
bool enabled = false;
//WidgetTerminal terminal(V3);
// Serial components
SoftwareSerial bluetoothSerial(BLUETOOTH_TX_PIN, BLUETOOTH_RX_PIN);
SoftwareSerial nss(GPS_TX_PIN, 255); // TXD to digital pin 6
/* Compass */
Adafruit_HMC5883_Unified mag = Adafruit_HMC5883_Unified(12345);
GeoLoc checkGPS() {
Serial.println("Reading onboard GPS: ");
bool newdata = false;
unsigned long start = millis();
while (millis() - start < GPS_UPDATE_INTERVAL) {
if (feedgps())
newdata = true;
}
if (newdata) {
return gpsdump(gps);
}
GeoLoc coolerLoc;
coolerLoc.lat = 0.0;
coolerLoc.lon = 0.0;
return coolerLoc;
}
// Get and process GPS data
GeoLoc gpsdump(TinyGPS &gps) {
float flat, flon;
unsigned long age;
gps.f_get_position(&flat, &flon, &age);
GeoLoc coolerLoc;
coolerLoc.lat = flat;
coolerLoc.lon = flon;
Serial.print(coolerLoc.lat, 7); Serial.print(", "); Serial.println(coolerLoc.lon, 7);
Serial.print("CoolerLoc");
return coolerLoc;
}
// Feed data as it becomes available
bool feedgps() {
while (nss.available()) {
if (gps.encode(nss.read()))
return true;
}
return false;
}
// Lid Hook
//BLYNK_WRITE(V0) {
// switch (lidState) {
// case OPENED:
// setServo(SERVO_LID_CLOSE);
// lidState = CLOSED;
// break;
// case CLOSED:
// setServo(SERVO_LID_OPEN);
// lidState = OPENED;
// break;
// }
//}
// Killswitch Hook
BLYNK_WRITE(V1) {
enabled = !enabled;
//Stop the wheels
stop();
}
// GPS Streaming Hook
BLYNK_WRITE(V2) {
GpsParam gps(param);
Serial.println("Received remote GPS: ");
// Print 7 decimal places for Lat
Serial.print(gps.getLat(), 7); Serial.print(", "); Serial.println(gps.getLon(), 7);
GeoLoc phoneLoc;
phoneLoc.lat = gps.getLat();
phoneLoc.lon = gps.getLon();
driveTo(phoneLoc, GPS_STREAM_TIMEOUT);
}
// Terminal Hook
BLYNK_WRITE(V3) {
Serial.print("Received Text: ");
Serial.println(param.asStr());
String rawInput(param.asStr());
int colonIndex;
int commaIndex;
do {
commaIndex = rawInput.indexOf(',');
colonIndex = rawInput.indexOf(':');
if (commaIndex != -1) {
String latStr = rawInput.substring(0, commaIndex);
String lonStr = rawInput.substring(commaIndex+1);
if (colonIndex != -1) {
lonStr = rawInput.substring(commaIndex+1, colonIndex);
}
float lat = latStr.toFloat();
float lon = lonStr.toFloat();
if (lat != 0 && lon != 0) {
GeoLoc waypoint;
waypoint.lat = lat;
waypoint.lon = lon;
Serial.print("Waypoint found: "); Serial.print(lat); Serial.println(lon);
driveTo(waypoint, GPS_WAYPOINT_TIMEOUT);
}
}
rawInput = rawInput.substring(colonIndex + 1);
} while (colonIndex != -1);
}
void displayCompassDetails(void)
{
sensor_t sensor;
mag.getSensor(&sensor);
Serial.println("------------------------------------");
Serial.print ("Sensor: "); Serial.println(sensor.name);
Serial.print ("Driver Ver: "); Serial.println(sensor.version);
Serial.print ("Unique ID: "); Serial.println(sensor.sensor_id);
Serial.print ("Max Value: "); Serial.print(sensor.max_value); Serial.println(" uT");
Serial.print ("Min Value: "); Serial.print(sensor.min_value); Serial.println(" uT");
Serial.print ("Resolution: "); Serial.print(sensor.resolution); Serial.println(" uT");
Serial.println("------------------------------------");
Serial.println("");
delay(500);
}
#ifndef DEGTORAD
#define DEGTORAD 0.0174532925199432957f
#define RADTODEG 57.295779513082320876f
#endif
float geoBearing(struct GeoLoc &a, struct GeoLoc &b) {
float y = sin(b.lon-a.lon) * cos(b.lat);
float x = cos(a.lat)*sin(b.lat) - sin(a.lat)*cos(b.lat)*cos(b.lon-a.lon);
return atan2(y, x) * RADTODEG;
}
float geoDistance(struct GeoLoc &a, struct GeoLoc &b) {
const float R = 6371000; // km
float p1 = a.lat * DEGTORAD;
float p2 = b.lat * DEGTORAD;
float dp = (b.lat-a.lat) * DEGTORAD;
float dl = (b.lon-a.lon) * DEGTORAD;
float x = sin(dp/2) * sin(dp/2) + cos(p1) * cos(p2) * sin(dl/2) * sin(dl/2);
float y = 2 * atan2(sqrt(x), sqrt(1-x));
return R * y;
}
float geoHeading() {
/* Get a new sensor event */
sensors_event_t event;
mag.getEvent(&event);
// Hold the module so that Z is pointing 'up' and you can measure the heading with x&y
// Calculate heading when the magnetometer is level, then correct for signs of axis.
float heading = atan2(event.magnetic.y, event.magnetic.x);
// Offset
heading -= DECLINATION_ANGLE;
heading -= COMPASS_OFFSET;
// Correct for when signs are reversed.
if(heading < 0)
heading += 2*PI;
// Check for wrap due to addition of declination.
if(heading > 2*PI)
heading -= 2*PI;
// Convert radians to degrees for readability.
float headingDegrees = heading * 180/M_PI;
// Map to -180 - 180
while (headingDegrees < -180) headingDegrees += 360;
while (headingDegrees > 180) headingDegrees -= 360;
return headingDegrees;
}
void setServo(int pos) {
lidServo.attach(SERVO_PIN);
lidServo.write(pos);
delay(2000);
lidServo.detach();
}
void setSpeedMotorA(int speed) {
digitalWrite(MOTOR_A_IN_1_PIN, LOW);
digitalWrite(MOTOR_A_IN_2_PIN, HIGH);
// set speed to 200 out of possible range 0~255
analogWrite(MOTOR_A_EN_PIN, speed + MOTOR_A_OFFSET);
}
void setSpeedMotorB(int speed) {
digitalWrite(MOTOR_B_IN_1_PIN, LOW);
digitalWrite(MOTOR_B_IN_2_PIN, HIGH);
// set speed to 200 out of possible range 0~255
analogWrite(MOTOR_B_EN_PIN, speed + MOTOR_B_OFFSET);
}
void setSpeed(int speed)
{
// this function will run the motors in both directions at a fixed speed
// turn on motor A
setSpeedMotorA(speed);
// turn on motor B
setSpeedMotorB(speed);
}
void stop() {
// now turn off motors
digitalWrite(MOTOR_A_IN_1_PIN, LOW);
digitalWrite(MOTOR_A_IN_2_PIN, LOW);
digitalWrite(MOTOR_B_IN_1_PIN, LOW);
digitalWrite(MOTOR_B_IN_2_PIN, LOW);
}
void drive(int distance, float turn) {
int fullSpeed = 230;
int stopSpeed = 0;
// drive to location
int s = fullSpeed;
if ( distance < 8 ) {
int wouldBeSpeed = s - stopSpeed;
wouldBeSpeed *= distance / 8.0f;
s = stopSpeed + wouldBeSpeed;
}
int autoThrottle = constrain(s, stopSpeed, fullSpeed);
autoThrottle = 230;
float t = turn;
while (t < -180) t += 360;
while (t > 180) t -= 360;
Serial.print("turn: ");
Serial.println(t);
Serial.print("original: ");
Serial.println(turn);
float t_modifier = (180.0 - abs(t)) / 180.0;
float autoSteerA = 1;
float autoSteerB = 1;
if (t < 0) {
autoSteerB = t_modifier;
} else if (t > 0){
autoSteerA = t_modifier;
}
Serial.print("steerA: "); Serial.println(autoSteerA);
Serial.print("steerB: "); Serial.println(autoSteerB);
int speedA = (int) (((float) autoThrottle) * autoSteerA);
int speedB = (int) (((float) autoThrottle) * autoSteerB);
setSpeedMotorA(speedA);
setSpeedMotorB(speedB);
}
void driveTo(struct GeoLoc &loc, int timeout) {
nss.listen();
GeoLoc coolerLoc = checkGPS();
bluetoothSerial.listen();
if (coolerLoc.lat != 0 && coolerLoc.lon != 0 && enabled) {
float d = 0;
//Start move loop here
do {
nss.listen();
coolerLoc = checkGPS();
bluetoothSerial.listen();
d = geoDistance(coolerLoc, loc);
float t = geoBearing(coolerLoc, loc) - geoHeading();
Serial.print("Distance: ");
Serial.println(geoDistance(coolerLoc, loc));
Serial.print("Bearing: ");
Serial.println(geoBearing(coolerLoc, loc));
Serial.print("heading: ");
Serial.println(geoHeading());
drive(d, t);
timeout -= 1;
} while (d > 3.0 && enabled && timeout>0);
stop();
}
}
void setupCompass() {
/* Initialise the compass */
if(!mag.begin())
{
/* There was a problem detecting the HMC5883 ... check your connections */
Serial.println("Ooops, no HMC5883 detected ... Check your wiring!");
while(1);
}
/* Display some basic information on this sensor */
displayCompassDetails();
}
void setup()
{
Serial.begin(115200);
// We start by connecting to a WiFi network
/* Explicitly set the ESP8266 to be a WiFi-client, otherwise, it by default,
would try to act as both a client and an access-point and could cause
network-issues with your other WiFi-devices on your WiFi-network. */
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
// while (WiFi.status() != WL_CONNECTED) {
// delay(500);
// Serial.print(".");
// Serial.println("");
// Serial.println("WiFi connected");
// Serial.println("IP address: ");
// Serial.println(WiFi.localIP());
// }
// Compass
setupCompass();
// Motor pins
pinMode(MOTOR_A_EN_PIN, OUTPUT);
pinMode(MOTOR_B_EN_PIN, OUTPUT);
pinMode(MOTOR_A_IN_1_PIN, OUTPUT);
pinMode(MOTOR_A_IN_2_PIN, OUTPUT);
pinMode(MOTOR_B_IN_1_PIN, OUTPUT);
pinMode(MOTOR_B_IN_2_PIN, OUTPUT);
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH);
//Debugging via serial
Serial.begin(4800);
//GPS
nss.begin(9600);
//Bluetooth
bluetoothSerial.begin(9600);
Blynk.begin(bluetoothSerial, auth);
}
// Testing
void testDriveNorth() {
float heading = geoHeading();
int testDist = 10;
Serial.println(heading);
while(!(heading < 5 && heading > -5)) {
drive(testDist, heading);
heading = geoHeading();
Serial.println(heading);
delay(500);
}
stop();
}
void loop(){
Blynk.run();
// Serial_Printing();
// Serial.print("Waypoint found: ");
}
For additional info, the code references a CoolerDefinitions.h file. That code is shown below:
// Blynk Auth
char auth[] = "BLYNK_AUTH_TOKEN";
// Pin variables
#define SERVO_PIN 4
#define GPS_TX_PIN 6
#define BLUETOOTH_TX_PIN 10
#define BLUETOOTH_RX_PIN 11
#define MOTOR_A_EN_PIN 5
#define MOTOR_B_EN_PIN 9
#define MOTOR_A_IN_1_PIN 4
#define MOTOR_A_IN_2_PIN 3
#define MOTOR_B_IN_1_PIN 1
#define MOTOR_B_IN_2_PIN 0
// If one motor tends to spin faster than the other, add offset
#define MOTOR_A_OFFSET 20
#define MOTOR_B_OFFSET 0
// You must then add your 'Declination Angle' to the compass, which is the 'Error' of the magnetic field in your location.
// Find yours here: http://www.magnetic-declination.com/
// Mine is: 13° 24' E (Positive), which is ~13 Degrees, or (which we need) 0.23 radians
#define DECLINATION_ANGLE 0.23f
// The offset of the mounting position to true north
// It would be best to run the /examples/magsensor sketch and compare to the compass on your smartphone
#define COMPASS_OFFSET 0.0f
// How often the GPS should update in MS
// Keep this above 1000
#define GPS_UPDATE_INTERVAL 1000
// Number of changes in movement to timeout for GPS streaming
// Keeps the cooler from driving away if there is a problem
#define GPS_STREAM_TIMEOUT 18
// Number of changes in movement to timeout for GPS waypoints
// Keeps the cooler from driving away if there is a problem
#define GPS_WAYPOINT_TIMEOUT 45
// PWM write for servo locations
// #define SERVO_LID_OPEN 20
// #define SERVO_LID_CLOSE 165
// Definitions (don't edit these)
struct GeoLoc {
float lat;
float lon;
};
//enum CoolerLid {
// OPENED,
// CLOSED
//};