BASIC is 50

So today (30th April, 2014)  marks the 50th anniversary of the BASIC programming language! Hurrah!

The very first BASIC program:

10 LET X = (7 + 8) / 3
30 END

To help celebrate this, I’ve made a new release of my RTB – Return To BASIC interpreter for the Raspberry Pi. RTB started life about 2.5 years ago – even before the Raspberry Pi hardware was on-sale. I wasn’t initially thinking about the Pi, just Linux in-general, but since the release of the Pi, it has gained a small and growing userbase. Get your copy of RTB for the Raspberry Pi here.

Which I think is fantastic for a 50 year old language!

For the past year (ish) I’ve actually been devoting my BASIC time to a forked version called FUZE. This is to run on the FUZE hardware platform, but I’ve just taken the steps to get RTB caught up with the FUZE version and am releasing it today in an easy to use way to install and run on your Raspberry Pi.

So say happy birthday to a 50 year old language and go and write that BASIC program you’ve always wanted to write… You know the one:

20 GOTO 10

Of-course, in modern RTB, that would really be:

  print "BASIC is Awesome!"

Pibrella from Pimoroni

Some time back the boffins at Pimoroni sent me a prototype of the new Pibrella board with a view to making the little piezo speaker on it make some noise… It wasn’t that loud, so I made a few suggestions then… Last Wednesday, almost as I was leaving for the Manchester Pi Jamboree the production version dropped through my door, and here it is!

pibrellaIt’s a tiny little board that fits on-top of the Raspberry Pi aimed at helping to teach programming using some big LEDs and a button to help make it more exciting.


  • 3 Large LEDs; Red, Yellow and Green
  • A Big Red button! (Everyone needs a Big Red Button!)
  • 4 Inputs – which have a degree of protection on them via a resistor and zener diode with LEDs to indicate the input state.
  • 4 outputs – which are Open Collector outputs from a ULN2003 open collector driver chip, also with LEDs to indicate their state.
  • A piezo buzzer which can generate tones, notes and other little squawks.
  • Its own website here:

It’s also purple which is their trademark board colour (as used in the PiGlow too, and who knows what in the future)

It’s aimed at helping to teach programming and simple GPIO use.

From the Pi’s GPIO point of view, it’s just simple outputs and inputs, so I didn’t think it warranted a special wiringPi devLib driver (unlike e.g. the PiGlow), but I have put together a nice header file for use in your C programs with all the input and output definitions and written a few test program for it in C and BASH, so if C is your thing, then read on. (If not, then read on anyway, you might get some ideas!)

You can fetch and compile my code and files as follows:

git clone git://
cd pibrella

All these examples will require the wiringPi libraries installed. Get them here.

The key part of all this is the file: pibrella.h. This contains all the pin definitions and some functions to help you use the Pibrella board from your C programs using wiringPi.

Please do look at the sources for the various programs here to find out how to use it effectively.

The examples I’ve provided are:

  • tune – Plays a well knows tune!
  • ladder – my old ladder game altered for the Pibrella board
  • – my old Tuxx (Pelican) road crossing simulator
  • stepper – how to drive a micro stepper motor directly from the Pibrella.
  • step1 – Drive a stepper motor one step at a time using the Big Red Button.
  • wire – classic wire loop agility game – move the wire loop along the bendy wire without touching it. Three touches and you’re out!

Tuxx/UK Road Crossing

Start with – it’s a simulation of a UK “pelican” road crossing, written in BASH using the wiringPi GPIO command. Run it as follows:


It will initialise and start with the Green LED on and the “red man” (top LED in the block of 4 white LEDs on the right) on. That means traffic can go, pedestrians should not walk.

Push the button and the sequence will start – Green,  Yellow, Red to signal the traffic to stop, then the red man will change to the green man (bottom LED in the block of 4 white LEDs on the right) and the beeper will beep. After the allotted time, the sequence will change to flashing green man and Yellow, then red man and Green to allow traffic to pass again.


