James: ummmm bike - wash and flip.

He is profit oriented, I am waste my own time oriented.

Somehow I've got it into my head that we can amalgamate this by flipping modern bikes while I do a bit of a restoration on a vintage bike. I came across an ebay advert:

RARE! Vintage Black Delivery Style Raleigh Bike for restoration

"It’s very old, possibly pre war. I’ve taken a picture of the hub head made by Sturmey Archer which gives some indication. The gear shift is not connected and I do not know if the gears operate or not. Everything else on the bicycle operates but needs a good clean up. It is a while since I tested it so the brakes might be less than roadworthy."

Well. I did a little bit of research, primarily based on the Sturmey-Archer hub, which has "AB-8" on it. From what I understand, the "AB" means it is a 3-speed hub with integrated brake. The -8 took a little more reading but it seems that a single-digit suffix was only used for a 9-year period. According to colwoodwheelworks this means what we have here is a 1938 hub. And it's fair to assume the bike therefore is a 1938 model.

I then managed to find a 1938 Raleigh catalogue online and only two models had the top bar mounted shifter, the Dawn Safety Tourist Model 20 and the Sports 'C' Tourist Model 38. The primary difference seems to be frame size, the Dawn being 22" and the Sports 'C' being 21". A quick measure and it seems ours is 21".

The only confusion being ours seems to have the Sturmey-Archer brake on the back like the 38X but the rim brakes on the front like the model 38. Perhaps the front wheel was changed, maybe it's a special build, it could even be a completely different model and I've got it all wrong!

After entering some discussion with Peter the lovely previous owner with a true gift for showing an interest in people, I mounted the bike into the rear seat of my wife's A5 cabrio (her having taken my estate car for the week) and brought it home in bits.

And that's how it is now. In bits, with some obvious first work to do:
- Remove the tinware for straightening
- Remove the chain for cleaning
- A general de-grease
- Replace the Sturmey-Archer gear cable.

Then I'll reassemble (probably sans the tinware for now) and see if it rides!

Defeating the Blank Page

Prompt:

I am doing an A-level in Computer Science. I am studying the AQA specification. My project, known as NEA or non-examined assessment, is a Python program to illustrate physics concepts for other students. I am taking a rapid application design approach to writing the program.

I have attached the NEA guidance document from the exam board.

I need a template for my NEA report. Please give me headings with as many levels of sub-headings as you feel appropriate.

Output:

Prompt:

How should I frame my "Overview of the NEA project"?

Output:

Summarising Knuth

Prompt:

I'm an undergraduate Computer Science student. I am struggling to understand the attached document. Summarise the concepts in terms I can understand.

Note: The GPT was provided with a copy of a Knuth preprint

Output:

A Little More Knuth

Prompt:

Please go into more detail summarising algorithm Q according to Knuth's paper.

Output:

Knuth for Seven Year Olds

Prompt:

I'm still struggling. Explain algorithm Q as if I am a seven year old that knows nothing about Computer Science.

Output:

Am I right in thinking...

Prompt:

I am studying Computer Science. I am covering complexity. In terms of time complexity, am I right in thinking that big-oh complexity tells me the worst case complexity and big-theta tells me the exact complexity?

Output:

Am I really right in thinking...

Prompt:

Is there anything else about this I might have misunderstood?

Output:

Debugging Code

Prompt:

My program is supposed to count down from 10 to a number I input, but it is stopping one above the question I input. For example, if I input 4 it counts down from 10 to 5. What do I need to do to fix this?

Code File Provided:

# problem 1

countDownTo = int(input('What would you like to count down to? '))
for i in range(10,countDownTo,-1):
    print('I count...',i)

Output:

countDownTo = int(input('What would you like to count down to? '))
for i in range(10, countDownTo, -1):
    print('I count...', i)

for i in range(10, countDownTo - 1, -1):

countDownTo = int(input('What would you like to count down to? '))
for i in range(10, countDownTo - 1, -1):  # Adjust stop value
    print('I count...', i)

I count... 10
I count... 9
I count... 8
I count... 7
I count... 6
I count... 5
I count... 4

Debugging Code Without the Fix

Prompt:

My program is supposed to count down from 10 to a number I input, but it is stopping one above the question I input. For example, if I input 4 it counts down from 10 to 5. What do I need to do to fix this? Please explain what I have done wrong but do not fix my code, I want to figure that bit out myself.

Code File Provided:

# problem 1

countDownTo = int(input('What would you like to count down to? '))
for i in range(10,countDownTo,-1):
    print('I count...',i)

Output:

for i in range(10, countDownTo, -1):
    print('I count...', i)

Debugging Code - Simple prompt and multiple problems

Prompt:

My program doesn't work properly. What's wrong with it?

Code File Provided:

# problem 2

countDownTo = input('What would you like to count down to? '
for i in range(10,countDownTo,-1):
    print('I count...',i)

Output:

countDownTo = input('What would you like to count down to? ')

countDownTo = int(input('What would you like to count down to? '))

for i in range(10, countDownTo - 1, -1):

countDownTo = int(input('What would you like to count down to? '))

for i in range(10, countDownTo - 1, -1):
    print('I count...', i)

Quiz Questions

Prompt:

I am an A-level student studying AQA Computer Science. Please quiz me on networks.

Output:

Interactive Quiz Questions

Prompt:

I am an A-level student studying AQA Computer Science. Please quiz me interactively on networks.

Output:

Finding Citations

Prompt (Standard ChatGPT):

Find me citations supporting the use of rock music to enhance learning.

Output:

Finding Citations

Prompt (Scholar GPT):

Find me citations supporting the use of rock music to enhance learning.

Output:

Finding Citations

Prompt (Scholar AI):

Find me citations supporting the use of rock music to enhance learning.

Output:

Recording of the workshop:

• Walkthrough as a PowerPoint
• Walkthrough as a PDF

Or Walkthrough as a video on YouTube.

The code, for those that don't like typing...

Part 1

int buttonValue;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  buttonValue = analogRead(A0);
  Serial.println(buttonValue);
  delay(100);
}

