Windows Can Only Be Installed on GPT Disks

July 4, 2020 at 1:53 pm (computers) (, , , )

This is another one of those “better write it down now I’ve found it out” posts.

I had to reinstall Windows 10 on a family computer but it had some weird partitioning on the hard disk and when it came to running the Windows installation CD, after going through the “custom”/”advanced” setting and seeing the partition layout, no matter what I tried I could get it to recognise any of the partitions.  It kept coming back with “Windows can only be installed on GPT disks”.

After a bit of Internet searching, it turns out that UEFI bootable computers (most modern ones) require a GPT partitioned disk for the operating system and for some reason this PC had older style “MBR” disks (weirdly, the ones I’ve tended to deal with most in the past).  To get to the point where I could install thus required the following.

Boot from a rescue disk or the recovery (“repair”) option from the installation disk into the command prompt.  Run the “diskpart” tool.  This allows you to muck about with the disk partitions properly now.

WARNING: Changing anything here means you WILL LOSE DATA! Make sure you know what you are doing and you only lose the data you are expecting to lose.

Things to watch out for:

  • Is there a manufacturers recover partition or area that you mustn’t clear out?
  • Is there a specific UEFI area with crucial drivers that your PC will need?
  • And of course, all your user data will be on your system partition, so if you clear it out, there goes your user data too – so it will need to be backed up elsewhere.

Within diskpart, the following commands are the kind of thing needed to get you where you need to go:

list disk
select disk
list partitions
convert GPT

This should then give you a blank GPT ready disk on which you can go through the installation process again and have it recognised properly.



Permalink Leave a Comment

Alesis Multimix 8 USB FX Timeout Error 0x0005

June 25, 2020 at 4:28 pm (computers, moan, music) (, , , )

This is another one of those “lots of people must have found this error but no-one seems to know the answer” queries…

We’ve acquired an Alesis Multimix 8 USB FX mixer with a USB interface to the PC.  If you just plug this in, it is found by Windows and all is good.  But there is a driver on the Alesis website which implies there is additional functionality.

However, when you try to install it you get a “Timeout Error 0x0005” half way through, and this seems pretty common on the Internet, but suggested fixes involve uninstalling, registry cleaners, and all sorts of mucking about which could easily lose you an afternoon.

Except no-one seems to mention that there are two Alesis Multimix 8 USB FX mixers – the USB FX and the USB 2.0 FX.  The former (that we have) does not require a driver, it seems to stream a single audio channel to the PC using the standard Windows drivers with no additional installation required.  The latter, does require a driver, as I think it can stream the different channels independently to the PC.  By the way, if you have the USB 2.0 FX it is strongly recommended that you don’t plug it in until you install the driver and it asks you to.

Now quite why the developers couldn’t have spotted this on installation and pop up a nice friendly “Hey, looks like you’ve plugged in the confusingly similarly named Multimix 8 USB FX which doesn’t need a driver” I don’t know.  Instead the installation is left looking for the USB 2.0 FX, which quite naturally doesn’t exist, so it simply times out.

So, if you get this error – make sure you are using an Alesis Multimix 8 USB 2.0 FX which needs a driver – and not the Alesis Multimix 8 USB FX which doesn’t.

I haven’t looked into the difference between the two in detail, so if you are planning on buying one, it would be worth having a look to see if you need the USB 2.0 FX or the USB FX.


Permalink Leave a Comment

MiniMO Compatible 4-Pot ADSR

May 21, 2020 at 12:18 pm (computers, maker, music) (, , , )

I’ve been enjoying having a play with the MiniMO synth, now I can programme it easily, but although I seriously like the idea of a piece of common hardware with software-defined synth personalities, I just found the ADSR with a single potentiometer just too limiting and not responsive enough for trying things out.

So I’ve sacrificed the common hardware and created a MiniMO compatible (i.e. based on the same circuit and code) 4-potentiometer ADSR instead.  To continue to use an ATtiny85 though requires a few compromises:

  • There is no button or LED.
  • There is no CV input to control the ADSR parameters (although this could be added).
  • The pots are always “live” – changing them will instantly change the parameter they represent.
  • And I needed to reclaim the ATtiny85 RST pin (pin 1) as an I/O pin.

If you are familiar with the ATtiny85 you’ll know that there is a fuse setting that will disable its response to the RST signal on pin 1 allowing you to use it as an additional I/O pin.

But you will also therefore probably know that this means you can no longer program it using the normal methods!  Once that fuse is set the only way to get back into your device is using a High Voltage Serial Programmer (HVSP).  There are a number of designs around the Internet for these and I’ve build some of them myself so can confirm they work.  The one I tend to use is a variation on this one with both 8-pin and 14-pin sockets, driven by an ATtiny2313 and some tweaked code to act as a “fuse resitter”.  I’ll perhaps post about that at some point.

You can’t set the RSTDISBL fuse from within the Arduino environment, so the general procedure is as follows:

  • Set your parameters as required for your device.
  • In “preferences” enable verbose messages on upload.
  • “Burn bootloader” to set the existing fuses – this will give you the command used to set the fuses.
  • In “preferences” disable verbose messages on upload again (if you want).
  • Upload your sketch to the ATtiny85.


  • Copy the command to set the fuses and update the hfuse value to set the RSTDISBL flag (i.e. put it to zero) and run it in a command window.

Running through the above, my “burn bootloader” command looks like this:

