Connect two simulated controllers with i2c

[ein-shved]

Hi! I just faced with fact that simavr was not designed to support direct connection of TWI IRQs of two AVRs lile next:

/* Connect i2c lines */
avr_connect_irq(
    avr_io_getirq(board->master, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_OUTPUT),
    avr_io_getirq(board->slave, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_INPUT));
avr_connect_irq(
    avr_io_getirq(board->slave, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_OUTPUT),
    avr_io_getirq(board->master, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_INPUT));

There two options:

1. add extra code to simulation to connect directly AVRs: transform irq messages which are intended to peripheral to make them correctly handled by AVR;
2. patch twi support in simavr to make it usable in multi-mk layouts.

Both approaches requires the good knowledge of simavr internals from me, but first requires it from others users requiters extra code and complicates the using of simavr lib. On the other hand the second approach may break api.

So my questions are next:

• am I right or I doing something wrong in my code?
• is there any working example for subject?
• which approach are preferred? If there no example for my situation, I'm going to patch simavr code and use it by myself (2nd approach) anyway. But if it has a chance to go to mainstream, I will spent time to check it with other examples and for bugs. I will create PR in any case.

[davezap]

Late to the party, but were you able to resolve this?

I have been digging in to the twi code in the library. But no luck so far. The slave.by default will not acknowledge addresses or data.

[gatk555]

Can you post example code that fails, preferably small?

[davezap]

Sure thing, here is the smallest version of some code that does not work.

static void twi_logger(avr_irq_t *irq, uint32_t value, void *param) {
    const char *tag = (const char *)param;
    const char *name = irq->name ? irq->name : "(unnamed)";

    if (strstr(name, "output")) {
        avr_twi_msg_irq_t m; m.u.v = value;
        uint8_t msg  = m.u.twi.msg;
        uint8_t addr = m.u.twi.addr;
        uint8_t data = m.u.twi.data;

        printf("[%s][OUT] msg=", tag);
        if (msg & TWI_COND_START) printf("START|");
        if (msg & TWI_COND_STOP)  printf("STOP|");
        if (msg & TWI_COND_ADDR)  printf("ADDR|");
        if (msg & TWI_COND_ACK)   printf("ACK|");
        if (msg & TWI_COND_WRITE) printf("WRITE|");
        if (msg & TWI_COND_READ)  printf("READ|");
        printf(" addr=0x%02x data=0x%02x raw=0x%08x\n", addr, data, value);

    } else if (strstr(name, "input")) {
        avr_twi_msg_irq_t m; m.u.v = value;
        uint8_t msg  = m.u.twi.msg;
        uint8_t addr = m.u.twi.addr;
        uint8_t data = m.u.twi.data;

        /*
        const uint8_t v = 35; // or your known index
        avr_int_vector_t *vec = g_avr_hmi->interrupts.vector[v];
        if (vec) {
            //printf("****BANG****");
            avr_raise_interrupt(g_avr_hmi, vec);   // will be serviced when SREG.I allows it
        } //else  printf("****NO_BANG****");
        */

        printf("[%s][IN ] msg=", tag);
        if (msg & TWI_COND_START) 
        {
            printf("START|");
        }
        if (msg & TWI_COND_STOP)  printf("STOP|");
        if (msg & TWI_COND_ADDR)  printf("ADDR|");
        if (msg & TWI_COND_ACK)   printf("ACK|");
        if (msg & TWI_COND_WRITE) printf("WRITE|");
        if (msg & TWI_COND_READ)  printf("READ|");
        printf(" addr=0x%02x data=0x%02x raw=0x%08x\n", addr, data, value);

    } else if (strstr(name, "status")) {
        printf("[%s][STATUS] 0x%02x\n", tag, (unsigned)(value & 0xff));
    } else {
        printf("[%s][???] IRQ=%s value=0x%08x\n", tag, name, value);
    }
}

static void dump_twi_endpoints(const char *who, avr_t *mcu, int port)
{
    printf("[%s] Discovering TWI IRQs via AVR_IOCTL_TWI_GETIRQ(%d):\n", who, port);
    for (int i = 0; i < TWI_IRQ_COUNT; i++) {
        avr_irq_t *q = avr_io_getirq(mcu, AVR_IOCTL_TWI_GETIRQ(port), i);
        if (q)
            printf("  idx=%2d  name=%s\n", i, q->name ? q->name : "(null)");
    }
    printf("\n");
}

