Just Type without Teletype - I2C shenanigans

desolationjones · 2018-01-08T20:25:38.066Z

I’m researching the feasibility of a tiny DIY expander for Just Friends which enables the polyphonic synthesis mode from Just Type. The JF-to-TT inter-module connectivity is achieved on an I2C bus, called “II” in monome parlance. Before I dive further into the code base: does anybody have a short list of device addresses and I2C message content used by the Teletype for its various inter-modular comms?

The most likely form of the expander would be a hobby microcontroller with MIDI DIN in, outputting JF.VOX commands with note and velocity info on I2C bus. Toggle switch for JF.MODE on / off. Simple as cake.

Road map:

Determine TT I2C addresses, message content, format, and speeds. <-- you are here
Use a Bus Pirate to issue JF.MODE and JF.VOX commands from terminal.
Troubleshoot communications.
Determine scope of expander.
Design expander.
Build it, share design.

jnoble · 2018-01-08T20:39:08.997Z

A version that had pitch and velocity CV inputs and a mode switch would be pretty cool.

desolationjones · 2018-01-08T20:48:09.720Z

Yeah, it would be pretty cool but I’m going to walk before I run. There is a lot of other Just Type features that could be implemented and adding CV control to any of it greatly increases the complexity.

jnoble · 2018-01-08T20:51:51.952Z

The same micro that handles MIDI could easily handle the A/D for CV inputs.

desolationjones · 2018-01-08T20:59:55.729Z

Could theoretically reprogram a TELEXi to serve this purpose. Only 4 CV in but it already has I2C bus.

jasonw22 · 2018-01-08T21:05:50.120Z

I don’t believe Telex is currently set up to be an I2C master, but it’d be better to hear it from @bpcmusic

desolationjones · 2018-01-08T21:13:48.361Z

There’s no hardware difference between master / slave configs in I2C. Just a matter of programming.

jasonw22 · 2018-01-08T21:14:10.129Z

Right, I was merely referring to the current implementation.

sam · 2018-01-08T21:43:48.444Z

Here you go…

github.com

monome/libavr32/blob/3264a8e1ec7d971108a5aa7585392a95b3b60dda/conf/teletype/conf_board.h#L172


#define DAC_SPI_NPCS 0
#define ADC_SPI_NPCS 1
#define OLED_SPI_NPCS 2


//TWI
#define TWI 					(&AVR32_TWI)
#define TWI_DATA_PIN			AVR32_TWI_SDA_0_0_PIN
#define TWI_DATA_FUNCTION   	AVR32_TWI_SDA_0_0_FUNCTION
#define TWI_CLOCK_PIN           AVR32_TWI_SCL_0_0_PIN
#define TWI_CLOCK_FUNCTION  	AVR32_TWI_SCL_0_0_FUNCTION
#define TWI_SPEED 100000;


#define MOD_TELETYPE


#endif // CONF_BOARD_H

github.com

monome/libavr32/blob/3264a8e1ec7d971108a5aa7585392a95b3b60dda/src/ii.h#L14


#define II_ANSIBLE_TR_TOG     2
#define II_ANSIBLE_TR_PULSE   3
#define II_ANSIBLE_TR_TIME    4
#define II_ANSIBLE_TR_POL     5
#define II_ANSIBLE_CV         6
#define II_ANSIBLE_CV_SLEW    7
#define II_ANSIBLE_CV_OFF     8
#define II_ANSIBLE_CV_SET     9
#define II_ANSIBLE_INPUT      10


#define JF_ADDR 	0xF0
#define JF_TR 		1
#define JF_RMODE 	2
#define JF_RUN 		3
#define JF_SHIFT 	4
#define JF_VTR 		5
#define JF_MODE 	6
#define JF_TICK 	7
#define JF_VOX 		8
#define JF_NOTE 	9
#define JF_GOD 		10

github.com

monome/teletype/blob/e6909a3cdca1d7d65626c5151c929c569c2bca3b/src/ops/justfriends.c

#include "ops/justfriends.h"

#include "helpers.h"
#include "ii.h"
#include "teletype_io.h"

static void op_JF_TR_get(const void *data, scene_state_t *ss, exec_state_t *es,
                         command_state_t *cs);