[PATH TO AVRDUDE]/avrdude -C[PATH TO AVRDUDE CONF]/avrdude.conf -v      -pattiny85 -cusbtiny -e -Uefuse:w:0xFF:m -Uhfuse:w:0b11010111:m         -Ulfuse:w:0xE2:m -Uflash:w:[PATH TO BOOTLOADER]empty_all.hex:i

I am using a USBtiny programmer. We only want the hfuse “write” command (and really don’t want the -e option which erases the sketch in memory). You can use a ATtiny85 fuse calculator to see what the value should be – for example, see this one.

First I read back the just set hfuse value.

[PATH TO AVRDUDE]/avrdude -C[PATH TO AVRDUDE CONF]/avrdude.conf -v      -pattiny85 -cusbtiny -Uhfuse:r:out.txt

Then write the new value as calculated by the fuse calculator – RSTDISBL is the top bit of the hfuse, so for me, it read back 0xD7, so I write out 0x57 – running this command WILL “BRICK” YOUR DEVICE if you don’t have a HVSP.

[PATH TO AVRDUDE]/avrdude -C[PATH TO AVRDUDE CONF]/avrdude.conf -v      -pattiny85 -cusbtiny -Uhfuse:w:0x57:m

So with all that out of the way, this is the circuit and code I used to get a MiniMO compatible 4-potentiometer ADSR.MinoMo-ADSR2-2_schem

As I said, I’ve sacrificed some of the hardware, but the pot input stage is the same (just repeated four times), and the output and gate stages are the same as the original MinoMO design, but the output is on a different pin to free up all four ADCs. It has moved from using OC1B as the PWM output to using OC1A instead.

The code is a lot simpler as it isn’t having to handle the button and shared parameter setting via the single pot.  Instead the potentiometer values are read “live” in my version.

//*      miniMO ADSR     *
//*   2016 by enveloop   *
CC BY 4.0 Licensed under a Creative Commons Attribution 4.0 International license: // --- Kevin --- Updated to build on recent Arduino IDE with ATTiny Core from: ADSR Re-written to use four individual potentiometers and reduced inputs. Note: this sacrifices the LED output, button for input, control inputs on the pots and relies on repurposing RST as an I/O pin (see below). It also switches the output from digital I/O 4 (pin 3) to digital I/O 1 (pin 6) so that ADC4 can be used. This means switching the PWM output from OC1B on compare to OC1A. I/O 1 and 2: Outputs - control voltage (usually for amplitude) 3: Not connected - but could optionally double with the potentiometers as per the original design 4: Input - gate (note ON/OFF) Mapped to ATtiny85 I/O: --------- ADC0 - 5/A0 - PB5 - | 1 8 | - VCC ADC3 - 3/A3 - PB3 - | 2 7 | - PB2 - 2/A1 - ADC1 ADC2 - 4/A2 - PB4 - | 3 6 | - PB1 - 1 - OC1A - PWM (Output) GND - | 4 5 | - PB0 - 0 - dig I/P (Gate) --------- Map potentiometers to ADSR: ADC0 (5) - (A)ttack ADC1 (2) - (D)ecay ADC3 (3) - (S)ustain ADC2 (4) - (R)elease NOTE: To use ADC0 need to programme the fuses to repurpose RST as an I/O pin which means it is no longer possible to programme the ATtiny85 except with a high voltage serial programmer (HVSP). --- Kevin --- */ #include <avr/io.h> #include <util/delay.h> // Define Arduino pin numbers - NB: Digital and Analogue have different numbers! #define ADSR_A 5 // PB5 = ADC0 - digital I/O 5 (pin 1) is the repurposed RST pin #define ADSR_ALG_A A0 #define ADSR_D 2 // PB2 = ADC1 #define ADSR_ALG_D A1 #define ADSR_S 3 // PB3 = ADC3 #define ADSR_ALG_S A3 #define ADSR_R 4 // PB4 = ADC2 #define ADSR_ALG_R A2 #define ADSR_G 0 // Gate input #define ADSR_O 1 // OC1A output int ADSR_adc[] = { ADSR_ALG_A, ADSR_ALG_D, ADSR_ALG_S, ADSR_ALG_R }; volatile unsigned int globalTicks; //output int envelopeValue; //envelope stage control; bool readyToAttack = true; bool readyToRelease = false; const int attackLevel = 255; int currentStep = 0; int ADSR[] = { 0, //attackLength 1, //decayLength 255, //sustainLevel 0 //releaseLength }; void setup() { //disable USI to save power as we are not using it PRR = 1<<PRUSI; ADMUX = 0; //reset multiplexer settings pinMode(ADSR_G, INPUT); //digital input (gate) pinMode(ADSR_O, OUTPUT); //output (PWM on OC1A) pinMode(ADSR_A, INPUT); //analog- ADC0 - (A)ttack pinMode(ADSR_D, INPUT); //analog- ADC1 - (D)ecay pinMode(ADSR_S, INPUT); //analog- ADC2 - (S)ustain pinMode(ADSR_R, INPUT); //analog- ADC3 - (R)elease //set clock source for PWM -datasheet p94 PLLCSR |= (1 << PLLE); // Enable PLL (64 MHz) while (!(PLLCSR & (1 << PLOCK))); // Ensure PLL lock PLLCSR |= (1 << PCKE); // Enable PLL as clock source for timer 1 cli(); // Interrupts OFF (disable interrupts globally) //PWM Generation -timer 1 TCCR1 = (1 << PWM1A) | // PWM, output on PB1, compare with OCR1A (see interrupt below), reset on match with OCR1C (1 << COM1A1) | (1 << CS10); // no prescale OCR1C = 0xff; // 255 //Timer Interrupt Generation -timer 0 TCCR0A = (1 << WGM01); // Clear Timer on Compare (CTC) with OCR0A TCCR0B = (1 << CS01); // prescaled by 8 OCR0A = 0x64; // 0x64 = 100 //10000hz - 10000 ticks per second TIMSK = (1 << OCIE0A); // Enable Interrupt on compare with OCR0A sei(); // Interrupts ON (enable interrupts globally) } //Timer0 interrupt ISR(TIMER0_COMPA_vect) { //10000 ticks per second globalTicks++; } void loop() { setADSR(); triggerADSR(); } void setADSR(){ // Read one each scan if (currentStep == 2) setLevel(currentStep); // S is a level not a length else setLength (currentStep); // ADR are all lengths currentStep++; currentStep &= 0x03; } void setLength(int step) { int lengthRead = analogRead(ADSR_adc[step]) >> 6 ; //values between 0-15 ADSR[step] = lengthRead; } void setLevel(int step) { int levelRead = analogRead(ADSR_adc[step]) >> 2 ; //values between 0-255 ADSR[step] = levelRead; } int checkGATE() { return (PINB & (1<<ADSR_G)); } void triggerADSR() { // Check the Gate input if (checkGATE()) { if (readyToAttack){ readyToAttack = false; readyToRelease = true; readADS(); } } else{ if (readyToRelease){ readyToAttack = true; readyToRelease = false; readR(); } } } void readADS() { int attackLength = ADSR[0]; int decayLength = ADSR[1]; int sustainLevel = ADSR[2]; //ATTACK if (attackLength == 0) OCR1A = attackLevel; else { globalTicks = 0; for (envelopeValue = 0; envelopeValue <= 255; ){ OCR1A = envelopeValue; if (globalTicks >= attackLength) { envelopeValue++; globalTicks = 0; } } } //DECAY globalTicks = 0; if ((decayLength == 0) || (sustainLevel == attackLevel)) OCR1A = sustainLevel; else{ if (sustainLevel < attackLevel){ for (envelopeValue = attackLevel; envelopeValue >= sustainLevel; ){ OCR1A = envelopeValue; if (globalTicks >= decayLength) { envelopeValue--; globalTicks = 0; } } } } //SUSTAIN --nothing to do, we keep the last value until the "note off" trigger } void readR() { int sustainLevel = ADSR[2]; int releaseLength = ADSR[3]; //RELEASE if (releaseLength == 0) OCR1A = 0; else { OCR1A = sustainLevel; globalTicks = 0; for (envelopeValue = sustainLevel; envelopeValue >= 0;){ if (checkGATE()){ //if during R stage there's a trigger, silence and exit OCR1A = 0; return; } OCR1A = envelopeValue; if (globalTicks >= releaseLength) { envelopeValue--; globalTicks = 0; } } } }

