Our community blogs
Recent EntriesLatest Entry
I am continuing my blog on http://www.bloggen.be/mb9090/ that way everybody can see how it is going with my project.
- Read more...
- 0 comments
In general I don't recommend starting any project with an enclosure that is smaller than what you can fit a proto version of your project in. But my enclosure supply just about gone, so I'll use what I have. The tekbox from TEKO enclosures. (NOTE: If for some insane reason you decide to emulate this work in progress, buy a tekmar case. It's the same but bigger)
Stage 1: Planning (barely) ahead.
Since this isn't a masterpiece by the MB gods, I 'm just going to build the control surface on veroboard (protoboard) and hand wire each component. This gives me that added option of making components sit really close to each other without worrying about PCB traces. My veroboards are from RadioShack. They are pretty standard 0.05" spaced holes and have pads on one side. To make sure the control surface would actually fit in the tekox, I created a new part of the pads in Eagle and then placed each component on the grid. My LCD in this picture is from the SparkFun eagle library. I also placed an optional 4 digit 7 segment display and knobs on the layout. (If you can, always place the knobs on encoder layouts. Even if its just a circle. I have at least 3 old projects that I never use because there isn't enough space for knobs and it looks like crap)
For all intensive purposes the 4 digit 7 segment display will probably not get populated (but its nice to have the option to put one there).
Stage 2: Sizing up the competition
As you can see in the picture below, the 1:1 print layout of the control surface fits perfectly in the recess of the top half of the enclosure. The knobs might protrude on either side of the case recess, but I'll just have to live with that.
Still not done checking though. I've burned myself enough to know that I'll have to test fit some parts on hand to make sure this is all going to work. After testing the LCD, I realized the SparkFun 16x2 LCD pin out is off by 0.05" but the outside dimension is perfect The SparkFun display was perfect. The Displaytech LCD footprint I used wasn't. I'll adjust the part and retest the fit. In the next version, I've also rotated the swing pot 180 degrees so that I can add the record indicator led next to the shift indicator led.
Stage 3: 3D Rendering
This step wasn't even remotely necessary. I'm just playing in sketchup with 3D rendering of eagle layouts. I've modified the EagleUp script and created some new models to generate a 3D rendering of this control surface. I originally had every intention of checking this against the enclosure DXF but OKW (TEKO) didn't have one available, so this is what you get. Still makes me happy to look at it.
This project is still very much a work in progress. At the time of this writing, I'm still planning the base PCB. If for any reason the MidiBox gods see a train wreck coming, let me know.
Recent EntriesLatest Entry
MIDIBox SlideControl is a remote control solution for Kodak Carousel slide projectors aimed at event usage.
It was a sometimes painful process of about 1.5 years to arrive at the solution at last. Success would not have been possible without the great midibox community! Thank you!
One box "on stage" receives MIDI and button presses to switch slides forward/backwards. Due to the long distances to be bridged (10-50 meters), it was necessary to use the CAN protocol/MBNet to transmit the necessary information to a distribution box (typically up in the rafters/trussing), from where up to 8 slide projectors are controlled in a star topology. Control is achieved by closing an electric circuit of the projector via a reed relay for total electric insulation.
Preliminary test confirmed that it is possible to transmit control information over 100 meters (!) of ordinary cable. The CAN protocol maximum specified distances lie in the range of 7 kilometers, only dependent on bit rate.
Due to the nature of the CAN protocol, it is easily possible to add further distribution boxes and daisy-chain them from the first one. One could control more projectors than I care for that way (>=64), only limited by MBNet address space.
One nice consequence of the design is, that XLR-cables, which are ubiquitous in event production, can be used for the cabling of the whole project (stagebox->distrobox, distrobox->projectors).
The stage box consists of one PIC8 core stuffed with a 18F4685 (necessary for the included CAN interface), one DIN for the buttons, one standard character LCD, and a small self-designed PCB for the CAN driver/transceiver, all put in some plastic case I had lying around.
The distributor box consists of one PIC8 core (with 18F4685 as before), and a self-designed PCB containing half a DOUT, the CAN driver circuitry, and the reed relais. XLR plugs etc. made the whole affair a little cramped (the core is actually stacked on top of the self-made PCB!), but I am very satisfied with how it turned out.
Some adapter cables and a connection tester made the whole thing complete and ready for action!
The software is basically a MIDIO128, augmented with the MBNet parts I ripped out of Midibox SIDV2. Due to MBNet only being available in assembly, I had to stay with a programming language I don't actually speak. TK was an invaluable help in merging the relevant source codes together!
The software forwards button presses to a distrobox. Since the distroboxes have Device ID's starting from one, it was possible to route received MIDI events to distroboxes depending on the MIDI channel, so events on Channel 11 only go to distrobox 1, Channel 12 to number 2, etc. I chose to start with Channel 11 to avoid interference with common MIDI control messages, which are typically on CH1.
I would rather not just put the code online here, because it is actually quite a hacky solution, and most probably affected with bugs I haven't found, and definitely not programmed elegantly. I only grafted MBSid code onto MIDIO128 in the crudest way possible, and I don't really know how to program assembler, it was much more "educated copy-paste". I will definitely send the code on request, and I did everything in a git repository, so it should actually be possible to follow my changes, and adapt them to you own needs.
- Read more...
- 0 comments
Recent EntriesLatest Entry
Yes, i admit, i'm slow as a turtle. But as a turtle i've put out my head, and today out in direction to the blog! :)
Ok, jokes apart, in the previous step i've explaned how to get installed the needed tools to compile apps for our beloved Core controller, in this third step we will see how to get the SVN repository and then how to get and app compiled and ready as an .hex file to upload to our Pic Core, or Core32.
First thing is opening the Terminal.
Since the last step i assume that we get familiar with the Terminal window so i'll not explain where and how find it in our Macs!
Once you have the terminal opened, go to your home folder.
Usually when you open Terminal you're already on the Home folder, and you'll see your mac login name on the left of the cursor.
lsand hit return. You'll see a list of files and folder, open via finder your home folder, if you see that the files are the same you are surely in the home folder with the terminal. Otherwise you're in another folder and what you have to write in the terminal is the following command
cd Users/yourhomenameIt will bring you to the home folder. Home folder that will be the folder where we will put the mios, or mios32 repository. With Terminal opened write this command
svn co svn://svnmios.midibox.org/miosYou'll see that the Terminal will start to download all the repository files in a folder called mios in your home directory. We are downloading this repository in the home folder because we will have to set a .profile file needed to the compiling process. I'll explain his purpose later. Ok, when the Terminal have finished the download, we will see a folder called mios in our home with inside it two folders, trunk and playground. We will concentrate on trunk, the place were all what we need for our apps is placed. But, hey, we forgot the SVN32! Simple task, repeat the same command "svn co" but this time with the svn32 address:
svn co svn://svnmios.midibox.org/mios32At the end of the download you'll have the core32 repository, always in the home directory. Now we have both core and core32 repository in our home folder. You should see mios and mios32 folders. Well, start to compile! No. Do you remember the .profile file mentioned just before? We have to edit it so the tools installed in the Step 2 will work flawlessy. Don't ask me more about this, as i'm learning like you and sometimes i know that things must go in this way but i don't know why because i haven't yet understood all. I know that's not brilliant, but at the end i've the compiling process working! :) (i hope to explain better why to modify .profile page as soon as possible!) Let's go on modify our .profile page, you braves! On terminal write this command (be sure that you're in the home folder "/Users/yourhomename", not in another folder like mios or music ):
open .profileYou'll see a textedit file opened. Put at the top of the file this code if you are using the mios repository:
# mios export MIOS_PATH=/mios/trunk export MIOS_BIN_PATH=$MIOS_PATH/bin # mios endPut this code if you are using the mios32 repository:
# mios32 export PATH=$PATH:/usr/local/stm32/bin export MIOS32_PATH=/mios32/trunk export MIOS32_BIN_PATH=$MIOS32_PATH/bin export MIOS32_GCC_PREFIX=arm-none-eabi export MIOS32_FAMILY=STM32F10x export MIOS32_PROCESSOR=STM32F103RE export MIOS32_BOARD=MBHP_CORE_STM32 export MIOS32_LCD=clcd # mios32 endIf you're using both the repository put this:
# mios export MIOS_PATH=/mios/trunk export MIOS_BIN_PATH=$MIOS_PATH/bin # mios end # mios32 export PATH=$PATH:/usr/local/stm32/bin export MIOS32_PATH=/mios32/trunk export MIOS32_BIN_PATH=$MIOS32_PATH/bin export MIOS32_GCC_PREFIX=arm-none-eabi export MIOS32_FAMILY=STM32F10x export MIOS32_PROCESSOR=STM32F103RE export MIOS32_BOARD=MBHP_CORE_STM32 export MIOS32_LCD=clcd # mios32 endSave the file (cmd+S) and then close. Now, to refresh the system with the new .profile file we have to write this in the Terminal window:
. ~/.profileBe careful to include also the first dot! Best way copy and paste. ;) Once the .profile file is refreshed we can now go with our terminal to an app folder and try to compile it. But before i advice you to do always a backup of the folder that contains files needed to compile. My workflow is the following: I need to modify and compile the blm_scalar app. I copy the blm_scalar app folder in another backup folder, folder that can be placed anywhere outside the mios, or mios32 folders. I will have in this way an original copy of the svn downloaded one. Now that we have placed the original copy in a secure place we will start to go into our app target folder with the Terminal: When you are in the home folder with the Terminal write this command
cd mios/trunk/apps/controllers/blm_scalarYou'll be in the blm_scalar folder where all the .c, .h and makefile, needed for compiling, are located. Remember that you must go in an app single folder with Terminal to have the compiling process working. I mean, if you need to compile the midibox64 app, you will ahve to go to the midibox64 folder through the command
cd mios/trunk/apps/controllers/midibox64and so on for the other apps. I advice you to check out the apps and the relative folders path via finder, and then write the needed path in the terminal. Ok, returning to the our folder, blm_scalar, we are ready to compile our target app. You should have in terminal this position:
macname:blm_scalar yourhomename$What you have to do now is simply write in Terminal
makeThe terminal will print out some text and then the prompt will be back. And now? Check out what changed in the folder via the Terminal command
You can check out what changed also with finder going into the blm_scalar folder.
You should see that some files and a folder were created!
And....you should see project.hex, our compiled app ready to be uploaded to our core!
Ok, now that we had this file how we can upload to our core?
Simple, we will upload it using MIOS_Studio!
Download it from here, scroll the page to the bottom, you'll find the download links for mac and windows.
In the meantime that connect your Core board to your computer via midi, connecting both midi in and midi out.
Once the MIOS_Studio is downloaded, place it in your applications folder and then launch it.
Click over the browse button, go on the blm_scalar folder located in /"home"/mios/trunk/apps/controllers/blm_scalar, select the project.hex file and click ok.
Then click the start button and the progress bar will raise up with the upload of the project.hex file!
When finished your core will reboot and in the MIOS_Studio you will see a "ready" text!
You have now your app compiled and uploaded!
Consider that the same process is valid when you modify apps and the you'll upload them, is the same also if you are working with the mios32 svn.
But remember always to backup the apps folders and to check if the svn is updated!
I'll write about the modify of the app later as is something that i've not yet learned.
In the next step i'll write about the components needed for my specific controller project and write about some other thing that i'll think over in the next days/weeks! Remember the turtle! :)
- Read more...
- 0 comments
much time hast past since my last entry here, but this project is not dead.
what happened in the meantime?
my studies ate up much more time than I planned, so I had to change priorities.
but its not all about math and machine construction ;-)
first step was creating all the pcbs i need for building the controller and - my very own
PIC-Burner. I used his lovely little pre-project to gain some advanced skills for the
etching machine at work. thanks to my boss, i got a nice box, LEDs and faceplate for it.
next step was the first big order from bÃ¼rklin (having access to non privat selling
companies via the company i work for in my freetime is a big advantage here).
the order contained all parts for building core module, several dins, ains and douts, and
a blue display from pollin.
due to my own impatience, all modules were finished very fast, but I made a mistake on the
interconnection between core and Display. result was a broken PIC and core... damnit.
I borrowed 2 other displays from a friend of mine and ordered a new pic. this time, everything
went well and I got the core up and running, with 128_din_dout software.
Another sunday evening solder marathon later, my very first prototype with one din and ain module
4 switches, three pots and one rotary switch (for multilayering knobs in the software) was build and running.
First tests with traktor pro 1.2 were sucessfull.
At this point, the progress of my project begun to slown down. main reason for that was to find a reseller for
my special alps potentiometers with buildin switches. actual status is that I am waiting for two mails from different
resellers which I ve asked. also, finding round aluminium profiles for the boxing (I have to have round corners on it!)
was a tough job. I spend around 3 weeks on the internet until I found www.weloe.com. I ordered 12 8cm pieces
for three boxes (yes I am going to build more xD) and awaited them in january. it was a big surprise when they
arrived this week just at my birthday xD
rest of the time I spent on this project I thought a lot about the frontplate and the layout of its buttons. the picture
from the last entry is not actual anymore, but I made only minor changes. I think the frontplate will be the last
thing that i order, since there are many things that still have to be planned in detail, for example the display
(I want to integrate a graphic one for informations like songtitle, bpm and selected effect, but i still did not figure out
if mios support anything like that). two other big problems i have to solve are the mounting of the pots and the control-
system for my RGB LEDs.
Recent EntriesLatest Entry
I ordered a front panel for my Sequencer (using Wilba's design) from Julian at www.thebeast.co.uk.
The panel looks great but as anybody following the discussions will know, it isn't easy for Julian to make threaded blinds so we decided to go for blinds that are large enough to fit a hex spacer in. They are 5.72mm diameter x 2mm deep.
As JB Weld isn't that common in the UK, I thought I would try Loctite "Bond Loc". This is available from Maplin http://www.maplin.co...?ModuleNo=46006 and claims to bond metal very well (it contains stainless steel!).
I thought I would try the spacers for the LCD, there are 8mm deep (including the 2mm blind) so the LCD stands off 6mm from the back of the panel. Once I have some 2mm perspex/acrylic for the window, this should be fine (hopefully).
While waiting for the Bond Loc to cure I built the Core32 module that I had earmarked for this. That went without a hitch and seems to work fine!
The LCD's fit fine, bit of a cock-up though, I bought them cheap off t'ebay and they are Electroluminescent backlight ones. Oh well. One 5v inverter order later (only Â£12 so not too bad), That works quite well the picture shows it is a blue/green backlight so not unpleasant. I am still undecided whether I like the displays but they will do for now.
I am now stopped until my PCB and other kit arrives, hopefully in January.
Recent EntriesLatest Entry
i'm finally continuing my work on using liveapi to integrate mios32 and ableton live. this works by giving programmers a large set of functions they can call to manipulate damn near anything in live. another set of functions are automatically called by live, allowing you to track whatever is going on. this will let users play a live set without ever looking at a computer screen. the possibilities can be a lot more than that.
to do this, i've made a protocol that works over midi and allows a midibox to seamlessly communicate with a liveapi script. on the programmer's side of it, you just have a simple set of functions to play with. look at it as a midibox API for LiveAPI, extending mios into live, and vice versa.
currently this is being developed for live 7.0.14. i'm fairly confident that most of the code will work for live 8, and i'll try to get a new version going once this is complete.
for a teaser, here are some of the functions at your disposal. keep in mind i haven't gotten to the clips, tracks, or track devices yet, but eventually you'll be able to go as far as bring clip or plugin parameter names into the midibox, and of course monitor what is going on with all of it. this list is growing by the day.
functions you can call from mios:
void MBLIVE_SONG_SetTransport(u8 state);
void MBLIVE_SONG_SetRecord(u8 state);
void MBLIVE_SONG_SetOverdub(u8 state);
void MBLIVE_SONG_SetFollow(u8 state);
void MBLIVE_SONG_SetBackToArrangement(u8 state);
void MBLIVE_SONG_SetDrawMode(u8 state);
void MBLIVE_SONG_SetArrangementPosition(u8 mode, u16 val);
void MBLIVE_SONG_SetTriggerQuantization(u8 state);
void MBLIVE_SONG_SetTempo(u8 mode, u16 value);
void MBLIVE_SONG_SetTimeSignatureNumerator(u8 mode);
void MBLIVE_SONG_SetTimeSignatureDenominator(u8 mode);
void MBLIVE_SONG_SetGrooveAmount(u8 mode);
void MBLIVE_SONG_SetMetronome(u8 state);
void MBLIVE_SONG_SetLoopStart(u8 mode, u16 val);
void MBLIVE_SONG_SetLoopLength(u8 mode, u16 val);
void MBLIVE_SONG_SetPunchIn(u8 state);
void MBLIVE_SONG_SetPunchOut(u8 state);
void MBLIVE_SONG_SetSessionArrangementView(u8 state);
void MBLIVE_SONG_SetClipDeviceView(u8 state);
void MBLIVE_SONG_SetBrowserView(u8 state);
void MBLIVE_SONG_SetDetailView(u8 state);
void MBLIVE_SONG_SetSelectedTrack(u8 track);
void MBLIVE_SONG_SetSelectedScene(u8 scene);
functions called by live:
void MBLIVE_SONG_NotifyTransportChanged(u8 state);
void MBLIVE_SONG_NotifyRecordChanged(u8 state);
void MBLIVE_SONG_NotifyOverdubChanged(u8 state);
void MBLIVE_SONG_NotifyFollowChanged(u8 state);
void MBLIVE_SONG_NotifyBackToArrangementChanged(u8 state);
void MBLIVE_SONG_NotifyDrawModeChanged(u8 state);
void MBLIVE_SONG_NotifyArrangementPositionChanged(u32 val0, u8 val1, u8 val2);
void MBLIVE_SONG_NotifyTriggerQuantizationChanged(u8 state);
void MBLIVE_SONG_NotifyTempoChanged(u16 value);
void MBLIVE_SONG_NotifyTimeSignatureChanged(u8 val0, u8 val1);
void MBLIVE_SONG_NotifyGrooveAmountChanged(u8 value);
void MBLIVE_SONG_NotifyMetronomeChanged(u8 state);
void MBLIVE_SONG_NotifyLoopStartChanged(u32 val0, u8 val1, u8 val2);
void MBLIVE_SONG_NotifyLoopLengthChanged(u32 val0, u8 val1, u8 val2);
void MBLIVE_SONG_NotifyPunchInChanged(u8 state);
void MBLIVE_SONG_NotifyPunchOutChanged(u8 state);
void MBLIVE_SONG_NotifySessionArrangementViewChanged(u8 state);
void MBLIVE_SONG_NotifyClipDeviceViewChanged(u8 state);
void MBLIVE_SONG_NotifyBrowserViewChanged(u8 state);
void MBLIVE_SONG_NotifyDetailViewChanged(u8 state);
void MBLIVE_SONG_NotifyTrackCountChanged(u8 trackCount, u8 returnTrackCount);
void MBLIVE_SONG_NotifySelectedTrackChanged(u8 track);
void MBLIVE_SONG_NotifySceneCountChanged(u8 count);
void MBLIVE_SONG_NotifySelectedSceneChanged(u8 scene);
Recent EntriesLatest Entry
Having had most of the parts required to get started for a few months already, I finally managed to spend some time working on this project! The midibox forum upgrade seems to have come with this new blogging feature, so I thought I'd use it to document the build.
I started last night by unpacking and sorting all the components required to assemble the base PCB (acquired from SmashTV). This didn't take very long as although there is a lot of components there is not that many different kinds; almost everything comes in multiples of 8. I wonder why that is... ;-)
After a bit of confusion as to which PSU option I was gonna go with, I opted for PSU Option A since I will only be using 6582s (8 of them, acquired from Wilba quite a while back and kept in deep freeze since). I have a C64 (second generation - looks like a C128) PSU which I assume to be working since it's able to power the C64 it came with...
I then started soldering the components in the order suggested in the construction guide.
Mmmmhh the smell of rosin always brings back sweet memories... That is of course until the fumes start to build up and my eyes start to sting. Time to open the window I think!
After 4 hours of soldering, most of the core and psu sections are complete. All the chip sockets are in. I haven't soldered any headers yet as I haven't decided exactly what I will require - I need to do a bit more reading on this... Also still to be soldered are all the electrolytic capacitors.
One thing I have noticed about the PCB is that a lot of the chip labels get covered by the sockets once they are in. Not a big deal, I will be using this file for reference if needed. I understand that this is kind of unavoidable as the layout is quite compact.
Added some more harware over the weekend. Built a very crude keyboard with 10 swithes and 2 x DIN registers on the board. Works beautifuly. Now have to start on the programing bit I suppose. Still trying to figure out how to handle the input bit and know when multiple inputs are toggled??? Just have to do some more reading I suppose.
Well here's another pic in the meantime.
Till next time.
- Read more...
- 0 comments
Hate it when I triplecheck all the connections on something and it's still bad. In this case, it was the LCD and I mistranscribed the pinouts. So for anyone else remember it's
So the numbering proceeds in a U-shape, which wasn't what I am used to.
Fortunately, my LCD (shown here) survived the abuse and after rewiring it was fine.
- Read more...
- 0 comments