The tune program is just a demo of using and making tones with your own software. Run it with the usual:

sudo ./tune

and name that tune…

I will warn you now; the sound quality isn’t great. It’s a very small piezo device with some resonant frequencies that don’t quite match playing musical notes…


This is my old ladder game. You start off at the bottom and have to climb to the top. The bottom LED will flash and to climb, you push the button. However you can only push the button down while the LED is on. If you push it while it’s off, then you fall to the bottom again. When you get to the top (the Red LED) then you win! Note that the closer to the top you get the harder it becomes… You may need to push the button 2 or 3 times to jump just one LED, but don’t keep it pushed, or back to the bottom you’ll go!

Run it with:

sudo ./.ladder

and enjoy the fun.

Stepper Motors

The uln2003 open collector driver chip on the Pibrella is capable of driving one of the little micro stepper motors (e.g. 28BYJ). You’ll have to make up some more wires as these usually come with a socket designed for a PCB plug:

pibrellaStepperThe photo shows how its wired up. The stepper motor has wires coloured Red, Orange, Yellow Pink and Blue. These go via male to male jumpers into the Pibrella in the same order for the Orange, Yellow, Pink and Blue – from top to bottom on the outermost set of 4 pins on the right-hand connector. The Red wire from the stepper goes to one of the 4 innermost pins on the right-hand connector (This is the +5v supply). Note that I didn’t have a pink jumper lead, so I used a white one here.