I made one up and am pretty pleased with the results!

2020-05-21 13.10.52



Permalink Leave a Comment

ATtiny85 VGA Sync

May 3, 2020 at 8:52 pm (computers, maker, Uncategorized) (, )

I’ve been reading Ben Eater’s inspiring series on producing a VGA video output from breadboards containing basic logic gates implementing counters, so wanted to see for myself how to create the timing signals for a VGA output.  There are loads of tutorials for how to produce VGA using an Arduino, with the main source appearing to be from Nick Gammon.  So for the sake of variety, I decided to see how it might work on an ATtiny85 (although naturally, many have also been there before too).

I’ve only implemented the sync signals to see if a monitor would recognise my signal.  I might see if I can get some data out at some point at some relatively low-level resolution.

The key decision is all centred around what clock frequency the ATtiny can support and how that relates to VGA video timings.  After a bit of messing around with a calculator, I settled on the following:

VESA Signal 640×480 @ 75 Hz and used the 64 MHz PLL clock mode of the ATtiny85 using a /8 prescaler – so a 8MHz clock, with each “tick” being 0.125uS.

So taking the timing values from the above linked tinyvga site, and translating that to “ticks” gives:

Scanline Pixels Time (uS) ‘Ticks’ @ 8Mhz
Visible Area 640 20.31746031746 16.546
Front Porch 16 0.50793650793651 4.063
Sync Pulse 64 2.031746031746 16.254
Back Porch 120 3.8095238095238 30.478
Whole Line 840 26.666666666667 213.333

Naturally there will have to be some rounding – I won’t be able to get fractions of a “tick” out of the ATtiny85 Timers.

This all rounds up to using the ATtiny85 Timer1 in PWM mode providing an output on OC1A to provide the H_sync pulse, then manually counting lines in the overflow interrupt routine to manually drive the V_sync pulse.

I originally wanted to use OC1B which made the pin assignments on the ATtiny85 much simpler, but ended losing an afternoon attempting to work out why I was getting no signal on OC1B. Turns out there is a bug in the ATtiny85 Compare on B for Timer1 – the compare mode bits in GTCCR are ignored unless the same bits are set for Compare on A in TCCR1.  Having found reference to this on the Internet, this kind of sounds familiar so I’m wondering if I’ve fallen foul of this before! Anyway, OC1A it is.

