I’m Harris and I studied Electronic Engineering at University of Nottingham, UK but have now graduated and work as a Graduate Electronic Engineer at Ocado (not blog affiliation here!). Along with a life full of electronics, I enjoy ice skating, playing bass guitar, having a pint with my chums, any form of gigging and listening to music!

I’ve been interested in electronics since a pretty young age in my opinion. It first started when a childhood friend of mine got a 10 in 1 electronic kit for his birthday allowing for such projects as making a crystal radio or lighting a light bulb with a transistor. I was utterly fascinated at how wiring up simple components could produce visual or audible effects and I begged my dad to buy me one! A week later, the post arrived and it turned out my dad had purchased me a 30 in 1 electronics kit off amazon. At first, I made a few of the projects not understanding what half of them even did but observing the effects of the circuits, whether they created strange sounds in the crystal headphone or lit the LED up dependent on external inputs. A few of the projects I found so interesting that I started to make them seperate from the kit. One of these was a keyboard using the carbon in pencil lead to produce a variable resistor and making little keys out of wood. It sounded awful but I was amazed at what electronics could do!

Fast forward a few years and I started my first “real” project. I’ve always liked the thought of being able to drive a motorized vehicle and decided to give it a shot. With absolutely no knowledge on petrol engines and hardly any mechanical abilities other than using a screwdriver, spanner and terrible soldering ability, I embarked on an epic task of building a trike.

When I was younger, I was fortunate enough to receive the present of pedal go kart. It had been a few years since then and I was starting to outgrow it anyway so I dismantled the whole pedal drive section leaving just the seat, frame and steering mechanism. It was then that I needed to figure out some form of drive system. Having been influenced by the T-rex reverse trike, I decided that I wanted to go for that style of vehicle and swiftly purchased a cheap “mini-moto” motorbike, IIRC, it was around £30 and my dad took me to collect it from somewhere in the heart of Staffs.

Now having bought a partially working mini moto, I had the mammoth task of rebuilding the crappy little 47cc (fake 49cc) engine. With ebay on my side, I purchased a new pull start, new ignition coil system along with a new fuel filter and throttle cable. I also bought an old exhaust fit for a mini moto off one of my school mates too (I was around 13/14 at this time!).

After rebuilding the engine, I had a working mini moto (though both tyres were in poor condition) and half a gokart and I needed a way to join them. Not wanting to involve anybody else in my project, I knew of welding (thanks to the godly program – Scrapheap Challenge), but not how to do it!

By this time, I had quite a collection of other electric motors and battery packs so I took to YouTube and saw if there were any possible methods that I could weld without shelling out another £50 for a real arc welder. After trawling through video after video, I managed to find a video showing of how people in parts of Africa were stranded with broken vehicles yet ingeniously used the car batteries wired in series to create a really shoddy arc welder.

Fitted with a couple of deep cycle 20Ah 12v batteries, the fattest wire I could find in my local hardware store (Price City, you’re the best shop ever!), some 2mm welding rods off eBay, thick gardening gloves, an Aldi welding mask and some battery clips, I was ready to have my first ever attempt at welding! I got the mask on and attached one of the clips to my vice which was holding a piece of scrap metal. Slowly stroking the rod along the piece of metal, I struck an arc straight away and melted the whole piece away! Turns out 48v is a little bit too much for welding scrap metal…

A few more attempts on the scrap and I was ready to start on my trike. With absolutely no measurements made (all done by eye), I scratched away at the paint, lined up the mini moto (with the steering mechanism now removed) and made the first proper weld!


Once all the welding had been done, all parts attached and the petrol tank filled with a 2 stroke mix, I took if for the first spin. It was completely exhilarating! Obviously, it was about as safe as walking down a motorway on a foggy night with loads of traffic, not forgetting it was loud enough to deafen from a mile away. The only place I could possibly take it to was a long stretch of path next to a field, and thats where I went! I managed to get it to 25Mph before deciding that going any faster would be stupid of me with no form of crash gear on.

It got to the point though where the neighbours were getting a bit annoyed about how obnoxiously loud and unsightly it was around the estate and my Gran proceeded to have a “chat” with me that generally concluded with: change it from petrol or it goes to the tip. I was absolutely livid that she couldn’t see the amount of work and effort I’d gone into making this trike and didn’t speak to her for 3 days (its harder than you think when you live with your grand parents!). So finally, my decision was to convert it from petrol to electric powered. Fortunately, by now I’d only spent ~£50 so my budget was still a touch healthy.