I’ve written 2 little programs, one; stepper simply makes it do a full turn one way, then a full turn the other, and the 2nd; step1 uses the button to advance the motor one step at a time. You can see which outputs are active on the 4 little white LEDs as the motor turns. (It’s 4096 pulses per full turn, so be patient if you want to make it go a full turn!


This is the classic steady-hand wire-loop game. Your task is to firstly make it, and secondly to guide the wire loop over the curvy wire to the other end without touching the wire!

I made up a very small version just for demonstration:

wireThe bendy wire (with red insulation at the ends) is plugged into the top and bottom of the outside column left-hand connector. (All these pins are at 3.3v). The wire loop you hold is plugged into the innermost connector on the same block marked “A”

We run the program:

sudo ./wire

and off we go. The program initially waits for the wire to be clear, then the game starts. You are allowed three touches of the wire which will be accompanied with a beep and one of the LEDs lighting (starting with Green and ending with the Red one), and on the fourth touch it’s game over. The Big Red Button can be used to reset the game at any time.


The Pibrella board is a fun little board that can be used on its own, or in conjunction with many other little projects – you just need to get thinking and get programming! Python and Scratch libraries are available and now this lets you program in it BASH, C or anything else that supports wiringPi – e.g. BASIC.

Raspberry Pi Jamboree 2014

So the 2nd (annual?) Jamboree was held in Manchester thanks to Alan O’Donohoe and whole host of others who helped him arrange it and it went fantastically well!

This year it was spread over 2 days with some talks, etc going on on Thursday with the main event in a dedicated room on Friday where there were some more specialised talks going on.

Of-course the real main event was the party in the evening, celebrating not just the Jamboree but of-course the Raspberry Pi’s 2nd birthday!

PANO_20140228_172403That’s a (slightly wobbly) panoramic view of the party room.

I was on the FUZE stand for some of the time, didn’t take that many photos in the end, here’s a couple:

fuzeStandThis is a FUZE running a BASIC program that lets you move the control icons around the screen then push them to move to robot arm…

displayThe new DSI display interface adapter board from the Raspberry Pi Foundation!

alanInternational man of mystery; Alan O’Donohoe…

At the party there was lots of “swag” to be had – little bits and pieces from lots of people and a couple got together to produce this nice little GPIO shim:

jamboreeThis was designed by Andrew @gbaman1 and @minigirlgeek and has a power LED and 2 programmable LEDs on pins 11 and 12 – BCM_GPIO 17 and 18, or wiringPi numbers 0 and 1. Here are a few wiringPi examples to use them: (using the gpio command-line tool)


# Make the pins outputs
gpio move 0 out ; gpio mode 1 out
# Light them up!
gpio write 0 1 ; gpio write 1 1
# Make them flash:
while true; do gpio wb 1 ; sleep 0.5 ; gpio wb 2 ; sleep 0.5 ; done

That last line uses the ‘wb’ command – wite byte which outputs an 8-bit number to the pins – alternating bits 0 and 1 here.

And finally… If you’re missing me talking about bread, here’s some I made earlier. Devon cider bread!



Bread making with the Artisan Bakery School

So I’ve been making bread for a good number of years now, mostly self-taught, and even sourdough for a few years now, and as I’m sure you’re aware there has been a veritable plethora of baking programs on TV recently – from Paul “silver fox” Hollywood, the Great British Bake-Off to the Fabulous Baker Brothers and who knows what else might be shown on daytime TV, etc… All showing you how to make real bread, but never really going into any great detail…

So, while my bread making was fine, I’ve always felt it could be improved and as one of my many mottos is “learn something new”, I embarked on an artisan bread making course with Dragan and Penny at the Artisan Bakery School in Sparkwell, Devon.

And what a fantastic day it was – actually, I should say two days as I’ve visited them twice now. The first time as an introduction to their sourdough bread making and the second to look closer at the business  side of things – (The micro business blueprint) going through some of the issues they faced and their solutions, pitfalls and traps and so on. Both times we baked some fantastic bread and my own skills have improved dramatically. Dragan and Penny inspired confidence and showed me new techniques for kneading and shaping, and even right after my first visit with them my bread improved – literally overnight!

Dragan’s technique for kneading was excellent and much faster than my own – but after several years of doing it my way, its been somewhat challenging to adapt to his way – it’s not that different at the end of the day, but it’s more efficient, or seems so – if you had to hand knead dough for over 100 loaves one Christmas eve, as they did a few years back, I guess you get efficient quite quickly!

And on to shaping – who would have thought just how important that was – it’s demonstrated quickly with a flourish on TV and in some books, almost glossed over, but seeing it first hand and then seeing the difference in the resulting loaf was very good – even in terms of cooked loaf volume – on the course, we were using slightly less dough per loaf than I was in my kitchen, yet the loaves were rising higher with a better texture than my own… All down to the shaping, slashing and proving technique!

Other techniques – how to test the dough for readiness, how to slash the perfect shape on-top, baking baguettes, rolls (soup buns as Dragan calls them!) and different shape loaves. Different flours – we made rye bread – both a standard sourdough rye with added seeds, nuts, etc. to a classic Borodinski (which tastes utterly fantastic!)

gbreadThat’s me with the bread we made on the last course – I didn’t make it all though – there were two others on the course that day, but it’s still a lot of bread!

So my own bread now which is being sold in The Seed in Buckfastleigh will certainly benefit from this, and I not have a bit of a clearer head on the business side when I decide to expand the Moorbakes business side of it all.

Techcamp 2013 (Raspberry Pi)

So the past two weeks has seen me attending Techcamp 2013 held at at Sparsholt college just outside Winchester. I was the lead tutor for their Raspberry Pi course. And now, a few days later I’ve finally had enough sleep to type this up 😉

Techcamp is run by Tom Ward, an Electrical Engineer who previously worked as Head of Science at Elstree School, Berkshire. Tom believes that young people should have ever opportunity to enjoy a summer camp from a technical perspective as opposed to those other summer camps where you play sports, etc… (Although Laser Tag is an active outdoor sport played here!)

A few months ago Tom was looking for some Raspberry Pi people and I replied to his posting and before I knew it, was in the system… Young people (8 to 17 year old!) attending the camp had to pick 2 courses to do over the week. The camp ran for two weeks and a very small number of young people stayed for both weeks, (attending 4 courses), but the majority were one week only.

Helping me with the Raspberry Pi class was Andrew Mulholland who flew over from N. Ireland for the fortnight.

The young people are split into day and residential “campers” and the residential ones arrive on the Sunday afternoon… So evening activities are arranged, to encourage people to get to know each other.

Sunday evening on the first week: We gave the young people some cardboard, tape and scissors and had them build a bridge that had to take firstly the weight of the lightest camper, and secondly Tom…

Most groups went for the “brick” approach where they just taped as much cardboard together as they could, but one group went for a proper engineering approach with a simple arched brdge which worked very well indeed!

The second week’s first night challenge was to build a tower with spagetti and marshmallows – sadly rain stopped play, but we did get a few structures built:

The rain produced a spectacular double-rainbow though:

rainbowsAnd on to the classes… I had 14 young people in my morning class and 13 in the afternoon on the first week and 2 groups of 12 people the second week. The camp fees included a “lab fee” to cover materials used and the students got to take home their Raspberry Pi, case, keyboard, mouse and SD card.

One of the challenges was to make the classrooms computer friendly – and the one we had been allocated had a grand total of one Ethernet point, but plenty of Wi-Fi. We had no Wi-Fi adapters for the Pi’s so some creativity was required involving re-arranging the desks, 3 Ethernet switches (actually, one was a 20 year old 10mB hub!) a lot of gaffer tape and an area I dubbed “the valley of death”.

I also wanted to create lots of space so that myself and Andrew could easilly move round the students to give them help and assistance and so on. I think it worked out well given the situation, and the whiteboard and smart-boards at the front were visible.

The smartboard was driven directly by a Raspberry Pi, but without drivers, there was no on-screen keyboard, but the touch/mouse input worked very well for Scratch but less-so when we had to type stuff in.

This was the first year Techcamp ran the Pi course – not a surprise given how relatively new the Pi still is, so it was hard to gauge what to do – the course was billed as an introduction to the Raspberry Pi and some game playing and programming – e.g. Minecraft… So we started by giving a general introduction to the Pi, some command-line activities – the first “Hello world” using BASH, then moved onto some simple programming with Scratch – Hello kitty, and turtle graphics. We moved onto BASIC with more turtle graphics then got the students to start to modify some of the programs I’d written to give them experience with looking at other code – my little snake game went down well with the students hacking it to change colours and alter the colission mechanisms (ie. to cheat snake death!)

After that we moved on to Python and took a more traditional approach (next year I’ll do more turtle graphics in Python) and then we looked at GPIO. We started with a simple LED+Resistor circuit on a breadboard when we wrote a program in BASIC, then Python to blink out S.O.S in morse code, then we used my ladder board whith more LEDs and buttons.

Finally it was minecraft time (for those who wanted to play it – some wanted to keep on with the ladder board and more code to use it) – with the caveat that they could only play the Pi version of Minecraft if they wrote some Python to interface to the Minecraft server. We had some intersting bits of code there – random dirt blocks in the sky – “competitive” teleporting of characters, auto-laying of TNT as you move and so on.

The camp was run over 2 weeks, but over the weekend between the two main weeks, we had a dozen students who werestaying both weeks to look after… So we hired a minibus and took them to various local attractions. InTech science center was a big hit and the Portsmouth Royal Navy Museum was another.

  • Note to anyone else doing this – sadly, Portsmouth is hostile to minibuses with one-way streets leading into car parks too small for a minibus. I found one area of street parking suitable for coaches, but it was a good 10 minutes walk from the Entrance of the museum – not good when you have a dozen excited young people in tow!

But apart from that, a good day was had by all:

onboardalthough I’m not sure Nelson would approve young people cavorting round on the Victory though…

Techcamp was about young people and technology – and it would be unfair of me to leave out the other courses that were run over the fortnight – Model rocketry, Robotics, building a pair of  Laser Tag guns (Parents – expect your child to get burnt by a soldering iron!) games and web design, not to mention the lighter evening activities forthe residential campers (“Reverse engineering” was particularly well enjoyed!) and the staff entertainement night for the young people – Felix and his amazing non-newtonian liquid kitchen chemistry, Jack and his gravity defying physics and myself with my make a Raspberry Pi(e) from scratch demo…

It was a pretty amazing 2 weeks for me. Very enjoyable and I’m already planning for next year!

PiFace abuse: Using Inputs as Outputs

Did you know that the 8 inputs on the PiFace can be used as outputs too? Well they can, and this is something that I understand the boffins in Manchester who designed it had in-mind too… So in-between barbecues this (UK) bank holiday weekend, I’ve had some fun and adapted something I did on the Gertboard to the PiFace – Driving a 6-digit 7-segment display.

Here it is:

piface-ioYou can just make out the numbers 123456 on the LED digits at the top…

So how does it work: The Piface really is nothing more than an interface board with a standard SPI based GPIO expansion chip – the MCP23S17 which as 16 IO pins. 8 of these are connected to a ULN2803 open-collector buffer (darlington) chip – 8 of those 8 outputs go to on-board relays, the other 8 are uncommitted. On the input side – the 8 inputs pins go via 330Ω resistors to the terminals (and 4 buttons).

Pins 0-7 go to the ULN2803 and to the relays and output terminals and pins 8-15 go to the 330Ω resistors, the buttons and input terminals.

If we access the MCP23S17 directly, rather than use the wiringPi PiFace devLib for it, then we can re-provision the input pins as outputs and use them to drive things like LEDs.

(Well, not quite good enough for my display above – it’s over 25 years old, so old LEDs which have faded, and those old LEDs did need more current to drive them than the 330Ω resistors are allowing, but it’s the principle of the thing here!)

So how do we drive LED digits – easy here. We have 8 inputs which we’re using as outputs, so we can connect 7 to the 7 segments on the display and the common pin on each digit can go to one of the open collector drivers. To light up a single digit, we program the 7 segments as required, and enable the common line for that digit. Current flows out of the input pin, through the LED segments, and via the common pin for that segment into the open-collector driver on the PiFace and to ground.

To light up many digits, we repeat the above for each digit. ie

For each digit:

Set 7-segment pattern

Enable digit common-line

delay a short time

Disable digit common-line

This way, we can cycle through each of the 6 digits in-turn and if we do it fast enough then we don’t notice it happening (Look-up Persistence of vision)

We can illuminate all 7 segments at once, if required (e.g. to display an 8) as each one has it’s own limiting resistor and the “sink” pin goes via a darlington driver that can handle the combined current.

One thing to note here: This will only work with common-cathode type displays.

So there you have it – not quite “abuse” as it’s really by design, but something else to think about when using your PiFace board – if you need a 3.3v output and you have spate inputs, then re-provision one as an output and off you go.

Here’s the code for anyone interested:

 * 7segments.c:
 *      PiFace "abuse". Use the inputs as outputs to drive a 7-segment
 *      LED display (common cathode) - connect the segments to the
 *      input pins, re-provisioned as outputs and use the darlington
 *      outputs as current sinks for each digit.
 *      Copyright (c) 2013 Gordon Henderson

#undef  PHOTO_HACK

#include <wiringPi.h>
#include <mcp23s17.h>

#include <stdio.h>
#include <time.h>
#include <ctype.h>
#include <string.h>

 *  Segment mapping
 *       --a--
 *      |     |
 *      f     b
 *      |     |
 *       --g--
 *      |     |
 *      e     c
 *      |     |
 *       --d--  p

#define PF      200

// GPIO Pin Mapping

static int digits   [6] = {  PF+ 7, PF+ 6, PF+ 5, PF+ 4, PF+ 3, PF+ 2 } ;
static int segments [7] = {  PF+15, PF+14, PF+13, PF+12, PF+11, PF+10, PF+ 9 } ;

static const int segmentDigits [] =
// a  b  c  d  e  f  g     Segments

   1, 1, 1, 1, 1, 1, 0, // 0
   0, 1, 1, 0, 0, 0, 0, // 1
   1, 1, 0, 1, 1, 0, 1, // 2
   1, 1, 1, 1, 0, 0, 1, // 3
   0, 1, 1, 0, 0, 1, 1, // 4
   1, 0, 1, 1, 0, 1, 1, // 5
   1, 0, 1, 1, 1, 1, 1, // 6
   1, 1, 1, 0, 0, 0, 0, // 7
   1, 1, 1, 1, 1, 1, 1, // 8
   1, 1, 1, 1, 0, 1, 1, // 9
   1, 1, 1, 0, 1, 1, 1, // A
   0, 0, 1, 1, 1, 1, 1, // b
   1, 0, 0, 1, 1, 1, 0, // C
   0, 1, 1, 1, 1, 0, 1, // d
   1, 0, 0, 1, 1, 1, 1, // E
   1, 0, 0, 0, 1, 1, 1, // F
   0, 0, 0, 0, 0, 0, 0, // blank
} ;