Pin assignments are as follows:

  • H_sync = PB1 (pin 6) OC1A
  • V_sync = PB4 (pin 3)

And the Timer1 settings are as follows:

  // Run a timer interrupt off a 64 MHz clock
  PLLCSR |= (1<<PLLE);            // Enable 64 MHz PLL clock
  while (!(PLLCSR & (1<<PLOCK))); // Wait for the PLL lock
  PLLCSR |= (1<<PCKE);            // Enable PLL as source for Timer 1

  // Timer 1 for CTC mode; set on compare with OCR1A; overflow interrupt
  TCCR1 = (1<<CTC1) |                // Reset on match with OCR1C
          (1<<CS12) |                // Prescale /8
          (1<<PWM1A) |               // PWM mode
          (1<<COM1A1) | (1<<COM1A0); // Set OC1A on compare; clear on rest
  GTCCR = 0;
  OCR1A = 15;
  OCR1C = 218;

There was some experimentation required to adjust the timings from the theoretical 213 ticks – 218 seems to give the most accurate horizontal sync frequency for some reason.  I haven’t done the maths to see why.  I was assuming I’d use 213 with a possible “leap tick” required every now and again to account for the lost 0.333 ticks to keep things in check, but turns out this worked ok for me instead.

Note that VESA 640×480@75Hz requires negative pulses, hence using “Set on Compare” rather than “Clear on Compare”.  Some modes require positive pulses so this would have to change.

The rest is just counting lines for the vertical refresh (using the line timings from tinyvga: 480-1-3-16=500), which is all done using the Timer 1 overflow interrupt, which signals the end (or in my case, start) of each horizontal line.

The final code is shown below, and sure enough, hooking this up to a monitor does indeed bring up the required mode to be recognised.

Next up, I’ll have a think about sending some data over.  Although if I want RGB outputs, that basically uses up the rest of the ATtiny85 I/O pins. That is an experiment for another day.


// Use a ATtiny85 to output a VGA signal using
// its 5 output pins
//    (RST) ---------- | 1   8 | --------- (Vcc)
//    V_sync -- PB3 -- | 2   7 | -- PB2 -- R (0-0.7v)
//(0-0.7v) G -- PB4 -- | 3   6 | -- PB1 -- H_sync
//    (GND) ---------- | 4   5 | -- PB0 -- B (0-0.7v)
// NOTE: Wanted to use OC1B but there seems to be a bug in many ATtiny85 that
//       means that OC1B doesn't work properly unless OC1A has the same mode.
//       Consequently, using OC1A on its own to serve the purpose required.
// Note: Use ATtiny85 PORTB numbers
#define H_SYNC 1  // OC1A
#define V_SYNC 3
#define VGA_R  2
#define VGA_G  4
#define VGA_B  0

// Basic operating principle:
//  Timer configured to automatically create the H_sync pulses by using Timer 1
//  compare values.  H_sync needs to drop negative for a short pulse at the end
//  of each line.
//    <----- H pixel display ------><HFP><H_sync><HBP>
//  Or alternatively:
//    <H_sync><HBP><----- H pixel display -----><HFP>
//  Use Timer 1 to signal frequency of H_sync based on OCR1A.
//  Use Timer 1 OCR1A to specify duration of H_sync.
//  So attach H_sync signal to OC1A output.
//  Configure OC1A output as Clear or Set on Match as required
//    V_sync pulses are created by counting horizontal lines.
//    V scanning will be in one of the following modes:
//         In Display Area - hence H-scan is drawing pixels
//         In V front porch or back porch areas
//         In V_sync area
// VGA Timing Modes are taken from:
// Based on the option of a 64 Mhz timing signal, choosing VESA 640x480 @ 75Hz
// gives us the following timing parameters
//     Screen refresh rate = 75 Hz
//     Verticle refresh    = 37.5 kHz
//     Pixel frequency     = 31.5 MHz
//     Timings are as follows
//      H visible area        640     20.31746031746 uS
//      H front porch          16      0.50793650793651 uS
//      H sync pulse           64      2.031746031746 uS
//      H back porch          120      3.8095238095238 uS
//      Total H line          840     26.666666666667 uS
//      H pulse is negative.
//      V visible area        480     12.8 mS
//      V front porch           1     0.026666666666667 mS
//      V sync pulse            3     0.08 mS
//      V back porch           16     0.426666666666667 mS
//      Total V frame         500     13.333333333333 mS
//      V pulse is negative
//  Using 64MHz PLL Clock as source for Timer 1 and setting Prescale to /8 gives
//  a frequency of 8 MHz and a single "tick" of 0.125 uS.
//  Total horizontal line timing is thus 26.666666666667/0.125 = 213.333 "ticks"
//  use 212 for OCR1C to define the line duration (same as the Timer 1 period).
//  At this resolution, H_sync is 2.031746031746/0.125 = 16.254 "ticks"
//  so use 15 for OCR1B to define the H_sync pulse.
//  As the required pulses are negative, need to use Set on Compare Match.

int V_Sync_Line;