Part 2

int buttonValue;

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  buttonValue = analogRead(A0);

  if (buttonValue < 100) {
    prevButton = '0';
  } else if (buttonValue < 200) {
    Serial.println("A");
  } else if (buttonValue < 350) {
    Serial.println("B");
  } else if (buttonValue < 500) {
    Serial.println("C");
  } else {
    Serial.println("D");
  } 
  
  delay(100);
}

Part 3

int buttonValue;
char prevButton;


void setup()
{
  Serial.begin(9600);
  prevButton = '0';  
}

void loop()
{
  buttonValue = analogRead(A0);

  if (buttonValue < 100) {
    prevButton = '0';
  } else if (buttonValue < 200) {
    if (prevButton == '0') {
      Serial.println("A");
    }
    prevButton = 'A';
  } else if (buttonValue < 350) {
    if (prevButton == '0') {
      Serial.println("B");
    }
    prevButton = 'B';
  } else if (buttonValue < 500) {
    if (prevButton == '0') {
      Serial.println("C");
    }
    prevButton = 'C';
  } else {
    if (prevButton == '0') {
      Serial.println("D");
    }
    prevButton = 'D';
  } 
  
  delay(100);
}

Part 4

#include <EEPROM.h>

int buttonValue;
char prevButton;


void setup()
{
  Serial.begin(9600);
  prevButton = '0';  
  pinMode(5,INPUT_PULLUP);
  pinMode(6,INPUT_PULLUP);
}

void saveValue(char value) {
  bool carryOn = true;
  int index = 0;
  Serial.println("Saving value");
  do {
    if (EEPROM[index] == 0) {
      carryOn = false;
    } else {
      index = index + 1;
    }
  } while (carryOn == true and index < EEPROM.length());
  Serial.print("Index found: ");
  Serial.println(index);
  EEPROM.write(index,value);
  Serial.println("Saved");
}


void loop()
{
  if (digitalRead(5) == LOW) {
    Serial.println("Showing EEPROM");
    for (int index = 0; index < EEPROM.length(); index++) {
      if (EEPROM[index] > 0) {
        Serial.println(EEPROM[index]);
      }
    }
    Serial.println("All shown.");
  }
  if (digitalRead(6) == LOW) {
    Serial.println("Clearing EEPROM (takes some time)");
    for (int i = 0 ; i < EEPROM.length() ; i++) {
      EEPROM.write(i, 0);
    }
    Serial.println("EEPROM Cleared");
  }

  
  buttonValue = analogRead(A0);

  if (buttonValue < 100) {
    prevButton = '0';
  } else if (buttonValue < 200) {
    if (prevButton == '0') {
      Serial.println("A");
      saveValue('A');
    }
    prevButton = 'A';
  } else if (buttonValue < 350) {
    if (prevButton == '0') {
      Serial.println("B");
      saveValue('B');
    }
    prevButton = 'B';
  } else if (buttonValue < 500) {
    if (prevButton == '0') {
      Serial.println("C");
      saveValue('C');
    }
    prevButton = 'C';
  } else {
    if (prevButton == '0') {
      Serial.println("D");
      saveValue('D');
    }
    prevButton = 'D';
  } 
  
  delay(100);
}

Recording of the workshop:

• Walkthrough as a PowerPoint
• Walkthrough as a PDF

Or Walkthrough as a video on YouTube.

int photoCellPin = 0;
int photoCellReading;
int LEDPin = 3;
int LEDBrightness;



void setup()
{
  Serial.begin(9600);
  pinMode(LEDPin, OUTPUT);
  pinMode(photoCellPin,INPUT);
}

void loop()
{
  photoCellReading = analogRead(photoCellPin);
  Serial.print("Analog reading = ");
  Serial.println(photoCellReading);
  photoCellReading = 1023 - photoCellReading;
  LEDBrightness = map(photoCellReading, 0, 1023, 0, 255);
  Serial.print("LED output = ");
  Serial.println(LEDBrightness);
  analogWrite(LEDPin, LEDBrightness);
  delay(100);
}

So this section really is just a combination of the previous two parts. Firstly we add the button circuitry to the existing web server circuit. This means a 10k from one side of the switch, via a jumper wire to the - rail, with another jumper from the same side of the swith do digital pin 5 on the Arduino, then a jumper wire from the other side of the switch to the + rail. This circuit can be seen here.

Then we add a few lines of code;

const int buttonPin = 5; //We will use D5 as the pin reading button goes at the top in the declarations.

pinMode(buttonPin, INPUT); //Open up the chosen pin for input goes in the setup to open up the input pin.

