Archive | Crumble Projects

If you haven’t already taken a look at part one, then it would be worth starting there for more information about this project.

The next step in our Binary Snap Game journey is to connect all of the other elements we need to play the game, which include the Smart Crumb: Digits and a Push Switch.

Now we need to work on the premise of our game – what do we want it to achieve? We want a number in binary to appear on our Sparkle Baton and another to appear on the Smart Crumb:Digits for a limited amount of time. If they are the same we need to press the button to score a point. If not, we wait until they change. Let’s start by getting the same random number to display on both components.

We then have a few other additions to make to complete the game:

• Generate a random number for each output
• Have a button press check whether the outputs are same
• Have a timer for each round, which then checks whether the outputs are different
• Have the game reset

We start with a timing loop, which will end either when the button is pressed, or the round is over.

We now need to check the outcome of the game. If Timer is less than 40, it means the button must have been pressed, so if that is true and both of our random numbers are the same, then we win. We show this by turning on all of the Sparkles green. On the other hand, If Timer equals 40, the timer has elapsed, so if that is true and both of our random numbers are not the same, then we also win and the Sparkles light up green. Finally, if we get this far through our conditions it means either we incorrectly pressed the button or we missed a matching pair of numbers and so we lose this round and the Sparkles turn red,

If we now add this to the previous code along with a pause to give us a chance to see the round results (wait 2 seconds) and nest the whole lot within a loop, we should have the basis of our Binary Snap game!

One thing you may notice before or after you’ve played are the odds of getting a matching pair. It is 1 in 225, which is fairly unlikely (although not impossible). Let’s add a small bias into our program to make every 1 in 10 match. For clarity we’ve created a new variable called Bias, which we set to a random number between 1 and 10. If that number is 5, then our binary number and normal number become the same.

With the bias put into our code we now have an awesome game! There are plenty of other ways you could achieve the same results or even take this further. Adding in larger numbers. How about keeping score? Or what about increasing the speed between each round after every successful answer!?

If you have a go at this project, or any other, we’d love to see! Get in contact with us via email, Facebook, Twitter or our Forum, and we may feature your work!

Understanding that any number can be represented using only the digits “1” and “0” is fundamental to understanding how computers store, process and transmit information. To investigate this concept further, and to practice writing (and de-bugging!) algorithms, let’s code the Crumble to play “Binary snap”. This game will involve matching binary numbers, represented on a Sparkle Baton, with the decimal value on a Smart Crumb: Digits.

If you aren’t familiar with what binary numbers are, take a look at this article explaining them, but put simply binary is a number system which uses only two digits: 1 and 0. This means we can represent a number on the Sparkle Baton by switching the individual LEDs on (“1”) or off (“0”). Let’s begin by working out how we can algorithmically convert a number into binary.

Whilst jotting down the first 16 numbers in binary to look for a pattern, we remembered a faint snippet of information from when learning about this back at school. An easy way to convert between decimal numbers and binary is to work methodically from largest place value column to smallest e.g. 8 | 4 | 2 | 1, comparing your number to the place value column. If your number is greater than or equal to the place value column, then put a one and subtract the place value from your number. If not, then we put a 0 in the number. After each ‘check’ we move onto the next smallest place value. It might be easier to see an example.

Start by wiring a Sparkle Baton to the Crumble.

Programming wise, start by clearing our Sparkles and setting up some variables for testing. SparkleIndex refers to which Sparkle we want to light up, Value is our number for converting into binary and BinaryPlaceValue is the place value of the binary columns. We are starting with a 4-bit number so will begin at the highest place value for that which is eight.

After this, we can add our algorithm: If Value is greater than or equal to BinaryPlaceValue, light up the current SparkleIndex Sparkle and subtract BinaryPlaceValue from Value, else move on. Decrease SparkleIndex by one and BinaryPlaceValue halves.

We’re missing some other important parts of this algorithm – it needs to loop back until we’ve passed over every binary place value column. A simple way of doing this is to use our SparkleIndex value as a loop counter, as it decreases on each pass of the loop. As we need to include the zero pass, we’ll set the loop condition to be -1.

A quick check of a variety of numbers and it seems we have a working program! Notice that the Baton needs to be upside down to display your binary value correctly.