// display:
//      A global variable which is written to by the main program and
//      read from by the thread that updates the display. Only the first
//      6 characters are used.

char display [8] ;

 * displayDigits:
 *      This is our thread that's run concurrently with the main program.
 *      Essentially sit in a loop, parsing and displaying the data held in
 *      the "display" global.

PI_THREAD (displayDigits)
  int digit, segment ;
  int index, d, segVal ;

  piHiPri (50) ;

  for (;;)
    for (digit = 0 ; digit < 6 ; ++digit)
      for (segment = 0 ; segment < 7 ; ++segment)
        d = toupper (display [digit]) ;
        /**/ if ((d >= '0') && (d <= '9'))      // Digit
          index = d - '0' ;
        else if ((d >= 'A') && (d <= 'F'))      // Hex
          index = d - 'A' + 10 ;
          index = 16 ;                          // Blank

        segVal = segmentDigits [index * 7 + segment] ;

        digitalWrite (segments [segment], segVal) ;
      digitalWrite (digits [digit], 1) ;
      delay (20) ;
      digitalWrite (digits [digit], 0) ;

 * setup:
 *      Initialise the hardware and start the thread

void setup (void)
  int i, c ;

// 7 segments

  for (i = 0 ; i < 7 ; ++i)
    { digitalWrite (segments [i], 0) ; pinMode (segments [i], OUTPUT) ; }