// Link master<->slave TWI using simavr’s IRQs.
// master_port/slave_port are usually 0 (first/only TWI).
int link_twi_debug(avr_t *master, int master_port,
                          avr_t *slave,  int slave_port)
{
    dump_twi_endpoints("MASTER", master, master_port);
    dump_twi_endpoints("SLAVE",  slave,  slave_port);

    avr_irq_t *m_in   =  avr_io_getirq(master, AVR_IOCTL_TWI_GETIRQ(master_port), TWI_IRQ_INPUT);
    avr_irq_t *m_out  =  avr_io_getirq(master, AVR_IOCTL_TWI_GETIRQ(master_port), TWI_IRQ_OUTPUT);
    avr_irq_t *m_stat =  avr_io_getirq(master, AVR_IOCTL_TWI_GETIRQ(master_port), TWI_IRQ_STATUS);

    avr_irq_t *s_in   =  avr_io_getirq(slave,  AVR_IOCTL_TWI_GETIRQ(slave_port),  TWI_IRQ_INPUT);
    avr_irq_t *s_out  =  avr_io_getirq(slave,  AVR_IOCTL_TWI_GETIRQ(slave_port),  TWI_IRQ_OUTPUT);
    avr_irq_t *s_stat =  avr_io_getirq(slave,  AVR_IOCTL_TWI_GETIRQ(slave_port),  TWI_IRQ_STATUS);

    if (!m_in || !m_out || !m_stat || !s_in || !s_out || !s_stat) {
        fprintf(stderr, "ERROR: TWI endpoints not found; see discovery dump above and adjust.\n");
        return -1;
    }

    // Optional: hook loggers for diagnostics
    avr_irq_register_notify(m_out,  twi_logger, (void*)"MASTER");
    avr_irq_register_notify(m_in,   twi_logger, (void*)"MASTER");
    avr_irq_register_notify(m_stat, twi_logger, (void*)"MASTER");

    avr_irq_register_notify(s_out,  twi_logger, (void*)"SLAVE");
    avr_irq_register_notify(s_in,   twi_logger, (void*)"SLAVE");
    avr_irq_register_notify(s_stat, twi_logger, (void*)"SLAVE");

    return 0;
}


int sim_init() {

// load 
  const char *hex_path_hmi = "firmware/hmi.hex";
  const char *hex_path_main = "firmware/main.hex";
  int hz = 16000000;

  g_avr_hmi = avr_make_mcu_by_name("at90usb1286");
  if (!g_avr_hmi) return -1;
  avr_init(g_avr_hmi);
  g_avr_hmi->frequency = hz;
  if (load_hex_into_avr(g_avr_hmi, hex_path_hmi) < 0) return -2;

  g_avr_main = avr_make_mcu_by_name("atmega2560"); // needed to create this core. 
  if (!g_avr_main) return -1;
  avr_init(g_avr_main);
  g_avr_main->frequency = hz;
  if (load_hex_into_avr(g_avr_main, hex_path_main) < 0) return -2;

// Connect master's TWI output to slave's TWI input
  avr_connect_irq(
      avr_io_getirq(g_avr_main, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_OUTPUT),
      avr_io_getirq(g_avr_slave, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_INPUT)
  );

  // Connect slave's TWI output to master's TWI input
  avr_connect_irq(
      avr_io_getirq(g_avr_slave, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_OUTPUT),
      avr_io_getirq(g_avr_main, AVR_IOCTL_TWI_GETIRQ(0), TWI_IRQ_INPUT)
  );

  link_twi_debug(g_avr_main, 0, g_avr_hmi, 0);
}

Same irq cross-link method as OP., Similar examples, see simavr\examples\parts\i2c_eeprom.c i2c_eeprom_attach()

That's fine for connecting application code to an emulated mcu, but it just fails between two emulated mcu's

I added the link_twi_debug, and started digging in tot he avr_twi.c code in the API but have not made a lot of progress yet

you can see from the debug trace that the irq is getting raised on the slave, but there may be some problem with the implementation? The data is mostly nulls on the slave side.

[MASTER][STATUS] 0x08
simavr.js:1 [MASTER][OUT] msg=START|ADDR|WRITE| addr=0xba data=0x00 raw=0x00ba1500
simavr.js:1 [SLAVE][IN ] msg=START|ADDR|WRITE| addr=0xba data=0x00 raw=0x00ba1500
simavr.js:1 [MASTER][STATUS] 0x20
simavr.js:1 [MASTER][OUT] msg=WRITE| addr=0xba data=0x4a raw=0x4aba1000
simavr.js:1 [SLAVE][IN ] msg=WRITE| addr=0xba data=0x4a raw=0x4aba1000
simavr.js:1 [MASTER][STATUS] 0x30
simavr.js:1 [MASTER][OUT] msg=STOP| addr=0xba data=0x01 raw=0x01ba0200
simavr.js:1 [SLAVE][IN ] msg=STOP| addr=0xba data=0x01 raw=0x01ba0200
simavr.js:1 [MASTER][STATUS] 0xf8
simavr.js:1 [SLAVE][STATUS] 0xa0
simavr.js:1 IRQ36 raising (enabled 1)
simavr.js:1 IRQ36 calling
simavr.js:1 IRQ36 cleared
simavr.js:1 IRQ36 cleared

[gatk555]

The code looks OK to me, but what about main() and the firmware? In your trace, the slave raises no IRQs, but it should be sending ACKs. Incorrect setup in slave firmware? And without an ACK, the master should not be sending data, but that may be a different bug.

Have you tried enabling the TRACE code in avr_sim.c?

[davezap]

I'll work on the TRACE,

But just wanted to add that the firmware runs fine on production hardware.

[gatk555]

"... firmware runs fine on production hardware." Both sides? You might have mentioned that before!

It is probably worth trying the suggested fix in #453.