Ansible: Where does the i2c process function get called from?

Galapagoose · 2018-05-19T17:18:10.906Z

Hello!
I’m trying to get i2c getters working for W/ presently and having a hard time working through the correct sequence of commands. When TT sends a ‘get’ request to a module, that follower module must ACK the address, receive a byte (what data is being requested), transmit the data back to TT.

At present, I can successfully transmit data from W/ back to TT, but the byte that says what data to send isn’t available. I think I’m missing something conceptually about how the process is intended to work.

So now to the question: Where does the ii_process() function pointer get called?

It seems like it should be part of libavr32 but I couldn’t find any reference to it by name. I’m assuming it occurs via an interrupt, but I was surprised not to find it referred to anywhere by name. The point is that I want to see how the follower-side low-level driver responds when it receives a request for transmission. Any help directly on that would be great too, but even just pointing me to where that function is called would be a great help.

scanner_darkly · 2018-05-19T18:03:04.142Z

do you mean process_ii?

on ansible it gets set when a mode is switched. here is where it’s set for levels (which is a good example of a follower sending data back to the leader):

github.com

monome/ansible/blob/master/src/ansible_arc.c#L84


		// print_dbg("\r\n> mode arc levels");
		app_event_handlers[kEventKey] = &handler_LevelsKey;
		app_event_handlers[kEventTr] = &handler_LevelsTr;
		app_event_handlers[kEventTrNormal] = &handler_LevelsTrNormal;
		app_event_handlers[kEventMonomeRingEnc] = &handler_LevelsEnc;
		app_event_handlers[kEventMonomeRefresh] = &handler_LevelsRefresh;
		clock = &clock_null;
		// clock = &clock_levels;
		// clock_set(f.levels_state.clock_period);
		init_i2c_slave(II_LV_ADDR);
		process_ii = &ii_levels;
		resume_levels();
		update_leds(1);
		break;
	case mArcCycles:
		// print_dbg("\r\n> mode arc cycles");
		app_event_handlers[kEventKey] = &handler_CyclesKey;
		app_event_handlers[kEventTr] = &handler_CyclesTr;
		app_event_handlers[kEventTrNormal] = &handler_CyclesTrNormal;
		app_event_handlers[kEventMonomeRingEnc] = &handler_CyclesEnc;
		app_event_handlers[kEventMonomeRefresh] = &handler_CyclesRefresh;

it gets called here:

github.com

monome/libavr32/blob/master/src/i2c.c#L70


  rx_pos[rx_buffer_index]++;
}
}


void twi_slave_stop(void)
{
uint8_t index = rx_buffer_index;
// rx_buffer_index must be incremented before process_ii is called
if (++rx_buffer_index >= RX_BUFFER_COUNT) rx_buffer_index = 0;


process_ii(rx_buffer[index], rx_pos[index]);
rx_pos[index] = 0;
}








extern void ii_tx_queue(uint8_t data) {
// print_dbg("\r\nii_tx_queue ");
tx_buffer[tx_pos_write] = data;
// print_dbg_ulong(data);

it gets triggered when a transmission is complete. there is an additional software buffer in case a follower hasn’t finished processing previous commands when a new one is received.

for completeness, TT requesting levels CV:

github.com

monome/teletype/blob/master/src/ops/ansible.c#L560


tele_ii_tx(II_LV_ADDR, d, 2);
}


static void op_LV_L_DIR_get(const void *data, scene_state_t *ss,
                        exec_state_t *es, command_state_t *cs) {
uint8_t d[] = { II_LV_L_DIR | II_GET };
uint8_t addr = II_LV_ADDR;
tele_ii_tx(addr, d, 1);
d[0] = 0;
tele_ii_rx(addr, d, 1);
cs_push(cs, d[0]);
}


static void op_LV_CV_get(const void *data, scene_state_t *ss, exec_state_t *es,
                     command_state_t *cs) {
int16_t a = cs_pop(cs);
a--;
uint8_t d[] = { II_LV_CV | II_GET, a & 0x3 };
uint8_t addr = II_LV_ADDR;
tele_ii_tx(addr, d, 2);
d[0] = 0;

ansible levels response:

github.com

monome/ansible/blob/master/src/ansible_arc.c#L627


					tr_note0();
				if(l.mode[1])
					tr_note1();
				if(l.mode[2])
					tr_note2();
				if(l.mode[3])
					tr_note3();
				monomeFrameDirty++;
			}
			break;
		case II_LV_CV + II_GET:
			if (d[1] > 3) {
				ii_tx_queue(0);
				ii_tx_queue(0);
				break;
			}
			ii_tx_queue(dac_get_value(d[1]) >> 8);
			ii_tx_queue(dac_get_value(d[1]) & 0xff);
			break;
		default:
			break;

Galapagoose · 2018-05-19T19:17:31.782Z

Thanks so much!
Github’s search engine didn’t find the entry in libavr32 for some reason. I definitely skimmed through that file and didn’t notice it myself. Thanks for the walkthrough! I think I can manage from here