// 6 digits

  for (i = 0 ; i < 6 ; ++i)
    { digitalWrite (digits [i], 0) ;   pinMode (digits [i],   OUTPUT) ; }

  strcpy (display, "      ") ;
  piThreadCreate (displayDigits) ;
  delay (10) ; // Just to make sure it's started

// Quick countdown LED test sort of thing

  c = 999999 ;
  for (i = 0 ; i < 10 ; ++i)
    sprintf (display, "%06d", c) ;
    delay (400) ;
    c -= 111111 ;

  strcpy (display, "      ") ;
  delay (400) ;

  sprintf (display, "%s", "123456") ;
  for (;;)
    delay (1000) ;


 * funTime:
 *      Jeremy Hillary Boob Ph.D. is a fictional character in the animated movie
 *      Yellow Submarine.

void funTime (void)
  char *message = "      feedbeef      babe      cafe      b00b      " ;
  int i ;

  for (i = 0 ; i < strlen (message) - 4 ; ++i)
    strncpy (display, &message [i], 6) ;
    delay (200) ;
  delay (1000) ;
  for (i = 0 ; i < 3 ; ++i)
    strcpy (display, "    ") ;
    delay (150) ;
    strcpy (display, " b00b ") ;
    delay (250) ;
  delay (1000) ;
  strcpy (display, "      ") ;
  delay (1000) ;

 * main:
 *      Let the fun begin

