PU-2: SD card capacity

I have just written a new version of the software that is used to convert a .CSV file into a Sysex file that the PU-2 can process. This version uses the SD card.

Preleminary tests show that 2000 midi commands require about 16KB of storage. So, my (very) old 16Meg SD card can store approximately 2,000,000 midi commands.

Actually, now that I’m using an SD card, the PU-2 can also display comments or command descriptions on the display. So the space on the SD card will be shared between the Sysex file and the Command Description file. I guess I’ll have to use a bigger SD card! Maybe even my (old) 256Meg card!

I now have to work on the Arduino side to process the commands from the SD card. The read speed is slow enough to introduce some latency when I do a bank switch. Also, as long as a bank (values for the 16 switches) contains less than approximately 4000 commands, I can store the command array in EEPROM. But if a bank contains more than 4000 commands, the PU-2 will have to perform direct SD reads to access the data. I could add more EEPROM. I have a batch of 128KB chips on hand. This chip could store up to 32000 commands per bank (128000 commands for a 512KB EEPROM card!). But I will test the preemptive reading of banks first. I will post the test results here.

Posted in Arduino, FCB1010, Pedal board, PU-2 | 2 Comments

SD Card reader: No Voltage required!

While testing a slight modification on the PU-2 prototype, I decided to test the current draw of the SD Card reader described in the previous post. I placed my multimeter in series with the 3.3 volt pin and measured 11 milli-Ampères. Even while reading data, the current draw was constant. I then decided to measure the current draw when using 5 Volts. I disconnected the 3.3v pin and connected the 5v pin in series, again, with the multimeter. The current draw was 0 mA.  !?

I disconnected the 5v pin and launched the reading program on the Arduino. It works. Really! The SD card reader is linked to ground, and MISO, MOSI, SCK and CS pins. NO power.

I can only guess that the SPI pins provide the necessary power to read the SD card. Here’s the schematic for this particular adapter:

Click to view larger image

Anyone has any idea? Anyone wants to try and replicate this?

Posted in Arduino, FCB1010, Pedal board, PU-2 | 4 Comments

PU-2: Data on SD card

Just in time! I received the SD card readers the day that I had planned to ship the first PU-2 Beta. I re-opened the boxes and fitted the card reader in each prototype.

This is the SD card reader that I chose:

SD card reader

It’s a generic card holder, that has the advantage of working with both 5V and 3.3V. The on-board IC is a voltage regulator that transforms the 5 Volt of the Arduino to the 3.3 Volt required by the SD card. I decided to use the 3.3v connection from the Arduino Mega board because the SD card operation requires very little current ( <50mA (safe for the Arduino)) and I will use other SPI components in the future. All the SPI components that I want to use are 3.3v. I could also have used the 5v pin and extracted the 3.3v from the card reader.

The SD card reader is connected to the Arduino with only 4 pins that are used to control the peripheral. This type of connection is explained on Wikipedia and on the Arduino site. An extra SPI peripheral will require only one more pin from the Arduino.

The card reader will let the user program the PU-2 faster. I decided at the beginning of the project that the PU-2 would not allow direct programming like the FCB-1010 on which it is based. Until now, all programming was done on a PC (or Mac (or Linux)) and a special file was created and sent to the pedal board. The input file can now be placed on the SD card and read directly by the PU-2. This will reduce the memory needed by the program to hold the data. This will soon mean that there is no limit to the total number of commands that the PU-2 can store and use.

Also, the fact that the file is now available to the Arduino means that the comment field, or description, is now available for display. The user can chose which description to post for each switch press, for each command bank. The limit is still about 3500 commands total, but I will switch the commands matrix from EEPROM to the SD card with a future version of the software.

Here’s the internals of the prototype, serial number 3, ready for final inspection.

Inside the prototype

 

Posted in Arduino, FCB1010, Pedal board, PU-2 | 1 Comment

FCB1010 vs PU-2: Why do it?

While waiting for parts (I do have to get a better inventory “system”) to complete the Betas for the PU-2, I went through a short period of discouragement. It’s hard to stay fully motivated when the project is bogged down by unforeseeable delays (or is it bad management?). But yesterday, I read an entry on the FCB1010 forum that reminded me why I was doing all this. A fellow user is trying to program the FCB1010 to communicate with a Yamaha device. The series of instruction that he had to document, after much trial and error I’m sure, goes like this:

So… to set the 1010’s bank 00, preset 3 button to access my Motif’s PRE 3
bank, patch 92, I put the 1010 in operation mode, called up bank 00 and hit
button 3 to indicate that I wanted to program that preset, then held the down
switch for 2-3 seconds.Hit the UP button to display which functions are active for the preset.For any button LED that light up besides button 5,6 & 7 (assuming that the only
thing this preset is going to do), press and hold that button down until the LED
goes out.