static void op_JF_RMODE_get(const void *data, scene_state_t *ss,
                            exec_state_t *es, command_state_t *cs);
static void op_JF_RUN_get(const void *data, scene_state_t *ss, exec_state_t *es,
                          command_state_t *cs);
static void op_JF_SHIFT_get(const void *data, scene_state_t *ss,
                            exec_state_t *es, command_state_t *cs);
static void op_JF_VTR_get(const void *data, scene_state_t *ss, exec_state_t *es,
                          command_state_t *cs);
static void op_JF_MODE_get(const void *data, scene_state_t *ss,
                           exec_state_t *es, command_state_t *cs);
static void op_JF_TICK_get(const void *data, scene_state_t *ss,
                           exec_state_t *es, command_state_t *cs);

This file has been truncated. show original

Does that get you started?

Galapagoose · 2018-01-09T00:30:58.871Z

Personally I’d just use a TXi, Ansible or some other Trilogy module. You get a solid hardware platform, plus a huge wealth of low-level details already dealt with. Definitely a good way to get working on the hardest challenges (those of design), rather than dealing with hardware headaches.

A poly-phonic version of Earthsea (for Just Type) has been on my list forever, but I doubt I’ll ever find the time.

bpcmusic · 2018-01-09T02:06:33.771Z

Galapagoose:

I’d just use a TXi, Ansible or some other Trilogy module.

Definately doable with any of the three. I’d be happy to help with the TXi route and add the functions necessary (if you want to go that way). It would be fairly trivial to do so (and I’ve already have done it with a direct TXo connection).

unity2k · 2018-01-09T02:09:31.777Z

So what you are really saying here @bpcmusic is that you will more than likely be facilitating the manufacturing of even more Telex units huh?

tehn · 2018-01-09T02:17:55.381Z

all that said, i hooked up a WW to a ras-pi (3 wires) and was controlling cut positions with a python script that was less than 10 lines. (was a proof of concept, don’t have the code on hand, but it’s ridiculously easy)

desolationjones · 2018-01-09T18:24:31.307Z

Thanks @sam. This is plenty to start throwing some bits at my JF (when it arrives).

desolationjones · 2018-01-09T18:38:13.597Z

Do the Trilogy modules act as USB hosts? One of them might be a good choice if I want to connect an external controller. Can’t find schematics for them on the monome github though. The TXi is open hardware, appealing, but with only 4 CVs chords would be tricky. 2 voices without velocity or 1 voice with. Or 4 voices triggered on CV change but giving up playing repeat notes.

shellfritsch · 2018-01-09T19:12:55.163Z

earthsea and ansible have usb midi host modes in the current firmwares.

Galapagoose · 2018-01-09T19:39:51.377Z

If you’re goal is to use a MIDI input to control Just Type, Ansible is your best bet. It already has the USB-MIDI driver (attach your USB-MIDI device directly, or use a USB-to-MIDI 1x1 converter. You’ll only really need to hook into the I2C-master code and the rest should be largely there already. That’s the closest to ‘Simple as cake’ as I think you’ll find.

ghost · 2018-01-10T17:20:53.770Z

Galapagoose:

A poly-phonic version of Earthsea (for Just Type) has been on my list forever

Kind of OT but, I’m interested to see how far we can take this with teletype. I’m still struggling on writing a nice note stealing algorithm to use with Just Type in SUSTAIN/SOUND mode but I wonder how many of Earthseas awesome features could be incorporated somehow.

jimi23 · 2018-03-10T00:47:14.000Z

How did you get on with this project? I was about to create a similar topic, but ill just bump this one!
Ive got an Ansible and JF, and was thinking about re-purposing telex expanders to get some extra functionality. Obviously hard-coded at compile time but i think theres some fun stuff to be done.
Particularly on Kria i’d like Position CV out and clock out. Would be cool to sync a stage cv addressable sequencer like the Voltage block to loop manipulations on Kria.
Similar with JF, a TXi module that could retune key intone relationships, give CV over amplitude for a quick VCA, maybe a second V/OCT input using the internal TXi quantiser.

I guess i should get some Txo boards and start hacking!

desolationjones · 2018-03-10T01:22:03.348Z

jimi23:

How did you get on with this project?

Funny that you should ask on the very same day my Teletype arrives…