And there we have it, we have successfully made a program that displays a whole number in Binary, using the Crumble controller and a Sparkle Baton. You can display 8-bit numbers if you want, all you need to do is tweak the SparkleIndex and BinaryPlaceValue. The next challenge will be to gamify this in part two!

If you have a go at this project, or any other, we’d love to see! Get in contact with us via email, Facebook, Twitter or our Forum, and we may feature your work!

Our younger child’s school is having a competition to design and make a crown for their Coronation celebrations on Friday. We think we can definitely add some wow-factor with the Crumble and a Sparkle matrix display!

First question: can we make a recognisable design on a 5×5 grid? We tried a few different options on paper and decided on the “Union Jack” design in the centre, below:

Top secret advance news: Crumble designer, Joseph, is actually working on a custom block to program the Sparkle matrix (similar to the block that already exists for the Sparkle baton) but, until this is ready for release, we will have to use our programming skills.

One way to write the program is block-by-block:

but this quite time consuming and boring to write. It also takes up a considerable amount of Crumble memory – especially if we then want to add in some animation.

In order to construct the design programmatically, we need to break it down into its separate elements. We started with the white background (“set all Sparkles to white”). We then created the St George’s Cross (the red vertical & horizontal bands) with a couple of “do-loops”:

St Andrew’s Cross (the blue diagonals) required a bit more thought. We initially used just one variable for the Sparkle number (because it is reset at the start of every do-loop) but to make the algorithms a bit clearer and to help us remember what the program does if we come back to it at a later date, we changed to two variables and gave them more meaningful names: 

We can now add in some “wait” statements so the crosses appear in turn and put the whole program in a “do forever” loop to animate the design:

Notice that this takes up less space in the Crumble’s memory than the original program that set each Sparkle individually, once. It also makes it much easier to tweak the design. Do you think it should cycle faster or slower? Would you give St Andrew precedence over St George? (Apologies to St Patrick: we couldn’t see a way to include the red diagonals with only 25 pixels.) 

As always, we’d love to see your own designs!

On Monday we had our first dentist appointment for over a year! No major issues (phew…) but the kids received a reminder about the importance of brushing teeth for 2 minutes every time. Faced with the prospect of having my phone waved around over a tiled floor and a toilet bowl twice a day, I suggested we should make a Crumble timer.

This turned out to be a really nice project. Even with just the components in our Starter Kit there is scope for different approaches (sounds/flashing lights/colour sequences) and it was a great opportunity to learn/recap how to use inputs and outputs.

My 8-year-old decided on the simplest approach: wait for 2 minutes and then sound a buzzer. While we were connecting the components, he asked if we could just connect “+” on the buzzer to “+”  on the battery box and use the battery box switch to turn the buzzer on and off. This is an excellent question because, of course, we can do that: the buzzer and battery box (with its built-in switch) can be connected in a simple circuit. When the switch is closed the electricity will flow and the buzzer will sound. 

Buzzer, battery and switch connected in a simple circuit.

Inputs and Outputs

This brings us nicely to a fundamental question: why do we use the Crumble at all? The reason is to give us control. We only want the buzzer to sound after 2 minutes has elapsed.

The chip (microcontroller) on the Crumble (or in your central-heating system/washing machine) takes information (input) from the user and runs a set of instructions (an algorithm) in order to determine which processes to run and what to ouput.

A clever feature of the Crumble is that pads A, B, C and D can function either as inputs or outputs. The Crumble will either set them (as outputs) or begin to monitor them (for input) depending on which blocks (processes) are used in the program:

We instruct the Crumble to monitor inputs using commands like:

When we connect a switch between “+” on the battery box and (e.g.) pad “A” on the Crumble we are not using it to turn the Crumble on and off. Instead, when the switch is pressed, electricity flows to pad A and the Crumble detects this as an input. If the switch is closed, A is “Hi”; if it is open, A is “Lo”.

We set outputs using these blocks:

When we connect the “+” pad of the buzzer to (e.g.) pad “C” on the Crumble, the Crumble then controls whether electricity flows to output C and, hence, whether the buzzer will sound. 

The wiring for the 8-year-old’s project is shown, below:

Wiring diagram for a simple timer with buzzer.

And here is the program that is sent to the Crumble:

Crumble program for a 2-minute timer

The Crumble waits until the switch is pressed (in this case, it is connected to “B”); waits for 2 minutes (quick bit of maths to convert this to seconds); then turns the buzzer on.

