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
clean
convert GPT
exit
exit

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.

Kevin

 

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.

Kevin

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.

THE NEXT COMMAND WILL “BRICK” YOUR DEVICE IF YOU DON’T HAVE A HVSP.

  • 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   *
//************************
//
   
Home
CC BY 4.0 Licensed under a Creative Commons Attribution 4.0 International license: http://creativecommons.org/licenses/by/4.0/ // --- Kevin --- Updated to build on recent Arduino IDE with ATTiny Core from: https://github.com/SpenceKonde/ATTinyCore 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

Kevin

 

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.

Kevin

// 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: http://www.tinyvga.com/vga-timing
//
// 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);
   }

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

Permalink Leave a Comment

Arduino and the Minimus32

April 25, 2020 at 12:08 pm (maker, Uncategorized) (, , )

I’ve had some Minimus boards kicking around for, well, since 2012 or so but they kind of lost their interest as I acquired more Arduino-compatible boards of other varieties.  But an application has recently come up that I thought might fit the Minimus so I brushed the dust off my pair of Minimus 32 boards and thought I’d see what the Internet thought about them today.  It turns out not very much – most of the information I found was back around the same time I was originally trying them out.  Can you still buy these?  I’m not entirely sure!

One thing I did find though was some information on a board package for the Arduino IDE, so I had a go at getting it running on my current installation (1.8.12).  Turns out it isn’t too bad these days – as usual thanks to the hard work of others.  Here is what I needed to get it up and running.

Key links:

After adding the following line to my list of board definitions in the Arduino preferences, and restarting the IDE, I was able to search for “minimus” in the board manager and install the package:

At this point I now have a “minimus32” and “minimus16” option to select as a board.

In order to use the Arduino IDE to download and run code, you’ll need to install an Arduino compatible bootloader onto your Minimus 32.

I used an USBasp programmer with the following connections:Minimus 32 Arduino ISP Programming

There was a problem invoking AVRDude however using “burn bootloader” – I got the following error:

java.io.IOException: Cannot run program "{path}/bin/avrdude": CreateProcess error=2, The system cannot find the file specified

Which turned out to be a problem in the platform.txt file which for me could be found here:

  • [USER]AppData\Local\Arduino15\packages\minimus-arduino\hardware\avr\1.0.2\platform.txt

in the section “AVR Uploader/Programmers tools” the following line was required before the tools.avrdude.cnd.path and tools.avrdude.config.path lines:

tools.avrdude.path={runtime.tools.avrdude.path}

On restarting the IDE it was now possible to burn the boot loader successfully. At this point, the Minimus 32 was recognised as a COM port looking like an Arduino Leonardo.

Note that the pin-out for the Minimus 32 is slightly different from the original board – see the diagram from https://github.com/pbrook/minimus-arduino/wiki.

I’ll describe my project in a further post, but for now, many thanks, as always, to Paul Brooks and Kimio Kasaka for putting this stuff together.

Kevin

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.

Kevin

 

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.

Pre-requisites:

  • Windows 8.1 32-bit (English) Installation Media – get it from here: https://www.microsoft.com/en-us/software-download/windows8ISO
  • 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: https://www.acer.com/ac/en/ID/content/support-product/4549

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: https://www.microsoft.com/en-us/download/confirmation.aspx?id=49546
  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 /m:Windows8.1-KB3102812-x86.cab

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.

Kevin

 

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.

Kevin

 

Permalink 1 Comment

3U 8HP 4 Channel Panning Mixer

July 14, 2019 at 7:01 pm (maker, music) (, , , )

As I mentioned in my last post, I used an off-the-shelf 4 channel mixer board in my synth-in-a-box, but I wanted it to be accessible as a eurorack modular panel.  I also wanted it to take mono inputs and be able to set the panning as required to the L or R channels of the mixer.  I managed to squeeze it into one of my 3U, 8HP panels.

Now I didn’t need an on/off switch, and I wanted some space to add a stereo output jack, so I removed the switch and soldered a couple of links in its place as can be seen in the bottom left of this photo.  The plan was to pass the pots through the panel and use leads to connect sockets to the inputs and output.

2019-07-09 19.17.12

The panning circuit was quite simple.  I found it in the book “Make: Analog Synthesizers” by Ray Wilson from MFOS.  In chapter 7 he describes a simple circuit to allow you to hook up your (mono) sound output to a (stereo) PC sound card. It involves a 10k pot and four 2k resistors, with the wiper of the pot connected to ground.  Full details can be found in the book.

