I’ve been thinking about my little scheme, and I’ve talked to a couple of people who know far more about electronics than I do. I’m a software person, essentially, and so I think in those terms.
Basically, one of the problems people have had with my idea is that every actuator requires different circuitry, because each one has different power requirements, etc. So one motor might need one set of resistors and capacitors to function correctly, but another one has a totally different set.
Which is fine, I totally get that. But that’s all part of the physical level of my architecture. It doesn’t matter how power gets to the motor, so long as it can be regulated by a low-voltage control circuit (i.e. my autonomic level).
According to my lazy Googling and some Twitter conversations, there are only really a very few ways for a low-voltage system to control a high-voltage actuator(s). Relay switches, transistors, MOSFETs, right? As long as my autonomic layer has interfaces for all of the usual methods, it doesn’t matter what’s on the other end of that interface.
For example: imagine I have a 50V electric motor in my system. It’s turned on by a reed switch, which is 5V, attached to my control board by a standard connector. If I swap out the 50V for a 75V, it doesn’t matter to my control circuit at all, because it’s just triggering that reed switch. So long as the reed can handle a 75V load, it’s all fine. It doesn’t matter how the 50V and the 75V each get power from their power supply — whether they’re just connected directly or have more sophisticated management subsystems — so long as they can be controlled by a binary EM switch or a system for varying power input.
Think of it like so:
Each of those physical subsystems (the green and red boxes) can be as complex or as simple as you like, so long as they can be interfaced with my low-voltage autonomic board.
So the real project here — the actual tasks I need to accomplish, as opposed to all my blue-sky philosophical bullshit — is this:
- Create a standardized way of interfacing the behavioral and autonomic layers. My guess is that this will mean making a way of sending and receiving OSC messages between the two.
- Create a set of methods for abstracting those messages within the autonomic layer and turning them into actual hardware control signals.
- Design a standard for normalizing hardware interface and control. I don’t think this has to be physical, necessarily, but more like a generalized way of driving different sorts of actuators and reading digital/analog input.
I think the easiest way to begin this is to write the code for the Arduino, because it’s the cheapest and most widely used hardware prototyping hardware around. So my initial concrete goal:
- Write (or find) an OSC receiver for Arduino;
- Create a set of initial abstractions for components (brushed motors, stepper motors, servos, and analog and digital sensors) that can be mapped to OSC endpoints and methods;
- Create a machine-readable way of describing those components to the hardware, that can be uploaded to firmware depending upon configuration.
Once I can get a proof-of-concept working for Arduino, I’ll open-source it to anybody who wants to port it to any other control system.
So, not a heavy amount of work or anything.