We had also thought about how you would use the timer in the bathroom. You could turn the buzzer off with the switch on the battery box but you shouldn’t do this with wet hands! Instead, we added the “wait 10 seconds” and “set C LO” blocks so the buzzer turns off after 10 seconds. The program then loops back to the start and the timer is ready for next time.

A coding challenge

Meanwhile, the 11-year-old was working on his own timer. (He found a Sparkle baton to use for his lights but the individual Sparkles from the starter kit can be used in a similar way.) He decided he wanted to see the time progressing so programmed each Sparkle to change from red to green, in turn, over the 2 minute period. At the end of the 2 minutes a buzzer (connected to “B”) pulses on and off for a few seconds.

This is the first program he wrote:

Crumble program for a 2-minute timer using a Sparkle baton and buzzer.

It works as required but it contains a lot of repeated lines. This suggests it is not the most efficient way to write the code. I set him a challenge to re-write his program using a loop and a variable:

Program with the same function as above, but coded more efficiently.

The resulting program does exactly the same but it is a lot shorter and would also be much quicker to adapt if he decided he wanted to change the colours or the time interval. Note, also, that it only takes up half the space in the Crumble’s memory. Writing efficient code is an important skill!

Design for purpose

Now we have the Crumble connected and programmed, we can think about other elements of design. We added a loop to the first program so we wouldn’t have to manually turn the buzzer off but there is always a risk, in a bathroom, that the components could get splashed. How could we mitigate this risk? Can we enclose the timer but still be able to press the button to activate it? Or is there a different type of input we could use?

We do, in fact, have several inputs that can be activated without touching them: the light sensor (included in the starter kit); the ultrasonic distance sensor; a tilt switch and a reed (magnetic) switch.

My version of the toothbrush timer, therefore, uses all the starter kit components inside a Tupperware box. Instead of being triggered by the push-button switch, the light sensor is used at the bottom of the box. When the box is picked up, the Crumble detects the change in light level and starts the timer sequence.

Wiring diagram for the light-sensor activated timer

Crumble program for the light-sensor activated timer

I used modelling clay to hold the Sparkles and light sensor in place, facing outwards. For the light sensor, this also helps to block out the ambient light when the box is resting on a surface. We pick up the box to trigger the timer sequence.

The Sparkles turn red, amber then green, in turn. I have used a variable “time” to control how long the light sequence lasts. This is set at the top of the program so could easily be changed, if required. Once the 2 minutes have elapsed, the buzzer pulses. The Sparkles are then turned off and the program loops back to the beginning and waits for the trigger.

What other types of timers can you think of? Would they require any different design features? If you try this, or a similar project, we’d love to see it!

Christmas is fast approaching, and to spruce up the office we decided to get a tree. However, this tree is a little bit different. Are they massive flexible Sparkles or is the tree really small?

Sadly, it is the latter. We picked up the tiniest little Christmas tree, and decided it needed a bit of a Crumble makeover. 

We snipped 10 lights off of our Flexible Sparkle Strip and soldered them together. If you don’t feel confident enough doing this, you could use the whole flexible strip and wrap that around your tree, or if you want to use big Sparkles, you can croc-clip them together like we did a couple of years ago.

After decorating, you can then program your own custom light sequences! We decided that we wanted a fairly classic light sequence, lighting up random colours between red, orange, yellow, green and blue. To achieve this, we are taking inspiration from our ‘Random Colour Picker’ blog. 

The program is simpler than it looks. Assign a variable a number, which will define what colour our Sparkle will light up. Then set a random Sparkle between 0 and 9, to the chosen colour. Wait 10ms before doing it all again!

This is not only way way of running your lights – you could have them fading through RGB, pulsing on and off, chasing up and down the tree, or you could even make your tree interactive!

Our lovely bit of festive cheer, to brighten up the office.

Thank you all for making this our best year yet. We have many exciting things planned for next year, and we are excited to share them with you soon. We hope you all have a wonderful Christmas, and a Happy New Year! See you in 2020.

If you have a go at this project, or any other, we’d love to see! Get in contact with us via email, Facebook, Twitter or our Forum, and we may feature your work!

One blog post was definitely not enough to look at DIY switches. Given how simple the idea is, it’s surprising just how many different ways you can make a switch! If you haven’t already seen it, take a look at our first post.