Finally, we adjust the section of loop() to include a check of the input pin value, and output the corresponding response:

    if (connectionId != -1)
    {
      //build the webpage
      String webpage = "<html><head><title>Testing!</title></head>";
      webpage += "<body><h1>Button Check</h1><p>Digital Button 5 is: ";
      if (digitalRead(buttonPin) == HIGH)
      {
        webpage += "High";
      }
      else
      {
        webpage += "Low";
      }
      webpage += "</p></body></html>";
      sendWebpage(connectionId, webpage); //Send the webpage
    }

You can access the whole modified code here if you are too lazy to type it all in yourself.

And that really much is it. If you hit the same IP address as before in your browser, you should see (without pressing the button):

And then if you hold the button and hit refresh:

Now things are starting to get interesting! If you did some port forwarding, you could access that from work and tell if anyone has broken in to your workshop and pressed your button!

In the next section we will start looking at the thing that actually triggered this whole series of tutorials, responding to multiple buttons!

The next tutorial is going to be looking at reporting a button state on the web server we built in part 3. First though, we're going to make sure we can build a button that works! I tend to say button; you may see switch, tactile switch, momentary switch... I like 'button'. Regardless, you're most likely to have ones that look like this:

Although I always struggle to remember which of the legs are common and not - I have prefer simple ones like these:

You can remove out the other circuits if you wish and build this one from scratch. I just disconnected the digital pins from the Arduino and left everything else where it was.

The simplest way to build such a circuit would be to have a button with one side

connected to + and one side connected to the digital pin. When the switch is open the pin receives no input (which we call LOW). When the switch is closed, the switch receives input (which we call HIGH). However, there's  bit of a problem here in that when the switch is open, it is called 'floating' and can report false values.

Instead what we do is connect one side of the switch to + and the other end to -. However this would cause a short circuit so between the - and the switch we put a resistor - 10k being a common choice (though almost anything around that range will do). We then connect the digital pin (in this case D5) to the switch on the - side.

This is called a pull down resistor. There's nothing special about the resistor, it's a normal resistor that serves a purpose. Having the digital pin connected to - normally (via the resistor) means it is held to 0v - it reports a consistent low. Closing the switch allows the +'ve current to flow through the switch, and as it's easier for the current to go to the digital pin than force it's way through the resistor to ground, that's the route it takes and we get a consistent high signal. There are also pull-up resistors which do the same thing but hold the signal high and closing the switch drags it low. For this system the choice is purely arbitrary.

For power you could connect to the +3.3v (or even +5v) of the Arduino and run the - from ground on the Arduino. However, this would not be what we want for the next part of the project so we instead will connect the +/- rails to a 3.3v supply from elsewhere and just connect the Arduino ground to the - rail.

I've drawn the circuit out for you here.

Now for the code. We could just have the LED light up when the button is pressed and out when not, but I like to go a bit overboard so the code below has the LED (I used the built in LED) flash fast if the button is HIGH (closed) and slowly if it is LOW (open). I also have it output the value (as 1 or 0 accordingly) on the serial monitor.

const int buttonPin = 5; //We will use D5 as the pin reading button

void setup() {
  pinMode(LED_BUILTIN, OUTPUT); //Open up the built in LED for output
  pinMode(buttonPin, INPUT); //Open up the chosen pin for input
  Serial.begin(9600); //Use the serial monitor 
}

void loop() {
    Serial.print(digitalRead(buttonPin)); //Ouput the current state of the button to the monitor
    if (digitalRead(buttonPin) == HIGH) {  //If it's high/closed
      digitalWrite(LED_BUILTIN,HIGH);
      delay(100); //flash fast
      digitalWrite(LED_BUILTIN,LOW);
      delay(100);
    } else { //or it's low/closed
      digitalWrite(LED_BUILTIN,HIGH);
      delay(500); //flash slow
      digitalWrite(LED_BUILTIN,LOW);
      delay(500);
    }
}

Give it a try. Next we will look at combining the button press to and the web server.

In part 2 of this exploration we connected to and programmed an ESP8266 WiFi module from an Arduino Nano. In this part we will modify that solution to hold a static web page.

This is where things started getting tricky; most of the examples I found online either simply did not work, or worked very intermittently. The key problem was the attempts to connect to and set up the esp8266 connection automatically - what worked absolutely fine when I was typeing AT commands in just didn't like to work when I was sending the commands in code.

So, this may not be the right way, but it's a way which I have found works. Mostly. And at least when it doesn't it gives you a flashing light to tell you to hit restart!

The circuit is the same as last time but the code is substantially different. I based my code off of code produced by MJRobot which was the closest I could find to working.

I needed a number of subroutines.

doCommand() was designed to send a command to the esp8266, just as if you are sending an AT command. The problem was working out whether it worked, failed, or just needed a bit of time to sort itself out.

My method was to run the command as-is, guessing it would say "OK" when things work and something like "FAIL" when it didn't (both these strings being passed in as parameters). If it detected the "OK" it would return true. If it detected the "FAIL" string it would return false. If it didn't detect either, it would wait msdelay milliseconds and then try again.

If of course things went horribly wrong, I watched the serial monitor and adjusted the OK and FAIL strings checks accordingly :)

I've also included a debug flag which basically outputs all the serial data and a bit extra (eg some lines to split/combine the output) to enable you to figure out what's happening. This function would be a lot shorter without that!

Note I've not included a time-out. This is because at least for now I want it to just keep trying until something works! I may, or may not, add that at some point in the future.