For me, I was planning to just solder the resistors directly onto the pots and sockets and then use a short stereo cable to connect to the input sockets of the mixer.  This is all shown in the following photos (complete with my dodgy machining skills).

The four input sockets are mono of course, with the stereo input signal coming off the resistor network.  The output socket is stereo. I soldered the four resistors for each channel together first then “applied” them to the pot and socket.

Then it was just a case of adding the mixer itself and making a simple power cable from the 16-pin eurorack connector to the DC barrel jack.

I used the four knobs that came with the mixer as the pan-pot knobs, as they were nice and small.  Then I used some generic ebay knobs for the volume controls.

When it came to fixing into the rack, I ended up soldering on an additional stereo lead to the output so it can be routed internally straight to the amp.  So in normal use, the output socket isn’t needed, but I can power off the amp and use the output if I wanted to send the audio off to an external amp.

I’m really pleased with how it came out. Not bad for a $15 board and a handful of components.

Kevin

Permalink 1 Comment

Modular Synth in a Box

July 14, 2019 at 2:30 pm (maker, music) (, , , )

Inspired by Morocco Dave who built a small “almost 5U” modular synth case out of a plastic storage box, I have created one of my own.  My goal was to build something that could take Eurorack modules, so looking at around 3U high modules, so for me the best layout was a dual-rack layout with the box standing vertically as follows.

2019-06-16 15.33.08

The box is a common “9 litre” box, with rough external dimensions of approximately 40x25x15 cm.  Mine came from a local discount store.

I’ve just used a few pieces of wood for the cross-bars and covered them with some of that aluminium tape you can buy for patching up cars.  The measurements are taken from the Eurorack standards and based on the instructions from the Synth-DIY Modular Synth Cabinet Howto from MFOS, gives me around 44HP of module space.  Each module has around 10cm height of usable clearance for electronics and

I created two bus-bars following the 16-pin Eurorack power standard out of stripboard and build and connected up a PSU from Frequency Central (£10 for the PCB).  The whole thing is powered using a 12AC “wallwart” power supply via a barrel jack socket on the side.  I drilled out a grid of holes top and bottom to allow air to circulate.

In addition I created a set of USB sockets hanging off the +5V line from the PSU as some of the modules I’m using will be Arduino and similar based, being to power directly from USB will be really useful.  The PSU is probably not powerful enough for an entire rack full of modules, but the idea is to have a platform that allows experimenting and playing around with designs, so that isn’t a major issue right now.

In terms of power bus cabling, I have a whole pile of old IDE cables so I picked up a bulk set of 16-pin IDC connectors and can now make my own bus cables.  The first one was the connector shown in the first photos, linking the PSU to the two stripboard buses.

I wanted a cheap way to make panels for modules, and in the end opted for a supplier on ebay who provides 2m lengths of 2x40mm wide flat aluminium bars.  This particular supplier also included some basic cutting, so for less than £25 I’ve ended up with a whole pile of approx. 260x40x2mm aluminium panels I can cut further as required.

I just use a wire brush to give a “brushed aluminium” finish.  If you want to follow this path, look up “aluminium flat bar” on ebay, and be warned that a cheap supplier will not be giving you accurate dimensions if cutting them for you!  I know 40mm wide isn’t a standard “HP” module width, but as it is almost 8HP, its fine for me.

One thing I was particularly keen to do was have a complete “synth in a box” and by that I wanted to include some basic amplification and speakers.  I had some speakers from an old CRT TV set that seemed pretty good for their size, so then looked around for means of amplification and mixing.  Again basic modules on ebay solved this for me, and I ended up with a cheap 4-way mixer board ($14) and amplifier ($5).  The mixer is based on a NJM3414 low-voltage, high-current op-amp and the amplifier is based on a TDA7297.  Both can be powered from a 12v supply and the amplifier claims 2x15W output.

I’ve built the mixer into a panel and added some simple panning “front ends” to each input, but I’ll leave details of how I did that for another time.  For now, here is the basic case with built-in stereo speakers and amp.

Being able to just unplug the power and pick the whole thing up is great.

My physical construction skills are not particularly great.  I don’t have the patience to do a really good job, and don’t have the skills, tools or experience for anything approaching any kind of professional finish.  But for a homemade “just for me” project,  I’m really please with the results.

Kevin

 

 

Permalink 1 Comment

Next page »