I was thinking about the interesting sequencers that use more or less obscure methods to determine patterns... The Klee, the Random Looping Sequencer, Fonik's VCPS which uses grey codes, etc.

I'm curious if anyone has tried applying cellular automata in this area? I'd expect there's no practical way to implement them in pure analog terms, but with the prevalence of microcontrollers (Arduino, PIC) that doesn't seem like a very high hurdle.

I'm scratching my head over how one might go about implementing a user interface for them. Part of me thinks a simple table of the Wolfram Codes for 1 dimensional CAs that you could scroll through ought to be sufficient, but then how to display the nature of the rules in a way that's meaningful?

I did some googling and see a lot of instances of the CAs being applied as MIDI scores, including some nice results with piano sounds in "Wolfram Tones" http://tones.wolfram.com/

But I don't see an application to sequencing patterns. I'm curious if anyone else thinks that might be interesting. Some rules seem like they could be leaning in the direction of Ian's experiments with attractors.....

I've been thinking about this too - So I made plans for a Game of Life sequencer in Buchla format.

First you generate your game in a 16 x 16 matrix, it might be random- or a predefined pattern. Then choose what row you want your triggers to come from, and then either step through matrix sequentially (E.g. 1 to 16) or evolve the pattern for new triggers.

Made a sketch in Buchla format. It misses a lot of stuff - Like reset for the step, no way to select predefined patterns and so on.

That's awesome. I was thinking tonight on the drive home that if I were doing it I'd be using a 16 wide 1D CA, you could set a starting state and let it propagate for 16 steps. Then you could pass the pulses out in any of the 4 cardinal directions up / down / left /right, possibly repeat each row a certain number of times, set loop points, use as a sequence of triggers or to drive a set of 16 pots. I guess you could make it 2 x 8 or 1 x 16 too.

All of which makes me think I probably ought to try implementing it in some kind of software first to be sure it's going to actually be as useful/interesting as it seems like it could be. Using something like that to drive one of those 16 x 16 lit button pads sure seems interesting though.

I've done some more thinking about this, and I think you can actually break this up into two pieces.

1) generating a data grid

For my original idea, generating the data grid would be a 1D CA, either just running 16 steps and leaving the grid fixed, or running each additional step as you needed it for the sequencer. But Life could be a different way to generate the data grid. A button grid of some sort could be another way to generate the grid, which brings the functionality closer to a more traditional trigger sequencer.

I think the biggest challenge for using a CA to populate the grid is going to be how to identify what rule set you're using.... To use Life would simplify that quite a bit, actually.

2) sequencing through the data grid

This can be entirely independent of the logic above, and can be used to create (or re-create, I imagine this is likely something that's been done before) a powerful grid-based sequencer.

Some of the other ideas that have occurred, though this sounds like its likely to be a beast (i.e. not something that's going to fit nicely on a 2U or 3U panel even in a 5U format):

switches across the top for loading--either the first row or somehow stepping through the grid--this plays back to other direct methods of populating the grid, but the first row would be needed to preload a CA as well. This plays very much like the load functions of the klee as I understand them.

momentary switches along each axis to select rows or columns.

LEDs along each axis to indicate a currently active point in the grid--possibly combine with the momentary switches.

Alternatively, use an LED button grid, which removes the need for both of those, but is more expensive....this sounds like it would be able to be implemented with software and a monome, but I don't have a monome sized budget .

A set of pots for CV sequencing, one for each column (and/or one for each row? Hm, interesting idea to have CV outputs for each axis)

All the normal sequencer controls, run/stop, step, reset, as well as direction (forward / backward).

In addition to the obvious CV/step sequencing one row at a time, I could see using the columns as trigger sequences, or modifying the cycle sequence -- top to bottom or bottom to top, left to right or right to left, serpentine (alternating direction on successive rows).

Have a means to constrain start/stop column/row so you could confine the sequence to any sub-grid. This is inspired somewhat by what I've seen done with the Archangel with setting start/stop points.

Possibly define each row (for step sequencing anyway) as repeating a certain number of times before going to the next row.

It also seems like it might be interesting to traverse the grid in less linear ways, say a spiral or the serpentine and generate a single stream of triggers from it, or even generate separate CVs, this might work well if you take CVs from each axis and even if you do sum/difference on them.

I wish I had all the pieces in place to be able to play with this right now . I have ordered an OctoMod (USB -> 8 CV outs controlled by OSC) and I think I could implement this in software and use the OctoMod to generate the outputs to the modular just as a proof of concept, but I don't expect to see the OctoMod built for another couple of months at least between lead time on the PCB, parts, and the actual build.

I've also done some of the initial investigation on how I might accomplish this with an Arduino controlling the logic, and I think it's feasible, but it'll take a few I2C expander chips to accomplish, so a PCB could be pretty big or rely on several (I haven't done any of my own PCBs for through hole, I'm not about to start first thing on SMD components ).

Ages ago, in my 'chaos theory & Fractals' craze. I did something like this, on the BBC micro, driving the then very cool 'Music 5000' system

The code sadly went a long time ago, and any recording were cassette, and I would have to dig through a big box to find them, but I can remember how it worked.

I used a Von Neuman automaton, initially of 16, then later 32 cells length. A rule was set up, and the first row initialised. whilst that was playing, a new row was generated and played, and so on.

I got my most pleasant results, using 8 cell values, 7 tuned tuned to a Balinese 'Pelog' scale, (I got the idea after listening to Neil Ardleys Jazz masterpiece 'A Kaleidoscope of Rainbows'), and a 'rest'. It was like a baby Gamelon player, with each sequence being somehow related to the previous one. Rules that worked in musical intervals were good, though many had a tendency to 'choke off' after a few rows played.

Some of the best results would play indefinitely, and some would deteriorate into a non-musical chaos rather fast. Some I left playing all evening whilst I was doing other stuff.

As I recall, part of the interest was in how I dealt with the end points of the rows. Looping back causes it's own problems, ( a circular automaton might never resolve, but then again, musically, that might not be a bad idea>

I don't think I could replicate the design now since it was written in 'AMPLE' the language for the Music 5000, after a prototype design in BBC BASIC, taken from a magazine article, but I will take a look to see if I can find anything.

A small processor would have no problems running it, though a neat way to input the rules on a synth module might be an interesting problem.

Edited: I forgot that I had 8 values - 1 for a space/rest._________________MikeLast edited by TheAncientOne on Thu Apr 04, 2013 8:18 am; edited 1 time in total

Great info! I doubt I would have thought to look into alternative scales, for example.

I have come into possession of a (slightly) used Monome 64, and I have a couple of Octomod USB->CV units that will come to me sometime this year, and I think once I have all that functioning I will work on software to try and implement this. If that works out, I'm also thinking I want to try to interface the Monome to an Arduino Leonardo (which is capable of acting as a USB Host) to make a standalone box out of it.

If you do find any of that other info I'd be really interested to learn more about your project.

Yes, PureData was high on my list. I have an ancient laptop lying around I was going to load Linux on (I'm an IT geek in my day job), but unfortunately I'd forgotten that it doesn't actually have a CD/DVD drive, so I will have to set up to network load the OS first. Doable, but not dead easy, and takes time away from things like finishing my wogglebug

The other positive for this laptop is that it has a touchscreen, so if I can get the Linux touchscreen drivers working, that opens up additional possibilities as well.

You cannot post new topics in this forumYou cannot reply to topics in this forumYou cannot edit your posts in this forumYou cannot delete your posts in this forumYou cannot vote in polls in this forumYou cannot attach files in this forumYou can download files in this forum

Please support our site. If you click through and buy from our affiliate partners, we earn a small commission.