So again, returning to eBay, I purchased all the kit required to do a full electrical conversion: 36v 500w motor, 36v dc controller, hall effect throttle and 3x 12v 7ah SLA batteries. This really did push the budget up having cost around £110 for all the parts – a lot of money when you’re an incomeless teen.

And so, that was the trike for a fairly long period of time until I decided to try and upgrade it to a hub motor and ended up breaking it! It unfortunately never lived on past that point and to this day, its probably my proudest achievement.

A few more minor projects happened along the way:

  • Bass guitar amplifier – 100w Class D based on a Philips TDA8920 with SMPS
  • A few bass effects guitar pedals
  • A few high voltage projects and amplifiers
  • Built a PC
  • The bassbox!

With  coming to uni, I got the opportunity (surprisingly!) to make many more interesting projects. One of such was a completely touch sensitive bass guitar named the Phobass. I entered this project into a university competition called the Student Venture Challenge, obtained some major investor interest and won a £1,000 entrepreneurial grant too! The project is still ongoing though with a job offer from a large electronic engineering company, its currently quite low down on the priority list.

If you fancy watching some videos of a few of my projects, check my youtube channel:

So thats me!


19 thoughts on “About

  1. Hi Harris, That is some awesome work you done in here.
    I was also working on a Nokia 5110 LCD but I cannot get the menu and button interface to work properly( scrolling through the menu depending on up, down and enter keys). Can you give me an idea as to how you have coded the menu for the LCD.
    In case you would like to contact me my mail id is: harigovindmenon92@gmail.com

    1. Hey Hari,

      Glad you like it! For my smart watch, I use a 3 button menu system: Up, Down and Enter. for the Phobass, I use a 5 button system: Up, Down, Enter, Left and Right.

      The part that makes it most easiest is that I use an external low pass filter and pretty drastically undersample by switches in code. I find that one of the easiest ways of debouncing. The Phobass however does include full hardware debouncing with low pass filters and schmitt triggers.

      Within the program, I use a nifty bit of code which only sends the button value on a rising edge press. This means that for every loop around my main code section, the switch is only 1 for the initial press and never again until the button is released and repressed!

      With regards to the actual menu, I merely print strings to a screen and use a variable that stores the current menu position, if the menu position is equal to the xth string, that string has all the colours of the character inverted!

      Hope that helps,

  2. Hi Harris,
    Love you page, a lot of useful information! I am specifically interested in your post regarding driving the SSD1306 with an STM32F0. I am trying to do the same thing on the STM32F4. What are the changes that you think I will have to take care of? Thank you in advance.

    1. Hi Tim,

      Fortunately, the ST peripheral library is pretty portable between the STM32F0 and STM32F4 series of chips. I’ve got the STM32F0 version on my Github and you can read my post here: https://hsel.co.uk/2014/10/21/ssd1306-lcd-and-updates/ 🙂

      You should only need to change:
      RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);


      RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

      and change GPIO_AF_0 to GPIO_AF_SPI1

      along with changing all of the filename includes from stm32f0xx to stm32f4xx (the one difference here is that stm32f0xx_misc.h becomes just misc.h iirc).

      With those changes, all should work fine! If you come across any problems, just drop me a message 🙂


      1. Hi Harris,
        Thank you so much for the prompt reply and sorry I did not see this message until today. I did what you suggested and also changed the CE (Chip select pin) to PE3 (since STM32F4 use PE3 for chip select), and everything compiled just fine but nothing on the display 😦 One weird thing is that the type uint8_t is not defined on my machine. Not sure if that’s the problem. Please get back to me.
        Thanks again,

      2. Hi Tim, don’t worry about it! I don’t actually think that the ST series of chips automatically do the chip select control as I’ve programmed that part to be done myself. If uint8_t isn’t defined, try including as this contains all standard integer types though stm32f4xx.h should include it! If you have any form of logic analysing hardware, it might be worthwhile checking to see if you’re actually sending any SPI data. If you can see the data sending, it could be a problem with the code with respect to the register writes for the LCD. If you’ve got dropbox or anything, I’d be more than happy to have a look at your code for you!


      3. Just to be more detailed, instead of this:
        G.GPIO_Pin = DC | CE | RS;
        G.GPIO_Mode = GPIO_Mode_OUT;
        G.GPIO_OType = GPIO_OType_PP;
        G.GPIO_PuPd = GPIO_PuPd_UP;
        G.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(IOGPIO, &G);

        G.GPIO_Pin = Clk | DIn;
        G.GPIO_Mode = GPIO_Mode_AF;
        GPIO_Init(IOGPIO, &G);

        I have:
        // DC and Reset pins
        G.GPIO_Pin = DC | RS;
        G.GPIO_Mode = GPIO_Mode_OUT;
        G.GPIO_OType = GPIO_OType_PP;
        G.GPIO_PuPd = GPIO_PuPd_UP;
        G.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(IOGPIO, &G);

        // Alternate configuration for Clk and DIn
        G.GPIO_Pin = Clk | DIn;
        G.GPIO_Mode = GPIO_Mode_AF;
        GPIO_Init(IOGPIO, &G);

        // CE (CS)
        G.GPIO_Pin = CE;
        G.GPIO_Mode = GPIO_Mode_OUT;
        G.GPIO_Speed = GPIO_Speed_50MHz;
        G.GPIO_OType = GPIO_OType_PP;
        G.GPIO_PuPd = GPIO_PuPd_UP;
        GPIO_Init(GPIOE, &G);

  3. Hi Harris,
    Thank you again so much for the reply. Yes i will send you the dropbox files when i get home. One more thing is that I am working with a 128×32 oled, not 128×64 like you have but they are using the same ssd1306 driver. My email is tcao2@masonlive.gmu.edu in case you want to quickly contact me.

  4. Harris,
    I just want to say thank you so much for your help! I got the screen to work now. I cannot stress this enough but THANK YOU! Do you have a PayPal or sth? I would like to buy you a meal or at least a coffee!
    I was missing this line: RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
    Right now I am trying to fix the font as I am a smaller display (128×32, not 128×64). Thanks again!

    1. Hi Tim,
      Don’t worry about it! The internet has helped me with a lot of my electronics, the least I could do is give back and help others 🙂 My graphics library uses a standard 5×8 font though you should be able to find smaller fonts around! If you fancy making your own, you can use a piece of software called GLCD font creator (http://www.mikroe.com/glcd-font-creator/) it allows you to export fonts as character tables 🙂


      1. Hi Harris,
        Sorry for bothering you again, but I ran into some problems. The text seems to be cut at the top and the bottom, and only the middle part of the text is visible when displayed. Initially I thought that it was because you were using the font for 128×64 screen, but that would not make sense as if I use the same thing on mine, it should display everything correctly, just that I would have 1/2 of your vertical space for text. Is there anything you can think of that might cause this problem? In your code, you have:
        #define XPix 128
        #define YPix 64
        #define GBufS (XPix*YPix)/8
        I changed YPix to 32 and GBufS to (XPix*YPix)/4
        Is there anything else I should change? Thanks again for your help Harris

  5. Hi Tim,
    I’m not too sure if you’re using a non 5×8 font so for this, I’m going to assume you are! If you’re using a 5×8 font, you want to keep GBufS as (XPix*YPix)/8. This is because one byte stores 8 vertical pixels, in the way that the SSD1306 memory interface is programmed. I’m not too sure but I think that if you use a 32 pixel screen, the memory is no longer linear. If you’ve ever had a go with any HD44780 LCDs, its the same with this in the sense that accessing the second row in memory is not directly after the first row.

    I don’t actually have a 128×32 OLED screen to test with so I don’t think I’ll be much help. Adafruit however do sell a 128×32 OLED screen so they probably have a better initialization method than I do. https://github.com/adafruit/Adafruit_SSD1306/blob/master/Adafruit_SSD1306.cpp

    Reading through their code, it does seem a few initialization variables change! Hope that helps 🙂

    1. Thanks for the prompt reply Harris. So I should look at the init sequence for 128×32, and modify your code accordingly? Thanks again.

      1. No worry! The SB function is used to send a byte from the STM32F4 to the LCD. The function takes three parameters, the data to send, whether or not the data is pixel data or a command and whether or not the CE (enable) pin is pulsed. To save on time, pixel data can be streamed to the LCD with consecutive SPI writes by enabling the CE at the start and disabling it at the end. This saves enabling and disabling the chip with every byte. with every byte. In the code, the initial Write Bit defines whether the data is a command or pixel data, the CE is then written depending on whether it should be (defined by En). Hopefully that helps!


  6. Hello again Harris,
    Hope everything is going well for you. I just wonder if you have any experience implementing a 4×4 matrix keypad using interrupt with the STM32F4 MCU? I’m implementing mine and having some issues that I can’t figure out.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s