void setup() {
  // Configure Output I/O pins
  PORTB = 0;
  DDRB = (1<<H_SYNC) | (1<<V_SYNC);

  // Run a timer interrupt off a 64 MHz clock
  PLLCSR |= (1<<PLLE);            // Enable 64 MHz PLL clock
  while (!(PLLCSR & (1<<PLOCK))); // Wait for the PLL lock
  PLLCSR |= (1<<PCKE);            // Enable PLL as source for Timer 1

  // Timer 1 for CTC mode and set on compare with OCR1A and overflow interrupt
  TCCR1 = (1<<CTC1) |                // Reset on match with OCR1C
          (1<<CS12) |                // Prescale /8
          (1<<PWM1A) |               // PWM mode
          (1<<COM1A1) | (1<<COM1A0); // Set OC1A on compare; clear on rest
  GTCCR = 0;
  OCR1A = 15;
  OCR1C = 218;  // Experimentation shows this is the best value

  // Enable Overflow Interrupt
  TIMSK = (1<<TOIE1);

  V_Sync_Line = 0;

void loop() {
  // put your main code here, to run repeatedly:

// Timer 1 Match with OCR1A interrupt
ISR (TIMER1_OVF_vect) {
   // Triggered every H_Sync line
   // It automatically outputs the H_Sync pulse, so need to complete the line:
   // <---- H line Pixel output ---->
   // From timings,  is approx 5.8 uS i.e. approx 23 ticks
   // So read the timer register and ensure it is > 23
   while (TCNT1 < 24) {};

   if (V_Sync_Line <= 479) {
      // Visible line output
      // todo next!
    } else if (V_Sync_Line == 480) {
      // V Front Porch
    } else if ((V_Sync_Line >= 481) && (V_Sync_Line <= 483)) {
      // V Sync Pulse
     PORTB &= ~(1<<V_SYNC);
   } else { // 484 onwards
      // V Back Porch
     PORTB |= (1<<V_SYNC);

   if (V_Sync_Line >= 500) {
     V_Sync_Line = 0;

Permalink Leave a Comment

Programming a MiniMO Synth

April 19, 2020 at 12:03 pm (computers, maker, music, Uncategorized) (, , )

I’ve been playing with a home-grown version of the MiniMO synth as the creator has very kindly put the designs out into the public domain.

But a key issue with programming the ATtiny85 devices used in the synth is incompatibility with the latest versions of the Arduino IDE and the SpenceKonde ATTiny85 core that is now easily installed within it.

Warning: The official advice is still to build using Arduino 1.5.7, so treat all this as unverified and experimental.

I did have a look at this in the past and the issue seems to be one of incompatible timers, that I’ve described before.  The MinoMO uses both timers of the ATTiny85, but by default the core assumes the use of Timer 0 overflow interrupt for the delay/millis function, but several of the programmes for the MiniMO also want to use the overflow interrupt.

Expanding on the solution described in my previous post  – if we are assuming an 8-bit timer then it will overflow at 255, so setting the compare-on-match to 255 should have the same effect, but generate the TIMER0_COMPA_vect interrupt instead (at least for the mode being used here).

However, there is one caveat to all this.  The MiniMO synth code (I’m looking at the DCO code right now) sets the following parameters for Timer 0:

  //Timer Interrupt Generation -timer 0
  TCCR0A = (1 << WGM01) | (1 << WGM00); // fast PWM
  TCCR0B = (1 << CS00);                // no prescale
  TIMSK = (1 << TOIE0);                // Enable Interrupt on overflow

As far as I can see the original use of Timer 0 in the ATTiny Core is Fast PWM but with a prescalar value of 64.  Changing it to no prescale value here means that the “tick” used for the delay and millis functions is now running 64 times faster than previously assumed.

I’m guessing the author had the same issue in the original code though (although presumably with the settings for Timer 1), as in almost all other cases he uses the library function _delay_ms() rather than the Arduino function delay() or millis() – there is one exception – a couple of functions called on power-up prior to changing the timer values, which use the Arduino delay() function.

So from what I can see for the few programmes I’ve used with the MiniMO so far, I believe this is probably the only thing that needs changing if programming your own from the latest Arduino IDE and SpenceKonde ATTiny85 Core.  At least, on manual review of the code so far, I’ve not spotted any potential issues with having delay() and millis() running too fast!  But this isn’t an extensive review, and I repeat, the official advice is still to use an older version!

I don’t have an original MiniMO to compare waveforms to see if all the timing appears correct or not, but so far, I’ve been able to calibrate the frequency of the DCO (required as my ATTiny85 had no pre-set values stored in EEPROM), change waveforms, and see all three frequency ranges.

The fuse settings I used (as detailed by the menus in the SpenceKonde Core for ATTiny85 and then set using “burn bootloader”) were:

  • 8 MHz Internal
  • B.O.D disabled
  • EEPROM not retained (removes calibration data on re-programming)
  • Timer 1 Clock = CPU
  • LTO = Enabled
  • millis = Enabled

Which translates over into the following fuse settings:

  • efuse: 0xFF
  • hfuse: 0xDF
  • lfuse: 0xE2

I’d really like to know if anyone can compare the waveforms and frequencies generated by an original MinoMO DCO with one programmed with the above to see if they are the same.  Either way, for me I have a functioning unit, programmed using a current version of the Arduino IDE and ATTiny85 support and look forward to trying some of the other programmes for it too.

Of course, a massive thanks to Jose of course for putting the designs out there for experimentation like this in the first place.



Permalink Leave a Comment

Acer Iconia W510 Windows 8.1 Reinstall

September 8, 2019 at 1:59 pm (computers) (, , , , )

Not quite sure why I’m persevering with this one, but it is quite a nice machine!  But as I mentioned last time, it is full and has stopped updating.  So time has come to re-install and conventional wisdom on the Internet seems to think that I won’t get anywhere putting Windows 10 on it, so Windows 8.1 re-install it is.

First problem though – I’d forgotten the admin password – doh! (actually I’m sure I wrote it down somewhere and made a Win 8.1 install disk – but I seem to have lost them both!).  Thankfully a local user account is still functioning and it would appear that from a local user account you can still invoke the start-up options to refresh (i.e. re-install) the computer.  So I did.  Which is good as it is almost impossible to invoke the rescue options any other way.


  • Windows 8.1 32-bit (English) Installation Media – get it from here:
  • USB DVD Drive (I burnt the ISO to a disk).
  • USB keyboard, mouse and ethernet adaptor (you’ll see why in a moment).
  • Micro USB connected (in my case via an adaptor) USB hub for the above.

On reinstallation of Windows from the ISO it doesn’t recognise the dock, touch screen or Wifi so I have to use a USB hub via the tablet’s built-in micro-usb port to connect up a keyboard, mouse and USB ethernet adaptor to get online.

There is a driver package on the Asus website that covers everything:

It is quite scary to run though as you get a very DOS looking type update programme running on restart and I’m pretty sure it is updating the UEFI BIOS somehow.  Still, once installed and restarted it was all running fine again.

But I instantly hit the same problem with Windows Updates as when I first got the machine, which I documented here.  Basically there is a problem with the Windows Update programme, and to fix it Microsoft helpfully suggest installing KB3102812 using, you guess it, Windows Update!

On examining the files already installed it looks like the Win 8.1 ISO has all the right files to have included the prerequisites for installing KB3102812 – I checked the version numbers of a few.  It also seems to list under “update history” the April 2014 cumulative update, so I simply downloaded and installed KB3102812 myself by hand as detailed in my previous blog post.  Of course, what would have been immeasurably more useful would be for the ISO to include at least up to the point of the fixed Windows Update!  Oh well.

  1. Download of the update for KB3102812.  The 32-bit download is here:
  2. Open a command prompt as Administrator then extract and install:
cd \Users\me\Downloads
mkdir temp
expand -f:* “Windows8.1-KB3102812-x86.msu” temp
cd temp
start /w Pkgmgr /ip /

At this stage nothing seems to happen for a while, then you get a message box saying Pkgmgr is deprecated, but do you want to restart now? On restart you get the standard Reconfiguring Windows Update type messages and then Windows starts.

At this point we can run Windows updates normally. In my case several times to get everything up to date again.

The final step was to create a system image of the new, clean Windows 8.1 machine.  But the option to do that is quite hidden, but still there somewhere.  Basically it is hidden away under FileHistory – but not the Windows 8 PC Settings File History – you have to go to the original Control Panel -> File History, then there is an option at the bottom of the left hand panel for System Image Backup.



Permalink Leave a Comment

More Windows (8) Update Woes

August 11, 2019 at 10:09 am (computers) (, , , )

That really nice Acer Iconia W510 tablet that I had such fun with before has started playing up again.  It isn’t clear from the wisdom of the Internet if I could put Windows 10 on it or not, but I did wonder if it was worth seeing if the free update was still working or not.  I haven’t yet, but the Windows 8.1 updates seem to have stopped again and I get a range of errors popping up, 0x800F0831 seems a favourite this time.  Apparently this isn’t in the list of common corruption errors, but, well, this is Windows, so who knows!?  It seems to be related to some kind of mismatch in applying updates.

I did wonder if it was getting too full (there is only 32GB onboard storage, and only around 1GB free) and so managed to get itself in a mess.  This post is by way of documenting some of the more useful suggestions I’ve found online for dealing with Windows update issues as I’ve tried to sort my issues out.

There does seem a ‘standard’ but complicated procedure for resetting Windows update (assuming the built-in troubleshooting doesn’t do any good).  There are two helpful Powershell scripts available here that can do all this for you, alongside details of all the manual steps involved too.  The only issue I found was that I had to temporarily change the signed execution policy to allow them to run.

In a “run as administrator” Powershell prompt, I had to do:

Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process

Before running the script.  The slacking of policy should only be temporary (unlike some other suggestions I’ve seen which change it permanently).  Once the script has run, a reboot is required to kick everything off again.

Still no go for me though. Next up is some advice about using the tools sfc and dism – that’s the “system file checker” and “deployment image servicing and management” tools.  Full details of what they do can be found here and from Microsoft here, but the summary is:

sfc /scannow
dism.exe /Online /Cleanup-image /Scanhealth
dism.exe /Online /Cleanup-image /Restorehealth

That will do some basic checks of the running system image (sfc); check the health of the  running instance (dism /Scanhealth) and then repair it if required (/Restorehealth) using the online Windows Update servers as the reference source material. Nothing says this, but I assume you need to run sfc again after the two uses of dism, otherwise I’m not sure what the actual point is!  The /Online means “target the running operating system” rather than an actual file or other partition containing a non-running Windows image.

By the way if dism gets stuck at 20% or 40% apparently this is quite common – you’ll have to wait it out.  Eventually it will jump to 100% complete.

If your system is too corrupt then it looks like you can use dism from a working Windows installation to repair the image of a broken one or specify an alternative source of known good files if the link to Windows Update isn’t doing it for you.  I downloaded the 32-bit Windows 8.1 installation ISO from the MS download site and then dropped it onto a USB memory stick so it can be mounted from the tablet.

To specify a new reference source, use the switches /Online /Cleanup-image /Restorehealth /Source to specify a known good source of files.  You need to point to \sources\install.wim from the mounted ISO image.  It is also worth using /LimitAccess to stop it phoning home to Windows Update and using the Windows Update client.  More details again here.

It may be that this would have helped my Windows 10 boot problems I described before.



Permalink 1 Comment

Surfing on Entropy

March 21, 2019 at 10:28 am (art, computers, music) (, , , )

I was passed a link to this interesting comment from Brian Eno: “There is not enough Africa in computers” (thanks Richard).

I’ve now read this a couple of times and was still left wondering quite what lay behind the comment.  So I tried to find the original interview between Kevin Kelly (then editor of Wired I believe) and Brian Eno so I could read it in full.  Unfortunately it isn’t on the same link anymore, but with some googling, you can find it in the Wired archive here.

There are a number of really fascinating discussion points – I really recommend reading the whole article – and it provides the context for that isolated quote. I did find some of the answers a little contradictory at times though.

A disclaimer, to date the music and views of Brian Eno seems to have passed me by, so these comments start with this interview in isolation. I look forward to seeing what he would say now and finding more about his ideas of generative music.

On the one hand I believe he is saying he doesn’t like the “set it in motion and it will perform predictably” aspect of computers – he likes the idea of providing inspiration and guiding principles that may or may not produce something depending on the live inputs of the viewer/reader/listener – he appears to like the serendipity of it all … but later on he talks of “black boxes for music” where he has set the rules and the box produces the music according to those rules, with some input from the listener depending on their mood.  The box become some combination of player and instrument if I understand his view correctly.

Right near the start of the interview, he suggests that the orchestral tradition is too constraining, but I see it as a (more limited admittedly) set of programmable components ready to do the composer’s bidding.

When you look at how the orchestra developed from Mozart’s time through the Romantic period, contrasting those early Classical period works with Beethoven, Brahms and then the later large scale deployments of Mahler, there is quite a lot of scope for variability there and the basic “machine” evolved enormously through that time. Then when you look at what Stravinsky did in his ballet music or what Debussy did with his completely alternative view of harmony through to the likes of Messiaen recreating birdsong in his Turangalia symphony (including incorporating the electronic Ondes Martinot), then as a “programmable box” an orchestra is actually quite a versatile person/machine system in action.

I guess he doesn’t like the idea that a composer sets the rules and the orchestra is then condemned to just reproduce them.  But I wonder what he thinks about jazz and improvisation? Good jazz still follows rules, but every performance is different. But it isn’t random. Is a jazz ensemble “more Africa” than an orchestra?  Or maybe it is a matter of the illusion on unpredictability.  When I look at something like the Long Player – that is a key set of rules, and you exactly determine what the music will be at any point – but the cycle is so long (designed to last a thousand years) that every time you dip into it, you don’t really know what you will hear.  Or at the other end, is John Cage’s As Slow as Possible where you can go back after several months and the music is still exactly the same.

I guess some of this relates to the difference between analogue and digital.  Digital is obsessed with chopping up the analogue reality into small measurable chunks – be that discrete frequencies that we call semitones in Western music, pixels on a computer screen, or even the digitising of the end results as a digital bit stream to be played back via audio hardware off a CD or MP3.  But even when digital and in theory part of a finite space, that space is so vast as to approximate to the entire musical repertoire or pictorial output of any artist, composer or musician (as least as far as human senses are concerned).

I’ve always been fascinated with the idea of the computer screen representing an unimaginably large single number and that counting through them all would show every possible image that screen could display.

In theory the digitisation of music could be represented the same way – if every note on the piano keyboard had a number 1 to 88, then a piece of music (forgetting rhythm for the moment) is essentially one very long base 88 number.  That’s not too dissimilar to how a pianola worked, although physical layout of the cut-outs are key here, or even MIDI in today’s world, when linked with a sense of the flow of time of course.  I remember my school having a dictionary of musical themes and it basically worked on those lines (although it only worried about a single octave, so it was essentially a 5-10 digit “base 7” number).  I’ve always wanted that book, but so far have never seen one since.

So just because things can be reduced to number and handled by computer, is that any less “Africa” than a free-flowing analogue equivalent?  I guess a key distinction is not necessarily digital vs analogue, but more pre-determined vs unpredictable.

In a weird way, fast forward these last 20 years and computers have become so complex as to be largely unpredictable to many.  Now that these already complex machines are hooked up to the even more complex global machine that is “the Internet” (by whichever definition to choose to use – remember it is just a series of tubes), then most of us would be hard pushed to be convinced by the argument that computers are things that always behave the same way based on the same inputs.

I am reminded here of Bjarne Stroustrup when he said (I believe): “I have always wished for my computer to be as easy to use as my telephone; my wish has come true because I can no longer figure out how to use my telephone.”

I’m also reminded of the fact that computers may soon be able to pass the Turing Test, not because they’ve become as smart as humans, but possible because there is a real possibility that humans are becoming as dumb as computers…

Back to Brian Eno:

“What people are going to be selling more of in the future is not pieces of music, but systems by which people can customize listening experiences for themselves.  Change some of the parameters and see what you get.”

He was after unfinished pieces of musical ideas to be combined in a new form as the listener experiments.  Of course, in a sense he was overestimating the listeners – today listeners want “customized listening experiences” but at the granularity of the song, the tune, not the musical extract or idea or concept.  And they don’t really want the effort of having to produce it themselves.  Of course they have it in droves with on-demand streaming where algorithms are “changing the parameters” on your behalf.

His ideas for evolutionary music and art may still come about, but again probably more by presaging the idea of algorithms creating music and art. But does that make the algorithms the composers and painters?  The jury is still out on that one, but he may well get his “furniture music” this way – his “ubiquitous 24 hours a day” music “infiltrating every waking moment of our lives”.

It is interesting his view on the use of machines.  He suggest we all need to be “surfing on entropy” – to be able to ride the wave of unpredictability and complexity becoming apparent.  I think that is very, very apt today, but the huge irony here being that this unpredictability and complexity has come about by the very components he considered too constrained, “not enough Africa”, now being let loose as they’ve grown more powerful and complex, on the world.

Machines are no longer doing “predictable, boring and repetitive things” – they are the very instruments of uncertainty.  We can still exert influence – by surfing the wave of complexity:

“When you surf, there is a powerful complicated system, but you’re riding on it, you’re going somewhere on it, and you can make some choices about it.”  You either ride it an use it with skill to get your own direction, or you give up and go with the flow.

There is an interesting section discussing the difference between art and science.  Art “doesn’t make a difference” – in that he means that whilst art will stimulate emotions, create large emotional experiences (e.g. watching a film) then end when the experience ends.  Of course, with today’s blended and mixed reality, is that still the case?

A fascinating read, especially with the benefit of 20 years passing in the mean time. The context might be slightly different, but many of the thoughts are still amazingly apt for today.  I’d love to know what he thinks about these thoughts again today.



Permalink Leave a Comment

Raspberry Pi Family Tree

December 8, 2018 at 10:44 pm (computers, maker) ()

There are a number of pages around listing the history of the various models of Raspberry Pi, and a few photo galleries of all models, but so far I haven’t been able to find an actual evolutionary family tree of the various boards produced to date.  So I’ve created one which will do until I find a better one.


And the images themselves were picked out from Alex of’s Raspberry Pi Family photo from March 2018:

(with the manual addition of the 3A+)

I think I’ve got the right linkages, but if not let me know.  Anything with a line across to the right hand side is still listed (at the time of writing) as a live product on as far as I can see.


Raspberry Pi Family Tree.png

Permalink Leave a Comment

Extractivism and the Anatomy of AI

November 6, 2018 at 10:20 pm (computers, interesting, science) (, , , )

I found this fascinating website – the Anatomy of an AI System – which takes an Amazon Echo and attempts to map out the behind the scenes costs in terms of manual labour, material resources, and data required to power the ecosystem.

It is particularly telling how much it focuses on the raw material impact of our modern lifestyles, which when all said and done is not unique to the Echo, but a symptom of our continued fascination with electronic gadgetry in its totality.  It has a word, that was new to me, for the way much of the impact is continually hidden from end consumers by large companies – extractivism – and attempts to bring to the fore the continued extractivism going on in support of the huge technology base being created (and in some cases just as quickly obsoleted) by large technology companies.

It uses as one example, The Salar, which is a high plateau in Bolivia that apparently contains the majority of the world’s source for Lithium, becoming increasingly important of course in our desire for mobile power (both smartphones and electric vehicles).

Another interesting example is the metaphor of “the cloud”:

Vincent Mosco has shown how the ethereal metaphor of ‘the cloud’ for offsite data management and processing is in complete contradiction with the physical realities of the extraction of minerals from the Earth’s crust and dispossession of human populations that sustain its existence.

We think of putting our data in “the cloud”, of using services in “the cloud” and all the mechanics are abstracted away, out of sight, out of mind. It is rarely that the physical realities of “the cloud” surface, expect in exceptional circumstances, usually where something goes wrong.

I would be interested in reading an update to Andrew Blum’s Tubes, updating it to make “the cloud” real in the same way he did for the also ethereal Internet itself.

Another interesting observation to come out of the study is the importance of the multiple roles of the end user:

When a human engages with an Echo, or another voice-enabled AI device, they are acting as much more than just an end-product consumer. It is difficult to place the human user of an AI system into a single category: rather, they deserve to be considered as a hybrid case. Just as the Greek chimera was a mythological animal that was part lion, goat, snake and monster, the Echo user is simultaneously a consumer, a resource, a worker, and a product.

(emphasis in the original paper).

This also comes out in the scale of income distributions – with Jeff Bezos at the top (apparently earning $275 million a day) – through US developers and workers, through overseas developers and workers – right down to “unpaid user labour” at the bottom generating the data that feeds the system and continually improves it.

The study rightly points out the fractal nature of attempting to display any of this in a linear manner on a single diagram.  Of course, each supply chain is supported by components each with their own supply chain.  Its supply chains all the way down until you reach the raw elements.

In summary I am minded simultaneously of Carl Sagan:

“We live in a society exquisitely dependent on science and technology, in which hardly anyone knows anything about science and technology.”

But seeing this complication laid bare, somewhat in defence of humanity, also of Douglas Adams (from “Mostly Harmless”):

“The available worlds looked pretty grim. They had little to offer him because he had little to offer them. He had been extremely chastened to realize that although he originally came from a world which had cars and computers and ballet and Armagnac, he didn’t, by himself, know how any of it worked. He couldn’t do it. Left to his own devices he couldn’t build a toaster. He could just about make a sandwich and that was it.”


Permalink 2 Comments

Next page »