If button 6’s LED isn’t lit, press and hold button 6 until the LED comes on
steady.

Press button 6 again to start defining that button’s function, and it starts
flashing.

Press UP to view the current CC# the button will send.

Enter 00 (Remember, the MSB paramater is sent with CC0) as the CC # you want the
button to send and press UP to enter.

Button 6 is still flashing, and the numeric display changes to show the current
CC value. Enter 63 (the MSB value) and press UP to enter.

We’ve just defined the first CC change.

If the button 7 LED isn’t on, hold it down until the LED comes on.

Press button 7 briefly. It starts flashing, now we need to program the LSB
value.

Press UP. The numeric display flashes the current CC # for the button. Enter 32
(Yamaha accepts LSB values as CC32) and press UP to enter.

The numeric display flashes… enter the LSB value for the bank change (in my
case I wanted bank PRE 3, which the data list defined as LSB = 2).

At this stage, the 1010 preset is set up to select the Motif’s PRE 3 bank, but I
still need to tell it which actual patch I want. An old post from Michael
LaMeyer stated that only PROG CHG 5 is sent AFTER the CC’s, so…

If button 5’s (PROG CHG 5) LED isn’t lit, press and hold until it is. Press
again to begin programming PROG CHG 5, and the button 5 LED starts flashing)

Press UP and the numeric LED shows the current PC value. In my case, I want
patch 92 (of my PRE 3 bank), so I type 92 and UP to enter.

The button should now be fully programmed to select the PRE 3 bank, patch 92.

Press and hold DOWN to save and exit, and button 3 of the 1010’s 00 bank should
now select MSB 63, LSB2, Patch #92. If the device (Motif, in this case) already
happens to have that bank and patch selected, manually change the device’s bank
and patch to another patch, and hit button 3 to test.

On the PU-2 the input file for the same thing would include 3 lines:

Bank,Switch,Type,Cmd Type,Channel,Command,Value,Extra,Comment
0,3,0,CC,1,0,63,,MSB
0,3,0,CC,1,32,2,,LSB
0,3,0,PC,1,92,,,PATCH

Then run the Java utility and send the Sysex to the FCB1010.

Repeatable, savable, simple.

That switch could be programmed to send anything else, including other CC commands to have other equipment react to a press of switch 3.

Posted in Arduino, FCB1010, Pedal board, PU-2 | 5 Comments

PU-2: Last delay

As I’m completing assembly of the first of five prototypes, I decided to test the unit before putting it all into a box. Since I want the PU-2 to include a USB-Midi interface, I use the technology that I documented here. I ordered a few more Midi interfaces from a local (North-American) EBay supplier. The USB-Midi interfaces that arrived were a different design than those that I used before, but I figured that I could still modify them and incorporate them into the PU-2 box. Problem…

The USB-Midi interfaces that I received do not tolerate long Midi Sysex sequences and the PU-2 stops at 399 bytes, well short of the 3080 bytes making the PU-2 Sysex message. I tried a second one to compare. Same results. They are going back.

Now, I have to wait for the bunch of (familiar) USB-Midi interfaces that I ordered from China at the same time. They will come. I just don’t know when…

Hang on, Beta testers!

Posted in Arduino, Pedal board, PU-2 | 1 Comment

PU-2: A batch of Beta

I’m getting comfortable making the PCBs for the PU-2. This is what a batch of 5 boards looks like, fresh out of the etching tank.

I still have to drill the 800-plus holes and solder everything… patience…

This is what 10 Arduino Mega boards look like:

The main components for the Beta. I now use most of the digital pins on the Arduino. I made no effort to save pins by using external components, like 74hc595 shift registers. When I choose a micro-controller for the production version of the PU-2, I might change this. But until then, and at least for the entire Beta series, I will use this micro-controller.

The code for the Beta just reached 1000 lines. But the compiled firmware is still under 20K bytes. It would still fit in an Arduino Uno!

The first batch of Beta will ship in a few days. I’m making 6 units (one for me!). They all found a willing partner. This is outside of the funding campaign, which did not produce the results I expected. Perhaps it was too soon, or people didn’t understand what it really was for. But the project is still kind of on-track. Various delays for parts procurement and my own availability resulted in a few weeks delay on production, but that let me spend more time on new functionalities.

Posted in Arduino, Pedal board, PU-2 | Leave a comment

PU-2: Meet Beta!

The PU-2 made it to Beta.