int main (void)
  struct tm *t ;
  time_t     tim ;

  wiringPiSetup () ;
  mcp23s17Setup (200, 0, 0) ;

  setup   () ;
  funTime () ;

  tim = time (NULL) ;
  for (;;)
    while (time (NULL) == tim)
      delay (5) ;

    tim = time (NULL) ;
    t   = localtime (&tim) ;

    sprintf (display, "%02d%02d%02d", t->tm_hour, t->tm_min, t->tm_sec) ;

    delay (500) ;

  return 0 ;

Adafruit RGB LCD Plate with WiringPi

Part of my testing of wiringPi v2. was to make sure that some of the existing libraries code would work with GPIO expanders – and the Adafruit RGB LED Plate was an ideal candidate.

So I ordered one, took a few moments to solder it together and plugged it in – and 5 minutes later I had my LCD test program working without any real issues.


So if you want to drive one of these from C/C++ or anything else that uses wiringPi, then be assured that it’ll just work!

WiringPi v2 released…

After some months of testing and time away due to family issues, a short holiday and what-not, wiringPi v2 has been pushed to the GIT repository and is now released!

Additionally, it now has its own website:

Changes: 100′s. There is now a completely re-written internal structure that allows for analogRead() and analogWrite() functions (hardware permitting – e.g. on the Gertboard and other A/D converters). There is a mechanism for adding new GPIO hardware – e.g. MCP23x17 (both I2C & SPI variants) and much much more!

