Just Type without Teletype - I2C shenanigans

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…

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…

chailight · 2018-05-14T23:41:23.176Z

I’m also following this topic with interest - just about to try doing the Raspberry Pi i2c out to Just Friends.

from what @tehn was saying earlier it’s a straight forward 3 wire connection. I was wondering if there needs to be a logic level adjustment from 3.3v to 5v for i2c between a Pi and JF (or any other Monome or Mangrove modules) or are they all in the same voltage?

It seems this is an issue if you are doing i2c between a Pi and an arduino - see here https://learn.sparkfun.com/tutorials/bi-directional-logic-level-converter-hookup-guide - so I thought i should check before I go plugging anything together.

Galapagoose · 2018-05-15T01:20:26.010Z

All monome & Mannequins modules supporting i2c use a 3v3 level connection.
I believe that’s what rPI uses to, but please confirm beforehand! Off hand, I think the i2c pins on stm32f4/7 series (used on JF / W/) are 5v safe, but I would have to doublecheck.

chailight · 2018-05-15T04:00:07.616Z

Thanks @Galapagoose !

That is really useful to know. Having just got my v1 JF back from having it’s Run jack updated (much appreciated btw!!!) I’d hate to mess anything up by plugging in the wrong thing.

Heard such a great demo of JF polyphonic mode via TT the other day, I’m really keen to explore it. But I’ll have a read up on the STM data sheets you mention - out of interest more than anything - and I’ll be double checking the I2C output from the Pi in any case to make sure it is 3.3v.

My RPi is currently in another rack at the moment, so I’m still thinking about what makes for a good i2c connection cable across to the JF since they don’t normally sit next to each other.

Looks like the FaderBank crew are looking at using a TRRS cable for the i2c output. i’ve wondered if repurposing a (mini) usb cable might be better (so that various contacts aren’t scraping past each other) although if i understand correctly i2c connections should only be made when everything is powered off so maybe it no difference.

iiii · 2018-05-16T19:50:08.678Z

This is an interesting prospect, curious to see what people come up with. If there is MIDI control for JF it would be rad to use something like Lemur on an iPad to control the extra functionality of JT. Neat!

desolationjones · 2018-05-16T23:41:31.036Z

I’d be tempted to wait and see what crows brings for JF functionality. That would be a USB->LUA->I2c link, probably with built-in support for the existing II ecosystem.

Hlp · 2018-06-09T17:25:53.021Z

Anyone knows any news about such a mod?
Is someone working on that? It would be a dream
All or most i would want from TT is opening up Just Type and it seems like a heavy rocky road for this.
I cant control a big system anyway since 56hp isnt a lot:)

If one would get Ansible or telexi, there could be sooner or later a firmware flash to add just type?