As you can see in the picture above, the PU-2 is an external module, linked to a connecting board inside the Behringer FCB1010 with a flat cable. The reason for the external module  is that I wanted Beta testers to feel totally safe about their FCB1010. Since the current design doesn’t require any permanent modification to the FCB1010, a user can decide to remove the PU-2 and restore the FCB to its original condition. The whole process only involves unplugging cables and plugging them in a small connecting board. The transformation can be done in less than 15 minutes! The production versions of the PU-2 will probably require the removal of the FCB1010’s main board. I don’t think that I can fit the PU-2’s electronics into the FCB1010’s case without removing it. Plus, it is quite a bit more expensive to use a second connection board and a flat cable. Also, the production version might include a display that will require the removal of the original plastic display cover.

The picture shows the USB cable, providing USB Midi connectivity (core Midi) and USB programming connectivity. The USB connection also supplies the power to the PU-2. The unit can also be powered by an external source of 7-12 volts. The is a receptacle on the right side. There is a small switch next to the USB cable to choose PROGRAM/MIDI interfaces. The display is 16 characters X 2 lines. The button on the left is a rotary encoder. It is used to invoke the menu system. This allows the user to calibrate the pedals, or the contrast of the display, for example. The big flat cable connects the PU-2 to the board inside the FCB1010.

This picture shows the connecting board that fits inside the FCB1010, with all plug-and-play cables ready for connection. On the right side, you see the connecting board, or shield, that sits on top of the micro-controller in the PU-2 box.

So… you want to be a Beta tester?

The first Beta is by invitation only. You have to invite yourself! Please contact me using the email link on the right and let me know why you would like to be a Beta tester. If I get more than 5 requests, I will have to make a choice between candidates. If I get many more requests, I might make another batch of Beta kits within a few weeks.

Beta testers will receive all the necessary hardware, of course. They will also be asked to provide feedback about the functions provided by the PU-2. I will in turn provide as much support as required to make sure that the board is as flexible as possible. There is a cost involved. I just can’t front all the expenses for the hardware. Beta testers get to keep the unit if they want to, but can send it back to me for a full refund (minus shipping). Future versions of the PU-2 will be compatible with Beta hardware. It that proves impossible due to major hardware updates, I will provide new hardware free of charge.

Please feel free to ask any question in the comment section down below, or email me.

Posted in Arduino, FCB1010, Pedal board, PU-2 | Tagged , , , , , , , | 4 Comments

Making my own PCB: An exercise in frustration

I decided a few weeks ago that I would make my own circuit boards (PCB) for a while. At least for the first Beta.

I succeeded, but the time and money invested make it a very “not profitable” adventure. I had to deal with nasty chemicals, capricious sensitized copper coated boards, unfriendly software and a long process that requires a lot of precision.

This guy has a detailed page about how to go about it. In theory, the whole process is pretty simple:

  • Use a CAD software (I used Eagle)
  • Print on laser printer onto translucent material
  • Expose board to printed material (with a lot of light)
  • Develop the photo (reminded me of being a teenager learning darkroom techniques)
  • Etch (remove copper with nasty chemicals)
  • Drill holes to insert parts

Yup. That’s exactly what I did. Over, and over, and over again.

Eagle, from cadsoft.de, is extremely non intuitive. Damn! It took me days to produce anything! Maybe it’s me. It must be me. Damn!

In the end, I must admit, the software does an excellent job. It must be me…

My first few tries at printing on the laser printer didn’t go too well. The blacks weren’t black enough. They have to be opaque. I found a bunch of old inkjet transparencies in a box. I ended up printing on my Canon inkjet with very good results. I only managed 300 dpi resolution, but it was enough for my simple circuits. Mike recommends 600 dpi. It would be necessary if I was trying to get the wire traces to be 8 mil wide (0.2 mm). But I decided to use 20 mil traces (0.5 mm). I did manage to produce an 8 mil trace board, but it was not very reliable, and the traces were way too fragile.

The first board I printed was 2″ x 4″.

Yes, the traces a 8 mil. The board is slightly overdeveloped. So some of the traces are actually less that 8 mil. You can see a broken one near the middle, just left of center. That little board was cheap. $2. It required a “full noon sun on a clear day” (as the included instructions specified) exposure of ten minutes. It also required the use of steel wool to remove the photo sensitive layer before I could solder. Hence the broken trace.

I then printed 5 boards to a 6X6 pre-sensitized copper board. That board had a defect. There were bubbles in the sensitive layer. It never looked good. Then I tested a pattern on a new board, at different exposure times and different development times. I found a combination that made sense.

Success came when I started to use MG Chemical boards and products. Exposure is 9 minutes using a 15 watts standard fluorescent tube. Development time is about 4 minutes. Etching took 20 minutes.

Then, of course, I had to drill some holes. A number 68 drill bit is necessary. 0.031″, or just about 1/32 of an inch. 0.8 mm. Pretty standard hole size. The drill bit IS fragile. Yup.

