We had a really good meetup of our little hardware group today. Adam came along and we talked about lots of lovely tech including proposals for a “bike thing” device for measuring road quality while you pedal. I really hope we can have a go at building one.
Today I have been mostly making mistakes. Some people say that failures are more useful than successes because you learn from them. In which case I’ve learned a lot today:
It is possible for a drawer to contain 50 cables, none of which are the one that you need.
The esp8266 microcontroller does not produce high enough logic levels to drive an AdafFruit 8x8 NeoPixel array. I realised this his after I’d wired up a few and none of them worked. Update: It turns out that this is wrong. I’d connected the data signal to the wrong pin on the ESP8266. It works fine with the panels.
The logic level converters that I bought to address this issue do not solve the problem. See technique above.
The ESP32 device does produce levels that can be used to drive a NeoPixel array. Provided you have a spare one to hand.
I need to order some more ESP32 devices.
Today finds me saving setting information for my nightlight. I want to save the time the “on” colour and the “off” colour along with the times when the light should change from one to the other. Like a good programmer I’ve made a class to hold the setting information:
blue = [0,0,255]
yellow = [255,255,0]
class Settings:
file_name = 'settings.json'
def __init__(self, on, off, on_colour, off_colour):
self.on = on
self.off = off
self.on_colour = on_colour
self.off_colour = off_colour
@staticmethod
def getDefault():
return Settings([06,30],[18,30], yellow, blue)This is the first part of my Settings class. The __init__ method initialises a setting instance. The getDefault method creates a light that comes on at 6:30 and goes off at 18:30. The light is blue when it is “off” and yellow when “on”. So far, so good. Now I want to store the value of a setting in a JSON file.
def save(self):
settings_json = ujson.dumps(self.__dict__)
print('Saving:', settings_json)
try:
f = open(Settings.file_name,'w')
f.write(settings_json)
f.close()
return True
except:
return FalseWe can use the save method to ask a Setting instance to save itself. It converts the data dictionary in the Setting object into a string of JSON and then writes this string to a file. If all is well it returns true. If you’re wondering why I’m using ujson rather than json its because this is a special JSON library for MicroPython. So we can now save the setting values in a file. But can we get them back?
@staticmethod
def load():
try:
f = open(Settings.file_name,'r')
settings_string=f.read()
f.close()
print('Got settings:', settings_string)
settings_dict = ujson.loads(settings_string)
result = Settings.getDefault()
for setting in settings_dict:
print("Setting:", setting)
setattr(result,setting, settings_dict[setting])
return result
except:
print('Settings file load failed')
return Settings.getDefault()This is the load method. It is a bit more fiddly then save. The problem is that when we load the JSON back from the stored file we get a dictionary, i.e. a set of name/value pairs. We don’t want a dictionary. We want a Setting object. So we have to build one which contains the loaded data. The first thing we do is create a “default” setting as a target. Then we work through the dictionary that we loaded from the file and use the magical setattr function to set each of the matching attributes in the result to the loaded value. If the loaded data is “sparse” (i.e. some of the attribute values are missing) the result that is created will have the default value for that missing attribute.
Note that I’ve made the load method static which means that it can be called from the Settings class. This means that I can load settings without needing to make a Settings instance to do it for me.
We could use these load and save methods to store a Settings object with any number of attributes. The only thing we can’t do is have Settings attributes which are themselves objects. The other wrinkle is that if you save a tuple attribute it will be loaded back as an array. But it does work and I rather like it.
I’m trying to make something every day. Or at least start making something every day. Or perhaps finish something that I started a while back. Or maybe start finishing something. Like a timed night light I started a while back. I thought I’d move the code to MicroPython (the device is ESP8266 based). The idea is that the light changes colours at different times. I built the lightbox a while back.
To make it work properly I have to get the time, which is easy enough in MicroPython. But I also have to deal with British Summer Time. Which is a bit of a pain. In summer time the clocks go forward to make the most of daylight and in the winter they go back again. I don’t want my light to get this wrong, so my code has to check for summer time and and add an hour to the time value if required. I’ve written this code many times. In a previous life I had my software putting best by dates and times on all kinds of things, from Budweiser beer to Cadbury chocolates to windscreen wipers. However, I’ve never written a version in Python. Here’s the code I ended up with:
def summerTime(time):
year=time[YEAR]
month = time[MONTH]
day = time[DAY]
hour = time[HOUR]
print("Test: ", year,month,day,hour)
if month<3 or month>10: return False
if month>3 and month<10: return True
if month==3:
hours_into_March = hour + (24 * day)
date_of_Sunday = 31 - ((year + int(year/4) + 4) % 7)
summertime_start = 2 + 24*date_of_Sunday
print(" Date of Sunday: ", date_of_Sunday)
print(" Hours into March: ", hours_into_March)
print(" Summertime start: ", summertime_start)
if hours_into_March>=summertime_start: return True
if month==10:
hours_into_October = hour + (24 * day)
date_of_Sunday = 31 - ((year + int(year/4) + 1) % 7)
summertime_end = 2 + 24*date_of_Sunday
print(" Date of Sunday: ", date_of_Sunday)
print(" Hours into October: ", hours_into_October)
print(" Summertime end: ", summertime_end)
if hours_into_October<summertime_end: return True
return FalseI give this function a time value made up of a tuple that contains six values. I’ve made some constants that I can use to pull each element out of the tuple.
# offsets into the time
YEAR=0
MONTH=1
DAY=2
HOUR=3
MIN=4
SEC=5The code is heavily instrumented (i.e. it prints out the values as it works things out). I can comment those statements out afterwards. Once I’ve written the code then came up with a way of testing it:
def testTime():
test_data = ( ((2020, 10, 25, 1, 30, 0), True),
((2020, 10, 25, 2, 00, 0), False),
((2021, 03, 28, 1, 00, 0), False),
((2021, 03, 28, 2, 00, 0), True),
((2021, 10, 31, 1, 30, 0), True),
((2021, 10, 31, 2, 00, 0), False),
((2021, 07, 23, 0, 30, 0), True))
for test in test_data:
if summerTime(test[0]) == test[1]:
print("Test passed", test)
else:
print("****Test failed: ", test)The test data is a date tuple and whether or not the date is in summer time. I’ve focused on the boundary conditions since these are when things can go wrong. If I was doing this for money I’d have a lot more tests than these. It seems to work (at least with these tests) so I can put it into my code.
Test: 2020 10 25 1
Date of Sunday: 25
Hours into October: 601
Summertime end: 602
Test passed ((2020, 10, 25, 1, 30, 0), True)
Test: 2020 10 25 2
Date of Sunday: 25
Hours into October: 602
Summertime end: 602
Test passed ((2020, 10, 25, 2, 0, 0), False)
Test: 2021 3 28 1
Date of Sunday: 28
Hours into March: 673
Summertime start: 674
Test passed ((2021, 3, 28, 1, 0, 0), False)
Test: 2021 3 28 2
Date of Sunday: 28
Hours into March: 674
Summertime start: 674
Test passed ((2021, 3, 28, 2, 0, 0), True)
Test: 2021 10 31 1
Date of Sunday: 31
Hours into October: 745
Summertime end: 746
Test passed ((2021, 10, 31, 1, 30, 0), True)
Test: 2021 10 31 2
Date of Sunday: 31
Hours into October: 746
Summertime end: 746
Test passed ((2021, 10, 31, 2, 0, 0), False)
Test: 2021 7 23 0
Test passed ((2021, 7, 23, 0, 30, 0), True)Above is the test output. Again, if I was serious about this I’d have made a bunch of unit tests. However, this works for my purposes. It’s worth noting that having automated tests made it much easier to debug the function when it misbehaved.
When I first tried the code I had written it failed and it took me a few minutes to work out why. It was because I was taking some C++ code and turning it into Python. And it has to do with modulo. You can use this to get the remainder of a divide operation. So any number modulo 7 would have the range 0 to 6. The code above uses this to calculate an offset into week.
Python has a modulo operator but it has an important difference from the C++ one. The C++ % operator only works on integers. But the Python % operator will work on floating point values. So 10.5 % 7 would be 3.5. You can argue which is the “best” way to do it, but for me the importance of the difference is that it broke the C++ code I was translating into Python. I had to re-write the code to allow for this.
I’ve been playing with PIR sensors. In this crazy world you can pick up five of them for around ten pounds. You can see one in the picture above. It’s the half bubble right in the middle of the frame. These trigger when they see something warm blooded walk past. They are used in burglar alarms and the like. I bought a bunch to play with. I want to make a PIR controlled nightlight that comes on when you walk past it. I’m going to use Neopixels as the light source.
The PIR sensor has an output pin that goes high when it sees someone go past. You can use the little orange trimmers on the device to adjust the sensitivity of the detector and how long it stays on once it has been triggered. You can also make the output signal a pulse or stay high as long as it detects something by moving the yellow jumper on the board.
I’d really like the whole thing to be battery powered. According to its data sheet the PIR sensor only sips tiny amounts of current, but this is not true for the ESP32 I’m using to control everything. The good news is that the ESP32 can be made to go into “deep sleep” mode in which most of the processor shuts down. We can use the trigger signal to wake up the processor when it sees someone. The ESP32 can then turn the light on and even log the detection over the network using MQTT or whatever. I’ve been playing with some code to make this work and I’ve come up with the following:
def startup():
global np,pin,n
if machine.reset_cause() == machine.DEEPSLEEP_RESET:
# we can do stuff here when the PIR was triggered
print('woke from a deep sleep')
else:
print('not been sleeping')
# PIR on GPIO 4
pin = machine.Pin(4, machine.Pin.IN)
# configure to wake up ESP32 when the PIR is triggered
esp32.wake_on_ext0(pin,esp32.WAKEUP_ANY_HIGH)
# put the ESP32 to sleep
print("Going to sleep")
machine.deepsleep()This MicroPython function can be added to a program that runs when the device is booted. In other words, you could put a call of startup() into the file boot.py
It checks to see if the ESP32 was woken from a deep sleep (i.e. the PIR triggered the restart. You can put whatever code you want to run in that part of the code. Then it configures pin GPIO4 as an input and tells the ESP32 to wake when this input goes high. Then it puts the ESP 32 into deep sleep.
I’ve tested it and it seems to work. The only problem is that not all ESP32 devices are equal as far as deep sleep power consumption is concerned. The DOIT board that I’m using leaves all the USB hardware switched on when it goes to sleep, which means that it still consumes quite a bit of power. If you want to do this kind of thing with an ESP32 I strongly recommend the DFRobot FireBeetle which only takes tiny amounts of power in sleep mode. Once I’ve made the code work I’ll move onto that platform.
I’m quite pleased with the way that this picture turned out. I took it yesterday in between the showers. It looks a lot warmer that it was..
Less of an “I’ve built this” and more of a “You should buy and build this” post.
I’ve spent a big chunk of today playing with LittleBits. They are awesome fun. Little electronic components that click together with magnets. Great if you happen to have a three year old to keep busy. Which I did.
I had a look to see if there were any new kits out there and I’ve discovered that they are selling Space Rover Inventor kits on Amazon for the silly price of 20 pounds. For that you get a controller you can drive from your phone via Bluetooth, two motors, a servo, a proximity detector and a bunch of other things. Well worth a look.
I suppose there should be more to making things than just plugging together devices and running their example programs….. However, until that time: here’s an M5Stack device connected to a thermal camera. M5Stack sell a camera unit but I used one sold by Pimoroni to be used with their breakout garden. Both devices are based on the same camera unit, the MLX90640 that gives 32x24 pixels of heat readings. I got the M5Stack sample program from GitHub which I found here. It works very well. At the moment these cameras are pretty much impossible to get hold of - I’ve had this one lying around for a while.
You can also use the camera with a Raspberry Pi although they are rather hard to get hold of at the moment.
I’m totally sold on Python development for embedded devices now. I had an idea for a silly device and ordered an 8x32 led array powered by Max2179 devices. The leds arrived last night and I plugged them into one of my cheap ESP32 devices and got it sort of working. I found an Arduino library and, after tweaking the C++ library code I manged to make it build and almost display something. Writing and deploying C++ from the Arduino IDE again reminded me why I don’t like this very much anymore. The compilers are very brittle and prone to failing if you happen to use a library that contains code that is not supported by the device you are targeting . And deployment is tiresome and slow. I think that the Arduino toolchain is an awesome achievement and makes lots of lovely things possible but it can be a bit of a pain to use sometimes.
Rather than continue with that I thought that today I’d try using putting MicroPython on the ESP32 and using a Max2179 library that I found on GitHub. This. Just. Worked. I used Thony to write and deploy the code. I was able to use the REPL command prompt to test out the code and my tiny little programs took no time at all to deploy and run inside the device. Best of all, the Max2179 library I found just sits on top of the Framebufuffer (http://docs.micropython.org/en/latest/library/framebuf.html) class and has lots of easy to use graphics commands.
I’ve got text scrolling nicely and now I’m going to hook it up to a data source. If you want to have a go at this kind of thing I’ve written a little HowTo that you can find here.
I’ve spent a chunk of today making my “Success Through Failure” presentation for Hull University First Years this evening. I’ll post a recoding or screencast later. As you can see above, my PowerPoint design skills are coming along nicely…
Update: the talk went really well (or at least I thought it did). The team were kind enough to record the whole thing and you can find the video here. You might even find it useful.
Didn’t have much time to make things today. But I did manage to make a successful landing somewhere in Japan…..
This is another of my posts to remind myself how to do something that I’m sure I’ll forget. It’s useful if you want to embed JavaScript (or perhaps any) code into a web page. If you use MarkDown to format the text you can mark the code by enclosing it in the sequences ```j and ```. In other words.
```j
var fred =99;
var jim = 100;
```
.. would be rendered as:
var fred =99;
var jim = 100;
Admittedly, this doesn’t look that different to the original, but if you remember that the line breaks in your text are properly respected so that it looks how it should. Remember to use the back single quote (it is on the top left hand corner of your PC keyboard) .
In a change of plan, rather than making a box for my temperature sensor, today I’ve spent a bit of time picking random letters. Years ago I I had an idea for a tiny Windows Phone game in which the player flicked letter tiles at targets to build words. I’ve decided to finish this off using my new JavaScript Matter.js skills. The first step is to pick some letters to use in the game. I reckon I’ll need 100 or so tiles to make the game work.
Now I could just pick the letters on the tiles by getting a random number in the range 1-26 and then just match that to a letter. That would work, but it wouldn’t be fair on the player as they would get as many letter Es as Zs, and that is not how the English language works. We use a lot more Es than Zs. So I went online, found a letter frequency table and popped it into JavaScript:
this.letterList = [
{ letterChar: 'A', freq: 8.34 },
{ letterChar: 'B', freq: 1.54 },
{ letterChar: 'C', freq: 2.73 },
{ letterChar: 'D', freq: 4.14 },
{ letterChar: 'E', freq: 12.60 },
{ letterChar: 'F', freq: 2.03 },
{ letterChar: 'G', freq: 1.92 },
{ letterChar: 'H', freq: 6.11 },
{ letterChar: 'I', freq: 6.71 },
{ letterChar: 'J', freq: 0.23 },
{ letterChar: 'K', freq: 0.87 },
{ letterChar: 'L', freq: 4.24 },
{ letterChar: 'M', freq: 2.53 },
{ letterChar: 'N', freq: 6.80 },
{ letterChar: 'O', freq: 7.70 },
{ letterChar: 'P', freq: 1.66 },
{ letterChar: 'Q', freq: 0.09 },
{ letterChar: 'R', freq: 5.68 },
{ letterChar: 'S', freq: 6.11 },
{ letterChar: 'T', freq: 9.37 },
{ letterChar: 'U', freq: 2.85 },
{ letterChar: 'V', freq: 1.06 },
{ letterChar: 'W', freq: 2.34 },
{ letterChar: 'X', freq: 0.20 },
{ letterChar: 'Y', freq: 2.04 },
{ letterChar: 'Z', freq: 0.06 }];This array contains an object that has a letterChar property (the char of the letter, and a freq property which gives the number of times that letter will appear in 100 letters. In other words, in 100 letters we should find around 12 Es, 1 V and not many Zs. I now want some JavaScript that will pick 120 tiles based on this distribution. To make the game seem more real, I also want to make sure that there is at least 1 of each character - even the one that mathematically should not be there. It turned out that the code to do this in one pass through the array of letters was a bit hard to do. In fact I didn’t manage to do it without a bit of cheating. What I came up with steals 1 tile from each calculated letter and then fills in the last few random tiles with randomly chosen tiles that have a uniform distribution over all 26. I’m kind of proud of this, until someone suggests a better way to do it…..
var createdTileCount = 0;
for (let letter of this.letterList) {
let noOfThisLetter = Math.floor(tileCount * (letter.freq / 100))-1;
if (noOfThisLetter < 1) {
letter.number = 1;
}
else {
letter.number = noOfThisLetter;
}
createdTileCount += letter.number;
}
// add in some spare random ones
while(createdTileCount<tileCount){
let lett= this.getRandomInt(0,25);
this.letterList[lett].number++;
createdTileCount++;
}Once I’d got my letters picked the next thing to do is display them. I’ve used my list of tile numbers to build all the tiles, given them some physics and then dropped them on the ground. Below you can see the result.
I guess this is more of a “work in progress” than a finished item. But it is still something I’ve. I’ll put the code on GitHub when it is finished.
I’m trying to use devices and things I’ve not used before. Today I’m using the Blockly environment provided by M5Stack to program their devices. This runs in the browser. You can find it here. You use the M5Burner app on your PC or Mac to program an M5 device with MicroPython plus a bunch of M5Stack libraries. You also use M5Burner to put your WiFi details into the device because (and this is wonderful) you can deploy the programs you are writing over a wireless connection.
You build a program by dragging blocks onto the workspace and fitting them together. Above you can see a program that fetches the temperature values and displays them. It took me a while to build this code what with the dragging and linking. I’m not really a fan of working like this, but then again I’m not learning to program so it’s not really aimed at me. The good news for me is that I can press the Python button at the top and be instantly transported into a world I know very well:
This source is keyed to the Blockly view and if I make changes to the Python code I’ll break all my blocks, but at least it gives me a handle on what is going on. And its a great way to learn to code. When you press the run button in the top right hand corner of the page you get to run the program in the device. If you want to deploy the program so that it runs each time the device is powered on you can use the menu to download it into the file store on the M5Stick. Then you use a tiny menu on the device itself to select the program and run it.
If you are wondering why some of parts of the above images have been covered with yellow blotches this is because these are the unique ID of my Cricket device which is transmitting the temperature values. You use the device ID as both the username and the password for the connection to the Things On Edge MQTT server. I don’t think that there would be a huge problem if someone got hold of the ID of my device (although I guess they could find out the temperature in my house).
And now I’ve got a little client that lets me view the temperatures from my remote sensor. It took hardly any time to put together and it works a treat. If I have a worry about the solution it is that if anything happens to the Things On Edge company my Cricket sensor turns into a tiny paperweight - because the only way to configure the sensor is via the Things On Edge server. It would be wonderful if the whole configuration process could take place on the Cricket itself via the same web interface that it generates when you setup the WiFi connection.
Anyhoo, that’s day 3. On to day 4 when I’m going to make a little box to put the sensor in….
The complete system
I’d rather like to be able to monitor the temperature around the house. The heating system tells me the temperature but I’m not sure what this means when I’m sitting in the living room several feet away from the radiator. I’m also keen to test something I got a while back. It’s called a Cricket and it is tiny microcontroller that is specifically designed to do just what I want, which is read the temperature every now and then and send it onto the network. I want to have a battery powered sensor and want the batteries to last forever-ish.
Previously I’d be looking at LoRa (Low Powered Radio) devices to do this but they are a bit complicated to set up. The Cricket claims to give you LoRa style battery life with WiFi connectivity. I should be able to power it from a pair of AA batteries for a good long time. The Cricket achieves this by optimising the time that it takes to connect to the network and send a data packet. It seems to take around four seconds to do this, which is pretty impressive. It has one input for sensing data and another for triggering a transmission. It also has a real time clock which can be used to trigger updates. And there is an onboard temperature sensor which I can use to get my readings.
Once you’ve soldered (badly in my case) the battery pack to the Cricket you then have to attach it to your WiFi. This is done in the “traditional” way of WiFi devices. Hold down a button to trigger Access Point mode, browse to the WiFi hotspot that the device has just created, open up a web page there and enter your WiFi SSID and password. Then you have to configure your device to tell it what data to gather and where to send it. You might think that you’d do this on the device but no, you do it via a browser. Each Cricket has an unique ID on a label on the back. You log into the developer portal, find your device by its name and then use a web interface to configure it.
You can configure the real time clock to wake up the sensor in time measured in hours, minutes or seconds. You can also use a digital or analogue input to wake the sensor up and make it send a reading. The reading can be sent as an HTTP Post to a web address or you can use MQTT. Things On Edge provide their own MQTT server or you can use your own. I’m going to use theirs.
The idea is that you enter your settings into the web page, press Save and then press the button on the sensor to make it connect to the server, upload a value and then check for new settings. This took a bit of fiddling for me, but eventually I made a sensor that wakes up every five minutes and sends a temperature reading.
Above you can see the display from the MQTTBox program on the PC showing that temperature readings are being sent up to the server. Next I need a device to get those values and display them. But that’s a job for tomorrow.
Hull Makerspace are having a Maketober event. I found out about it this afternoon. The idea is that you do a different make for every day the month of October. I’m going to have a go and see how far I get. I’m going to set up a GitHub repository and fill it up with the silly things that I make.
Above you can see a screenshot of today’s effort. It’s a tiny demo of a JavaScript physics engine that I’ve been meaning to play with for a while. That’s the beauty of things like this event. They force you to actually do something. You can play with the program here. It might prove the basis of a little game or two.
Richard Osman is a very clever bloke. He’s known in the UK for various quiz shows and whatnot, but now he’s written a book. And it’s really, really good. It’s about murder and amateur sleuthing. There are dead bodies, confused coppers and clues galore. It’s a really enjoyable read. And I didn’t figure out who dunnit, despite being convinced at various points in the text that I was on the right track. If you like your sleuthing gentle and very English then you’ll love this.
In the unlikely event of you being allowed out of your house in the near future, and the even more unlikely event of the weather being nice enough to make it worth going anywhere, you could do a lot worse than go down to Burnby Hall in Pocklington near York. They’ve taken great care to make sure the place is Covid safe and the food in the restaurant is lovely.
These are the notes for my chat about current affairs for Radio Humberside this morning. I thought I’d do a Tech Roundup and make the notes into a blog post…..
Amazon are launching a tiny home security drone that can fly round your house to check that you haven’t left the gas on. It comes in its own cute recharging stand and you can teach it the way round your house. I can think of a few problems.
You’ll have to leave all the doors open so that it can make its rounds.
You’ll have to be OK with a mega corporation being able to look around your home. Although Amazon say that they are not going to keep the recordings I can forsee a time when you get emails with titles like “Replace that ugly woodchip in your living room…..”
Who on earth is going to need it in a time when we aren’t really allowed to leave the house?
This is a brave time to be launching new games consoles but both Microsoft and Sony are in the midst of doing just that at the moment. Perhaps the calculation is that if nobody can go anywhere they are going to put a premium on having the best home entertainment possible. But they seem to be going about it in the most confusing manner possible. Sony “stealth sold” their new machine by putting making it available a while before they said it would be and Microsoft have chosen a name for their machine that is so close to that of their previous console (Xbox Series X vs Xbox One X that quite a few people seem to have bought the old machine by mistake.
The good news is that the new consoles offer graphics and sound which are astonishingly realistic and also have so much power that they will make creating truly immersive experiences much easier and cheaper for developers. It is also interesting to see how they are moving into a subscription model, Microsoft will give you a shiny new console and access to all their games for around thirty pounds a month, which sounds like a pretty good deal to me. Although I’m still spending too much time with Animal Crossing on my Nintendo Switch to get the best out of these new devices.
Microsoft has done something that I think only a company with its vision and resources could. It has made a program that is genuinely revolutionary. They’ve built a Flight Simulator which is as big as the world. They’ve taken map data and aerial photographs for the whole of the globe and put it on their servers. Then they’ve added Artificial Intelligence that infers the shape of buildings from the overhead photographs and built servers that can stream this data into your computer as you fly around the planet. You can stick a pin anywhere in the world map and take off from there. The program includes pretty much every airfield on earth to land on.
The realism is astonishing. You get fantastic fluffy clouds and even rainbows. It’s a social game too. You can meet up with friends and take a spin around London, or New York, or Mont Blanc, or Chernobyl. It’s all there. Some of it is quite as you might expect though because the AI doesn’t always create the right buildings. Buckingham Palace is an office block. And at the moment Hull is missing a proper Humber Bridge (see above). You’ll also need quite a pricey PC and a fast network connection to get the best out of it. But it is going to totally change the way we regard video games. If indeed it is a game at all. There is so much detail that you some folks reckon that you almost learn to fly from the program. And I’ve been surprised how much fun it is to go flying with a bunch of friends.
One piece of great news for Hull residents is the fact that we have some of the best networking in the world, which makes heavily connected games like this really sing. In the future more and more experiences are going to be supplied over fast network connections and the KC LightStream service works a treat for this.
The game Among Us has been out for a while. But recently it has been riding high on the Twitch game servers. 1.5 million simultaneous players, Developers Innersloth have been working on a sequel but they’ve now stopped because the original game is so popular that they want to spend time developing that instead. I’ve had a go at playing it, and it is well worth a look for anyone into social mayhem.
If you’ve ever fancied having a sewage pump as a ringtone you can now live that dream. The BBC has released that, and lots of other sounds, for anyone to use. I wrote about this earlier here.
Sometimes, way back in the past, software writers set massive traps that we still fall into today. Like when someone at Microsoft wanted to make MS-DOS seem different to Unix so they used backslash “\” for filename separators rather than forward slash “/”. Or that other time, when someone else (or maybe the same person - who knows) thought it might be a wizard wheeze to make MS-DOS not care about the case of filenames so that Fred and fred were regarded as the same file.
This piece of genius still haunts us today. For example, when you put the web pages that you tested on your PC up onto GitHub and then find that they don’t work because you’ve said “tomato.png” in the code and the file is called “Tomato.png”.
Now, we’ll gloss over the stupidity that caused the file to be called “Tomato.png” in the first place - mainly because that is my stupidity. Let’s focus on how hard it is to fix. If you rename the file on your PC (which is hard enough because you can’t just rename Tomato to tomato - you have to go Tomato->temp->tomato) GitHub doesn’t see this change in filename name as a change in your project and so it won’t push the changes into the server. I could change the filename to “Tomato.png” in the program code, but all my other files start with a lower case letter and I’m loth to be inconsistent. I do have some pride left.
In the end I’ve fixed this by changing the name of the image file to “redtomato.png” which does reflect a change and also makes the game futureproof in that if I fancy adding some blue tomatoes later I now have a naming convention I can use.
If you’re not sure why I want to have tomatoes in my game take a look here. See what kind of high score you can get. My maximum so far is 740.
Rob Miles is technology author and educator who spent many years as a lecturer in Computer Science at the University of Hull. He is also a Microsoft Developer Technologies MVP. He is into technology, teaching and photography. He is the author of the World Famous C# Yellow Book and almost as handsome as he thinks he is.
Begin to Code with JavaScript is now available for purchase and download. You can find it here