bool doCommand(String command, String success, String failure, int msdelay, bool debug) {
  String s = "";
  char c = "";
  esp8266.write(command.c_str()); //write the command to the esp8266. Note this has to be a c_string.
  while (true) { //repeat forever (this is where the timeout would have to go I suppose)
    delay(msdelay); //wait a moment before carrying on
    while(esp8266.available()) //If the esp8266 has content
    {
      c = esp8266.read(); //read it
      if (debug) {
        Serial.write(c); //output if debug
      }
      s += c; //add to the received string
    }
    if (debug)
    {
      Serial.print("---");
      Serial.print(s);      //once we have a whole string, output it
      Serial.println("---");
    }
    if (s.indexOf(failure) > 0) //check if the failure string is found. This goes first as sometimes 
    {                           //a 'false success' occurs (ie getting an IP address, it returns 0.0.0.0)
       if (debug)
       {
        Serial.println("Failure detected."); //output if debug
       }
      return false; //leave the loop
    }
    else 
    {
     if (s.indexOf(success) > 0)//check if success string is found
     {
       if (debug)
       {
        Serial.println("Success detected."); //output if debug
       }
       return true; //leave the loop
     }
    }
  }
}

When the esp8266 receives a request from a web client, it gets a +IPD message which has a connection ID. I wrote a little helper to check if an +IPD had been received and return either the connection ID (-48 for some reason I don't understand but seems to work), or -1 if +IPD isn't found

int checkIfRequest()
{
  if (esp8266.available()) // check if 8266 is sending data
  {
    if (esp8266.find("+IPD,")) //+IPD code detected
    {
      delay(300); //Brief pause
      int connectionId = esp8266.read() - 48; //Get the ID (no idea why -48 but it works)
      return connectionId; //return the ID
    }
  }
  return -1; //Or return -1 if no request made
}

The act of building up and sending a web page is actually relatively complex. First we have to send an AT+CIPSEND command with the connect ID and the web page length. The OK message for this, weirdly, was keep-alix. I don't know who Alix... Actually I have a confession to make; it awas keep-alix on my first esp8266, on this one which I'm using to test for you lot it comes back as keep-alii. Now I can't pretend to know why this is - but the keep- bit seems stable so I adjusted the code to just use that. Learning on the fly! Then we have to send the webpage data itself. Then we have to send an AT-CIPCLOSE command, again including the connection ID. I thought it best to make a little helper function to do this.

void sendWebpage(int connectionId,String webpage)
{
      String cipSend = "AT+CIPSEND="; //Build up the initialisation string
      cipSend += connectionId;
      cipSend += ",";
      cipSend += webpage.length();
      cipSend += "\r\n";
      doCommand(cipSend,"keep-","FAIL",1000,true); //Send initialisation
      doCommand(webpage,"OK","FAIL",1000,true); //Send the webpage
      String closeCommand = "AT+CIPCLOSE="; //Build up the close string
      closeCommand += connectionId; // append connection id
      closeCommand += "\r\n";
      doCommand(closeCommand,"OK","FAIL",1000,true); //Send the close string
}

A few initialisation things at the top. You may notice I've changed to using esp8266 rather than ESPSerial. I don't really know why... but the same pins for the Rx/Tx, speed is set as a constant so we can change in future if we want, and I have included a DEBUG constant that can be used to turn on global debugging (which, if turned off, can be overruled with an 'or true' in the function calls).

#include <SoftwareSerial.h>
SoftwareSerial esp8266(2, 3); // RX | TX

#define speed8266 9600 
#define DEBUG false

bool ipFail;

Then, the setup! This basically runs through the AT commands we did before, and again while they worked perfectly typed in manually, I find these often go wrong. Hence all this palaver (and this is days of experimentation - you're welcome!)

The one thing that can go wrong is the IP address. If it comes back as 0.0.0.0 then it's a problem - and in the loop I make the LED flash. You need to restart the Arduino. I suppose I could set a loop to check it and run the process again but I'm still learning about this and may come up with a way to stop it happening in the first place. If I have to reset occassionally it will annoy me and I'm more likely to remember to fix it!

void setup() 
{ 
  pinMode(LED_BUILTIN, OUTPUT); //use the built in LED
  esp8266.begin (speed8266);  //set the speed
  Serial.begin(speed8266); //open the serial monitor
  Serial.println("ESP8266 Static Web Server"); //
  Serial.println("Waiting 1 s");
  delay(1000); //Get ready...
  Serial.println("Connecting to network and waiting 1 second.");
  doCommand("AT+CWJAP=\">>YOUR NETWORK SSID<<\",\">>YOUR PASSWORD<<\"\r\n","OK","FAIL",1000,DEBUG or true);
  Serial.println("Changing mode and waiting 1 second.");
  doCommand("AT+CWMODE=1\r\n","OK","FAIL",1000,DEBUG or true);
  Serial.println("Showing IP and waiting 1 second.");
  //The next line logs ipFail as to whether 0.0.0.0 was returned (a fail)
  //later on we'll have the LED flash if this is the case and you have 
  // to restart the Arduino
  ipFail = not doCommand("AT+CIFSR\r\n","CIFSR","0.0.0.0",1000,DEBUG or true); 
  Serial.println("Enabling multiple connections and waiting 1 second.");
  doCommand("AT+CIPMUX=1\r\n","OK","FAIL",1000,DEBUG or true);
  Serial.println("Starting comm port 80 and waiting 1 second.");
  doCommand("AT+CIPSERVER=1,80\r\n","OK","FAIL",1000,DEBUG or true);
  Serial.println("Entering loop.");
}

Now, finally, the main loop! First we check whether an IP address was received, and flash if there's a problem or just turn on if OK. We check if there's a request, and if so build and send the webpage.

void loop() 
{
  if (ipFail) //If the IP came back as 0.0.0.0 then we flash the LED
  {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(500);
    digitalWrite(LED_BUILTIN, LOW);
    delay(500);
  }
  else
  {
    digitalWrite(LED_BUILTIN, HIGH); //If not, just turn the LED on solid 
    //so we know things are good to go.
      while(esp8266.available())
      {
        Serial.write(esp8266.read()); //Get any data from the ESP and echo it
      }
      while(Serial.available())
      {
        esp8266.write(Serial.read()); //Get any data on monitor and send it back
      }
      int connectionId = checkIfRequest(); //Check if we've received a web request
      if (connectionId != -1)
      {
        //build the webpage
        String webpage = "<html><head><title>Testing!</title></head>";
        webpage += "<body><h1>Testing!</h1><p>Hello, world!</p></body></html>";
        sendWebpage(connectionId,webpage); //Send the webpage
      }
   }
}

Now of course, you could be a tad lazy and access the whole file here. However, I'm a big fan of typing code, I feel it helps you learn.

The first time I ran this, I got the following:

ESP8266 Static Web Server
Waiting 1 s
Connecting to network and waiting 1 second.
AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..---AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..---
---AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..---
---AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..---
---AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..---
---AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..---
---AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..---
+CWJAP:1

FAIL
---AT+CWJAP=">>YOUR NETWORK SSID<<",">>YOUR PASSWORD<<"

busy p..+CWJAP:1

FAIL
---
Failure detected.
Changing mode and waiting 1 second.
AT+CWMODE=1


OK
---AT+CWMODE=1


OK
---
Success detected.
Showing IP and waiting 1 second.
AT+CIFSR

+CIFSR:STAIP,"0.0.0.0"
+CIFSR:STAMAC,"5c:cf:7f:49:d---AT+CIFSR

+CIFSR:STAIP,"0.0.0.0"
+CIFSR:STAMAC,"5c:cf:7f:49:d---
Failure detected.
Enabling multiple connections and waiting 1 second.
AT+CIPMUX=1


OK
---AT+CIPMUX=1


OK
---
Success detected.
Starting comm port 80 and waiting 1 second.
AT+CIPSERVER=1,80


OK
---AT+CIPSERVER=1,80


OK
---
Success detected.
Entering loop.

Obviously my debug code could be made a bit more succinct, but it does the job. More importantly, I didn't change my SSID/Password...

The second time I remembered (and no, that's not my password!) and everything seems fine:

ESP8266 Static Web Server
Waiting 1 s
Connecting to network and waiting 1 second.
AT+CWJAP="GDog","MyPa$$w0rd"

---AT+CWJAP="GDog","MyPa$$w0rd"

---
---AT+CWJAP="GDog","MyPa$$w0rd"

---
---AT+CWJAP="GDog","MyPa$$w0rd"

---
---AT+CWJAP="GDog","MyPa$$w0rd"

---
---AT+CWJAP="GDog","MyPa$$w0rd"

---
WIFI CONNECTED
---AT+CWJAP="GDog","MyPa$$w0rd"

WIFI CONNECTED
---
---AT+CWJAP="GDog","MyPa$$w0rd"

WIFI CONNECTED
---
---AT+CWJAP="GDog","MyPa$$w0rd"

WIFI CONNECTED
---
---AT+CWJAP="GDog","MyPa$$w0rd"

WIFI CONNECTED
---
---AT+CWJAP="GDog","MyPa$$w0rd"

WIFI CONNECTED
---
WIFI GOT IP
---AT+CWJAP="GDog","MyPa$$w0rd"

WIFI CONNECTED
WIFI GOT IP
---

OK
---AT+CWJAP="GDog","MyPa$$w0rd"

WIFI CONNECTED
WIFI GOT IP

OK
---
Success detected.
Changing mode and waiting 1 second.
AT+CWMODE=1


OK
---AT+CWMODE=1


OK
---
Success detected.
Showing IP and waiting 1 second.
AT+CIFSR

+CIFSR:STAIP,"192.168.1.139"
+CIFSR:STAMAC,"5c:cf:7---AT+CIFSR

+CIFSR:STAIP,"192.168.1.139"
+CIFSR:STAMAC,"5c:cf:7---
Success detected.
Enabling multiple connections and waiting 1 second.
AT+CIPMUX=1


OK
---AT+CIPMUX=1


OK
---
Success detected.
Starting comm port 80 and waiting 1 second.
AT+CIPSERVER=1,80

no change

OK
---AT+CIPSERVER=1,80

no change

OK
---
Success detected.
Entering loop.

Shall we test it? Let's grab that IP address and put it into a browser window...

Well that looks good! The code below shows what came over the monitor.

,433:GET / HTTP/1.1
Host: 192.168.1.139
Connection: keep-alii---,433:GET / HTTP/1.1
Host: 192.168.1.139
Connection: keep-alii---
Success detected.

Recv 99 bytes

SEND OK
---
Recv 99 bytes

SEND OK
---
Success detected.
AT+CIPCLOSE=0

0,CLOSED

OK

+IPD,1,361:GET /favicon.ico H-Language: en-GB,en-US;q=0.9,en;q=0.8

---AT+CIPCLOSE=0

0,CLOSED

OK

+IPD,1,361:GET /favicon.ico H-Language: en-GB,en-US;q=0.9,en;q=0.8

---
Success detected.

Of course, we could (should?) do some filtering of the GET string, return 404 errors or whatever for the favicon.ico and such like. But this is just playing, I'm not trying to write an Arduino-based Apache server!

There we go then - no wiring up this time, but we've got WiFi and made a very basic web server! On to the next tutorial I suppose...

Note: I know the esp8266 can be used as a microcontroller in it's own right. This set of workshops was based around having an easy to use yet affordable microcontroller - the Arduino Nano - but then using the esp8266 as a cheap and (relatively) simple way to get the Nano online. You can get Arduino's with wifi built in - but where's the fun in that?

Part 2: Getting connected to WiFi

• Arduino Nano (other flavours exist; I used a cheap and cheerful nano from eBay)
• USB cable
• ESP8266 (again I went with the cheapest and cheerfullest)
• Breadboard
• 5x M-F jumper wires
• 2x M-M jumper wires
• 3.3v power supply
• 10kΩ resistor
• 1kΩ resistor
• 2.2kΩ resistor

For the 3.3v power I initially I used 2xAAA batteries together in series. They didn't last long so now use a power adaptor that came with an Arduino kit and a variable voltage plug that I got from Maplins years ago. You cannot run the ESP8266 from the Arduino 3.3v supply.  

Part 3: Basic web server

Note: This uses the same circuit as part 2 and so the parts are identical...

• Arduino Nano (other flavours exist; I used a cheap and cheerful nano from eBay)
• USB cable
• ESP8266 (again I went with the cheapest and cheerfullest)
• Breadboard
• 5x M-F jumper wires
• 2x M-M jumper wires
• 3.3v power supply
• 10kΩ resistor
• 1kΩ resistor
• 2.2kΩ resistor

Part 4a: A Button

This is for a single switch (we're just testing!).

• Arduino Nano (other flavours exist; I used a cheap and cheerful nano from eBay)
• USB cable
• Breadboard
• 4x M-M jumper wires
• 3.3v power supply
• Momentary / push button switch
• 10kΩ resistor

Part 4b: Reporting a button on a Web Server

This is for a single switch (we're just testing!). Each additional switch would need two more M-M jumper wires, one more 10kΩ resistor. And of course an additional switch!

• Arduino Nano (other flavours exist; I used a cheap and cheerful nano from eBay)
• USB cable
• ESP8266 (again I went with the cheapest and cheerfullest)
• Breadboard
• 5x M-F jumper wires
• 5x M-M jumper wires
• 3.3v power supply
• 2x 10kΩ resistor
• 1kΩ resistor
• 2.2kΩ resistor
• Momentary / push button switch

Project Total

If you want to just order everything to cover the whole project then you want to use this complete list.

• Arduino Nano (other flavours exist; I used a cheap and cheerful nano from eBay)
• USB cable
• ESP8266 (again I went with the cheapest and cheerfullest)
• Breadboard
• 5x M-F jumper wires
• 5x M-M jumper wires
• 3.3v power supply
• 2x 10kΩ resistor
• 1kΩ resistor
• 2.2kΩ resistor
• Momentary / push button switch

So we have this little esp8266 thing; it's supposed to connect to WiFi. But how do we do that? Well one way is to use a programmer device to connect to it and tell it what to do. This is a nice solution (and one which I will explore at a later date). But in the interest of getting started cheaply, we don't have a programmer. We do have an Arduino. And as that's what we're going to be using it with anyway, we may as well use that to control it right through.

To step through this, I've taken a brand-new out of the packet esp8266. Everything I experience, you will experience.

So firstly, what we should be doing here in terms of wiring. We need to know the pinout of the esp8266. I made this lovely diagram which I've got stuck on a whiteboard near my desk while I'm working. A bit of Googling found it, then I drew it special for you!

1. Rx
2. GPIO 0
3. GPIO 2
4. Gnd
5. Tx
6. CH-PD
7. RST
8. Vcc

We need M-F jumpers to wire most of this up. On my breadboard I've got a 3.3v power supply at one end with + and - stuck in the corresponding rails, and the Arduino at the other end. More on the 3.3v later! The hardest thing is rotating your diagram and the actual esp8266 the right way -  I kept spinning mine or having it with the pins facing up!

1. Pin 4 to - rail on the breadboard
2. Pin 8 to the + rail on the breadboard
3. Pin 6 to a line on the breadboard, then a 10kΩ resistor from that line to the + rail
4. Pin 5 to digital pin 2 (D2) on Arduino
5. Pin 1 is the tricky one. First we use an M-F jumper to put it to a space on the breadboard. Then we have a 2.2kΩ resistor between that line and the - rail. This I believe drags it down to 0v to stop it floating when there is no signal. Then we need a 2.2kΩ resistor from the same line to a new line, and finally a M-M jumper to the pin 3 (D3) on Arudino.
6. A M-M jumper from Arduino ground to the - rail

I know number 5 sounds squiffy - it's really not that difficult. Hopefully the circuit I show below should help. The resistor to the - rail stops the voltage floating when not in use (which can cause problems) and is, I believe, called a pull-down resistor. The other resistor is, I assume, a voltage divider and is, again I assume, because the Arduino can output 5v and more than 3.3v can make the esp8266 stop working. It may - and probably will - work if you just go straight through. But then it may not.

At this point I must add I didn't have the right resistors, so used a 2kΩ in place of 2.2kΩ and two 470Ω in series in place of the 1kΩ. They're close enough and seem to be ok!

It's also worth noting that if you have a different Arduino you can probably connect through to one of the other Serial lines. The Nano only has one which will be in use by the Arduino/PC connection. So figured may as well use SoftwareSerial to do it for us. I believe it's slower, but it's what the rest of the tutorials will be doing, and it's fast enough. I wanted something that should work for everyone.

Hopefully this tinkercad diagram will help make that all clear.

Now for the code; I've been using the Arduino web editor though the same should work on an installed version.

#include <SoftwareSerial.h> //Enables us to use digital ports as serial connection
SoftwareSerial ESPserial(2, 3); // RX | TX

void setup()
{
  Serial.begin(9600);  // communication with the host computer
  ESPserial.begin(115200); //set the esp8266 communication speed
  Serial.println("Ready"); //Are you?
  Serial.println("");
}

void loop()
{
  if ( ESPserial.available() ) //if there is data on serial line
  {
    Serial.write( ESPserial.read() ); //read it and put on monitor
  }

  if ( Serial.available() ) //if there's data on the monitor
  {
    ESPserial.write( Serial.read() ); //read it and put it on the serial line
  }
}

Now how to get that on to the Arduino? This is always a bit of fun. I prefer to use the web-based developer at  on the Arduino website though you might want to download and use the offline one. Either copy and paste, or type in (my preference - you learn more) that code. I've linked to the sketch here.

• Power on your 3.3v to fire up the esp8266
• Plug your Arduino into the computer
• At the top, you need to choose the board. I chose the **Arduino Nano** (I knew that bit) then fiddled with the options until I got the right one (mine is using the old bootloader and COM7).
• (If you've not used your Arduino before you may want to try this code which just blinks the in-built LED slowly. I use this rather than the standard 'blink' code as that sometimes comes built in and you don't know if yours has worked or not!)
• On the left hand side of the screen, under >EDITOR there is a Monitor button - click that so you can see what the Arduino is doing. In the left hand dropdown choose Both NL & CR (this uses \r\n as a line terminator which is what the ESP8266 uses) and select 9600 baud in the other one - this is the speed we have told the Arduino to communicate with the computer at.
• Now press the right arrow to upload (hopefully) to your Nano.
• Hopefully the avrdude will say 'done. Thank you.' and in the monitor window it will say 'Ready'

Mistakes I made (in the interest of honesty) I originally used an alternative connection having the reset pin high and the CH_PD to D4 but that didn't work (probably because my program didn't match!). I also forgot to ground the Arduino...

Now let's have a play with this ESP8266 and see whether we can get it to work?

If you type in:
AT and hit Enter
The ESP8266, via the Arduino, should return OK
It may or may not also return a bunch of gibberish. My first one did because it couldn't cope with the communication speed (or maybe the Arduino couldn't I don't know), my second one oddly didn't. Either way we will tell the ESP8266 to reduce down to 9600 baud which we know will work.
AT+UART_DEF=9600,8,1,0,0 and hit Enter

Now we need to adjust the code - change line 7 to read 9600 - I've linked to the updated code here.

Reflash and enter AT again to make sure everything is still Ok.
Let's make sure we can connect to the WiFi shall we?
Enter these commands:

AT+CWMODE=1
This sets the mode to 1 meaning it will act as a station (client). You should get OK back.

AT+CWLAP Gets a list of networks the ESP8266 can see. For example I can see:

+CWLAP:(3,"SHELL 1567AF",-84,"a4:91:b1:15:67:af",6,53)
+CWLAP:(4,"GDog",-41,"48:8d:36:1d:8a:cf",11,56)
+CWLAP:(3,"PLUSNET-T6TJ",-78,"b8:ee:0e:f0:7a:04",11,28)

In the barackets the first number is the type of security, SHELL and PLUSNET use WPA2 and PSK, GDog uses WPA, WPA2 and PSK. Then there's the names, and finally the MAC address of the access point.

AT+CWJAP="YOUR_SSID","YOUR_PASSWORD" connects to the WiFi network with the given SSID (network name) and password.

When I ran this I got:

WIFI DISCONNECT
WIFI CONNECTED
WIFI GOT IP

OK

Which is fairly clear, it disconnects if relevant, reconnects, gets an IP address and then say's all is OK.

Finally:
AT+CIFSR Get's and reports the IP address and MAC address of the ESP8266. I got:

+CIFSR:STAIP,"192.168.1.139"
+CIFSR:STAMAC,"5c:cf:7f:49:d4:ca"

And to prove this worked, I can open up a terminal/command line on my PC and ping that address:

A useful list of known AT commands for the ESP8266 is available here.

And that's pretty much us; we've successfully connected the ESP8266 to WiFi, via our Arduino (the cheapest one available not an expensive Mega or Uno or anything) and can move on to the next tutorial. Whoo.

As I mentioned in my previous blog post, I was once stuck with a decent number of teachers needing CPD. In a pub. In Bletchley. Additional challenges included some teachers being KS3 only, some being A-level, some being new, some being experienced; the traditional stand up and talk CPD was never going to work. In fact, why do we ever think that's best? Teachers are constantly being told not to lecture, then sit there and expect to be lectured at CPD!

So a new concept was needed - and CPD in a Box was invented. While I have the intention of producing these, the concept is simple:

1. Take a box. This will be the box which your CPD will be in. Choose your box carefully. You should choose for space, compactness, robustness... or whatever you have lying around. I chose your common or garden box file.
2. Choose a CPD topic. Try and keep it to a single topic. I created the PCH BBC LTE, one on graphics, and two-three others.
3. Create a booklet to deliver the CPD theory. I made mine in PowerPoint and printed out at about postcard size, laminated, bound (with a treasury tag). These included specification links, QR codes to further information and/or videos, simple step-by-step theory, and anything else relevant.
4. Include props. I actually think this is the most important bit - props make CPD fun. Be it the mini brown box computers, cards to draw on for bitmap theory, things to sort and search... this is what makes the boxes actually useful.

My teachers split themselves into 4-5 groups, each with a box, and worked through them as a group. Each group had roughly 20 minutes before cleaning, re-packing and swapping around.

The novelty was good, the CPD was effective, and fun was had. What more could one want?

Prebuilt versions will be on sale soon: ask to be kept in the loop.

songs = open("Songs list.txt","r")
songs_list = songs.read().splitlines()
songs.close()

So where do we start? Firstly, that file name. I won't comment on the choice (I don't like spaces or capitalisation,  but that's just me!) More importantly, this should be defined as a constant. A constant is a named memory location which can't (or in the case of Python shouldn't) be changed at runtime. We indicate this in Python by using all capitals for the identifier:

SONGSFILE = "Songs list.txt"
songs = open(SONGSFILE,"r")
songs_list = songs.read().splitlines()
songs.close()

Now what? Well, what if that file doesn't exist? When a file can't be found, Python will raise an error called an exception. What we should do as a minimum is try to catch that and die gracefully. In this case we raise our own exception (SystemExit) which is an elegant way to close the program.

SONGSFILE = "Songs list.txt"
try:
    songs = open(SONGSFILE,"r")
except:
    print("Sorry, I couldn't find the file!")
	raise SystemExit
songs_list = songs.read().splitlines()
songs.close()

But wait - maybe we moved the file? Or changed the name? We can be a little bit clever and give the user the chance to fix the error! Note I'm now using songsfile as a variable (and initialising it with a value) so have changed case.

songsfile = "Songs list.txt"
while True:
    try:
        songs = open(songsfile,"r")
        break
    except:
        print("Sorry, I couldn't find the file!")
        songsfile = input('Enter a correct file name, or hit enter to quit')
        if (songsfile == ''):
            raise SystemExit
songs_list = songs.read().splitlines()
songs.close()

Now we are going to continue trying until we decide to stop. If we get past the open command, then we must have successfully opened the file so we can break out of the loop. If not, then instead of exiting straight away, we ask the user to enter the file name. If they choose to hit enter (i.e. enter an empty string), we exit as before. However, if they do enter something then we go around the loop and try again.

There is of course potential to look at the data and start deciding whether this data file was valid/correct, but that's a different issue. And it was lovely seeing my friend remembered the close command. Normally you won't notice this is missing, until you go to move/delete/edit the data file and find it's locked!

Update

A colleague quite rightly contacted me recently pointing out a lack of pythonic 'correctness' on this page; I have included this below, but thought I'd take the opportunity to explain my reasons.

1. I learnt to program a long time ago and fell into Python for dubious reasons; therefore I don't always know about Pythonic methods.
2. I've taught programming in many languages - (most/many?) other languages don't support this syntax.
3. It feels icky to me - trusting the computer to close a file feels risky to me.

That being said, it's always good to explore different methodologies and I'm more than happy to use and abuse Python as it suits me. So here's Alistair's method.

SONGSFILE = "Songs list.txt"
try:
    with open(SONGSFILE,"r") as songs:
  songs_list = songs.read().splitlines()
except:
    print("Sorry, I couldn't find the file!")
raise SystemExit

In preparation for an upcoming book I have spent a little bit of time collating some data. My personal feelings are that we put young people through too many formal assessments at age 16. I've gone through the three biggest exam boards in the UK (AQA, OCR and Edexcel) and looked at what an averagely bright student might have to sit. This is making some assumptions:

1. They sit all exams with a single exam board (with the exception of OCR who no longer offer MFL GCSEs).
2. They take a minimal amount of subjects. Some (many?) schools have their students sit more than the minimum - particularly as English Literature often leads to poorer grades than language, so will be included to double-up the English grade in Progress 8, but a different subject included for the actual grade needed.

Some times were rounded slightly.

What does this mean in real world terms? Secondary age children spend 190 days in school each year. With an average of 5 hours a day of lessons, this is 950 hours a year, or 1,900 across two years. Very roughly ten weeks of this is lost in Year 11 so that's 250 hours gone, leaving children with 1,650 hours of key stage 4 education.

What about Physical education? Religious education (still mandatory within the UK)? If we were to give these one hour a week each (and it could be argued that one hour a week of PE isn't enough to get them changed never mind actually exercising), then that's an extra 152 hours we need - taking us down to 1498 hours. Any teacher will tell you that they lose probably 5-8 minutes of each lesson due to change over, getting equipment out, etc etc. So if we assume hour lessons we're taking 13% off of each one, 1,298 hours left.

Many schools will assess at the end of each term, and at least approximating the real assessments, so that's five sets of mocks/assessments at 31 hours each (again, if we're using worst cases here), 155 hours. 1,143 hours left.

If we look at the worst case scenario of Edexcel having 31 hours of examinations, this leaves us with 143 hours per subject, or less than 37 hours of teaching for each hour of assessment.

What's the old maxim? It takes 1,000 hours to master something?