You’d think that only one size hole would do, right? I had to run to the hardware store to buy a 3/64 drill bit. Number 56, at 0.465″, or 1.2 mm. I bought a box. They are fragile too!

It took me half a day just to drill and install components.

But now that it’s done, I think I could get another pair of boards within half a day, all included. Actually, I’m planning to produce 4 pairs. But it’s a secret. The Beta is coming…

Posted in Arduino, Electronics, Pedal board, PU-2 | Tagged , , | Leave a comment

PU-2: Additional functions

I’m getting a lot of feedback from musicians who follow the development of the PU-2 pedal board. A lot has to do with demands for more details on existing functions, but some people ask for functions that the PU-2 doesn’t offer… yet!

So far, two new functions have been prompted by public demand. The first one is an analog volume control on the expression pedals and the second one is a general query for more flexibility (even more than already offered?) on command strings.

The analog volume control is going to be implemented as soon as I can get the parts. I will be using Silonex optocouplers. They are quite simple: a LED shine onto a photo-sensitive resistor. The advantage of using Silonex: very low distortion in the audio spectrum. I will test direct volume control first. This is just using the optocoupler in series with the guitar signal. If that doesn’t work well, I will use a simple op-amp circuit. I figure that I can add the analog volume control circuits for less than $20 per pedal board. I might offer it as an option.

The added flexibility in the  input file format is software only. Basically, I want the pedal board to accept any command, Midi or not. For example, many peripherals understand SysEx chains but are not very flexible on the Midi command side. My plan is to modify the program running on the PC to read any command line in the input CSV file and transfer it to the pedal board. For example, a SysEx string could be stored in the file and identified using a special command type (why not use SX?) which would signal the  translation program to leave the remaining bytes alone and pass them to the pedal board untouched. Another option would be to allow direct sending of any SysEx file to the pedal board, only limited by the size of the memory chip used.

Posted in Arduino, Pedal board, PU-2 | Leave a comment

PU-2: Version 0.093 – ALPHA is ready

Phew! The hardware is now ready to be converted for Beta. This means that Beta testers will have a unit within a week or two.

The hard part was the programming. I had to freeze the specifications and develop Alpha code. Here are the specs for Alpha:

Hardware

  • Based on standard Behringer FCB1010 pedal board
    • Main board removed
    • Power supply removed
    • 3 digit display removed
  • 10 configurable switches. See software specs below
  • 2 configurable expression pedals. See software specs below
  • 2 switches for Bank-up Bank-down
  • LCD display: 2 lines of 16 characters
  • Internal midi interface
  • Internal USB interface
    • Used for programming/monitoring in Alpha and Beta
    • Will be a core-compliant midi interface in production
  • New main board plug compatible with existing FCB1010 hardware. 15 minutes to replace
  • runs on USB power or 7-12 volts external power
  • Uses open source hardware (Arduino)

Software

  • 16 banks or patches (unlimited in production version)
  • 16 physical and logical switches per bank
    • 10 fully configurable switches
      • each can send unlimited number of midi commands
      • EACH command can be Stompbox, momentary or Normal mode
    • 2 switches pre-configured for Bank-up, Bank-down
    • 2 expression pedals with same configuration possibilities as On-Off switches
    • One rotary encoder (in Beta version)
    • One extra configurable stompbox switch (in Beta version)
  • All parameters permanently stored in EEPROM
  • PU-2 sends standard Midi commands using 8 parameters to shape the command

Programming Interface

User programming is done using a simple text file, which has a .CSV extension so it can be opened in a spreadsheet. No dedicated software interface for Alpha, but the file structure is self explanatory and uses decimal numbers (with comments) for data values.

A small program (runs on Mac, Windows or Linux) will read the specified file and create a SysEx file that is transferred to the PU-2 using a SysEx librarian (Snoize SysEx librarian recommended on Mac, a bunch for Windows).

I modified the data structure since the last post to accommodate the new fields. The fields are now:

  • Sequence / Bank / Patch number (limited to 16 until Beta)
  • Physical switch number (limited to 10 + 2 expression pedals until Beta)
  • Switch Behavior: Normal, Stombox or Momentary mode (0,1,2)
  • Midi command type (Control Change, Note On, Note Off, PitchWheel, etc)
  • Channel for this command
  • Midi command  (i.e. 7 for Volume control, 11 for Sustain, Note number, etc)
  • Midi command value (0 to 127 or 1 to 128)
  • Extra (not used until Beta)
  • Comment/Description

Here’s an example in CSV (just a text file):testdata1.csv

Want to play with one? Write a comment or send me an email or better still, help me finance the Beta/Production development by clicking on the link at right and committing an amount.

Posted in Arduino, FCB1010, Pedal board, PU-2 | Leave a comment