We love these, as they provide an alternative way of using interesting inputs with the Crumble. We’ve decided to show you a few more examples of switches you can make yourself, and whilst going through this process we’ve thought of a brilliant idea for a new project, which we are working on now.

The first switch we have here, is a moisture sensor. It is made using two strips of copper tape (you could use anything conductive) placed close together.

If you wet your finger and place it across the two strips, the moisture bridges the two pads, causing the switch to be ‘closed’.

Next up, we have a reed style switch. For those of you unfamiliar with a reed switch, take a look at our Magic Candle blog to see it in action. Put simply, it’s a switch that is triggered (closed) by a magnet. We have fashioned our own using some aluminium foil (not magnetic), and a nut glued to the raised flap of foil.

When a magnet goes near the underside of the switch, the nut is pulled towards the other piece of foil, closing the connection. When the magnet is moved away again, the foil flaps open again. It’s amazing how resilient and springy foil can be!

Now we move onto something a little bit different. We’re going to call this a ‘joust switch’. It serves the same purpose as a whisker/bump/micro switch.

When it is pressed, the connection is broken (push-to-break). We can use this as a limit switch, and easily make a bump-and-reverse buggy!

Our final switch takes inspiration from a tilt switch. We have left the top off of this version, to make it easier to see what is going on.

When tilted in a certain direction, the ball bearing touches our two electrodes, closing the switch. When it’s tilted back, the ball bearing moves away from the electrodes and breaks the connection, opening the switch.

And there you have it, more switches to use with your projects!

If you have a go at this project, or any other, we’d love to see! Get in contact with us via email, Facebook, Twitter or our Forum, and we may feature your work!

Although the outputs (motors, Sparkles, buzzers etc) of the Crumble get a lot of love and attention, we mustn’t forget how awesome inputs are! They allow us to interact with our projects. Arguably the simplest type of input, the humble switch provides us with a digital(binary) input for the Crumble; it is either on/off or HI/LO.

Before we look at making our own switch, we need to consider what a switch is, and what it does. This will help us later on. If you already have a good understanding, then feel free to skip over the next bit.

First, let us consider a circuit – a closed loop of conductive material and electronic components through which electricity flows. The important word here is ‘closed’. Electricity will only flow when there is a clear path from positive (+ve) to negative (-ve). If we break the circuit/connection, then the electricity will stop flowing. This can be very useful when we want to control components in a circuit e.g. a buzzer or a light. We can do this by using a switch – a component which we use to control the flow of electricity.

There are all manner of switches available, from a good ol’ push switch to an illuminated key switch. But sometimes there just isn’t quite the one we want, or one we can integrate into a project how we want. A great way of solving a particular problem and thinking about how switches work is to make your own. To make something, which when interacted with in some way, will close a circuit. Not only does this give you a great insight as to how switches work, the concepts involved are perfect for meeting various Computing/Science/Design & Technology curriculum targets.

So without further ado, let us look at different ways to make switches!

First of all, let’s make a classic split pin/paperclip switch.

By moving the paperclip, we can open/close the switch. The paperclip joins together our two contacts (split pins), which are connected to the Crumble – one on a +ve output, and the other to an input (A, B or C – D is used for a Sparkle). When the connection is made, A becomes HI and the Crumble turns a Sparkle on red. When the connection is broken, the Sparkle turns off.

Our code for this is as follows. Although not the most efficient way of achieving our desired result, this code is easily extendable for our rotary switch. If A is HI, then set the Sparkle red, otherwise turn the sparkle off.

Continuing along the theme of a simple switch, lets make a ‘pressure pad’ style switch.

When pressure is applied to the top surface, the foil bridges the gap between the two foil contacts on the bottom surface (connected to the Crumble as before). This then runs the same program as before – the switch is a straight swap.

Finally, we decided that we wanted a rotary switch, with multiple outputs.

The centre arrow can be lined up with one of three outputs. Each one connects to a separate input on the Crumble. Depending on which one of the inputs is HI, the Crumble lights the Sparkle red, green or blue.

The code for this is an extension of our previous two switches, except that we check for multiple different conditions being true (inputs being HI).

These are just a few different ways of making your own switch. By taking the very basic principle of ‘bridging a gap’ and closing a circuit, you can easily let your creativity run.

If you have a go at this project, or any other, we’d love to see! Get in contact with us via email, Facebook, Twitter or our Forum, and we may feature your work!