As usual, feedback is welcome – my plan is to run a forum on the site  shortly, but for now I’ll allow comments on this post, or drop me email.

Sourdough with unbleached flour…

So as you may have read here, you might know I have a bit of a thing for baking… And so we had a little family “do” last weekend – my in-laws 50th wedding anniversary and we did an afternoon tea party for about 60 guests.

So as well as cakes, scones, and so on we needed sandwiches. Nice thinly sliced bread with the crusts cut-off, cucumber at the ready along with egg mayonnaise & cress, and so on.

Now I love baking bread, but that much bread, while perfectly possible for me to bake in a day or 2 is not possible to slice without a proper bread slicer – so in the past we’ve used local bakeries to supply the bread. This time we used Seeds2 in Totnes.

Darren there did us proud and supplied 11 loaves of varying type from white to seeded and granary. Knowing I like making my own bread, he also gave us a bag of the flour he uses – Stoats Organic unbleached strong white flour.

So I fed my sourdough starter with some and baked a loaf. Then baked another, and took some photos… The starter seems to like it – lots of activity there, and the bread rises a bit faster on it too! Possibly because most of the bread I usually make is a wholemeal flour mix, so giving it white flour with a bit more protein and gluten gave it a boost.

sourdough4Heres the latest loaf. The smell, texture/crumb and crust is all great. But the colour… That’s unbleached white flour for you! It’s a very pale yellow in the packet and It appears to darken slightly when cooking.

So wondering what they put into flour to make it white, I did some searching… Found this on Wikipedia and a whole load of other things too.

A quick search for products return names like “White Glow” and “Super Glow”, and interestingly in 2011 China banned the use of flour whiteners! (Which doesn’t seem to stop online places like selling flour whiteners from China though)

So it seems there is fierce debate on the subject, but not everywhere! What would you do if you bought a load of bread made with white flour and cut into it and found that it was a pale yellow colour – perhaps verging on beige?

I think it’s quite brave of Seeds2 to sell unbleached white flour loaves, but at the same time, when we’re living in a society where we’re being more conscious of what we eat and how its produced, maybe they’re actually the leaders and showing us the way…

Me? I think I’m going to stick to using the wholemeal flours which I usually use, which aren’t bleached anyway, but for my cakes and biscuits? More experimentation may be required.

Oh, in-case you were wondering – this is what some of the spread looked like last weekend!

50thWell, some of it at least. There was the same again (and more!) in the kitchen which came out to top-up the platters through the afternoon.

Cheese Scones, Devon clotted cream and jam scones (jam on top!), carrot cake, polenta and almond cake (gluten free), rich chocolate cake, bakewell tart, millionaires shortbread and plain shortbreads, brownies, bara brith, a raspberry loaf, chocolate and ginger loaf, and a tower of cupcakes! (I didn’t do the big cake in the middle or the bara brith though!)