Raspberry Pi (3B) to Arduino I2C Setup
===

I had a hard time finding example code to do simple I2C communication with an Arduino,
so I decided to write this minimal tutorial on how to get non-trivial communication
functioning between an Arduino (Nano) and a Raspberry Pi (3B).

This tutorial shows a simple "passthrough" to communicate to an Arduino (Nano)
via I2C from a Raspberry Pi (3B).
Text can be sent via the Serial line from the Arduino and show up from a program
running on the Raspberry Pi.
Messages from the Raspberry Pi can be sent via the I2C line and show up on the
Serial line on the Arduino.

Overview
---

The Arduino will have a direct connection to the Raspberry Pi's I2C line
and the Arduino will act as the 'slave/worker' whereas the Raspberry Pi will act as
the 'master/manager'.

The Arduino will have a connection to the PC via a USB line which will serve double
duty to program the Arduino and allow us to interact with the Serial interface.

Normally, the operating voltage of 5V for the Arduino would cause problems when interfacing
with the 3.3V of the Raspberry Pi but since the Arduino is a 'worker' I2C device and the
Raspberry Pi is the 'manager' I2C device, the Arduino will not drive the I2C lines higher
than the 3.3V the Raspberry Pi sets them at.
This means we can interface the Arduino directly to the I2C lines of the Raspberry Pi with
out a line level converter.

Once the physical wiring is setup, the Arduino will be programmed with a simple 'passthrough' program
that sets up a receive and send I2C interrupt handlers for the I2C communication to the Raspberry Pi.

The Raspberry Pi will be setup to enable the I2C lines and a program will be created that uses
the I2C SMBUS interface to communicate over the I2C lines.

Wiring
---

Arduino Programming
---

The Arduino will be setup with an I2C worker address of `8`.

The following program should be put into a sketch and the Arduino
should be programmed:

```
//
// This code is in the public domain.
//

#include <Wire.h>


#define MSG_BUF_MAX 128
#define ARDWORKER_I2C_ADDRESS 0x08


char _tbuf[MSG_BUF_MAX];

int   i2c_msg_buf_n = 0,
      i2c_msg_buf_rdy = 0;
char  i2c_msg_buf[MSG_BUF_MAX];

int serial_buf_s=0,
    serial_buf_n=0;
char serial_buf[MSG_BUF_MAX];

void setup() {
  i2c_msg_buf_rdy = 0;
  i2c_msg_buf[0] = '\0';
  i2c_msg_buf_n = 0;

  serial_buf_s=0;
  serial_buf_n=0;
  serial_buf[0] = '\0';
  
  Wire.begin(ARDWORKER_I2C_ADDRESS);
  Wire.onReceive(receive_i2c_data);
  Wire.onRequest(send_i2c_data);
  Serial.begin(115200);
}



void loop() {
  int i, _b, _cur;
  int _ser_print_rdy = 0;
  

  noInterrupts();
  if (Serial.available()) {
    _b = Serial.read();
    if (_b >= 0) {
  
      // Add to our circular serial_buf for later tranport
      // through to the i2c line.
      //
      if (serial_buf_n < MSG_BUF_MAX) {
        _cur = (serial_buf_s + serial_buf_n) % MSG_BUF_MAX;
        serial_buf[_cur] = (char)_b;
        serial_buf_n++;
      }

    }

  }
  interrupts();

  noInterrupts();
  if (i2c_msg_buf_rdy) {
    for (i=0; i<MSG_BUF_MAX; i++) {
      _tbuf[i] = i2c_msg_buf[i];
    }
    
    i2c_msg_buf[0] = '\0';
    i2c_msg_buf_n=0;
    i2c_msg_buf_rdy=0;
    _ser_print_rdy = 1;
  }
  interrupts();

  if (_ser_print_rdy) {
    Serial.print(_tbuf);
  }

}


void send_i2c_data() {
  int res;

  if (serial_buf_n > 0) {
    res = Wire.write((char)serial_buf[serial_buf_s]);
    serial_buf_n--;
    serial_buf_s++;
    serial_buf_s %= MSG_BUF_MAX;
  }

}


void receive_i2c_data(int howMany) {
  char c;

  while ( Wire.available()) {
    c = Wire.read();

    i2c_msg_buf[i2c_msg_buf_n++] = c;
    if (i2c_msg_buf_n >= MSG_BUF_MAX) {
      i2c_msg_buf_n = MSG_BUF_MAX-1;
    }

    if ((c == '\n') || (c == '\r')) {
      i2c_msg_buf[i2c_msg_buf_n] = '\0';

      // Our messages are terminated by '\n' and '\r'.
      // Once a message is received, shuttle it to the
      // serial line.
      //
      i2c_msg_buf_rdy=1;
    }
  }

}
```

Once done, a serial window should be opened with the baud rate set to `115200`.

Raspberry Pi Configuration
---

On the RPi, issue `raspi-config` (as root) and setup I2C

```
(5) Interfacing Options -> (P5) I2C
```

Check to see the device is available:

```
# ls /dev/*i2c*
/dev/i2c-1
```

If desired, the speed for the I2C device can be confirmed with:

```
#!/bin/bash
var="$(xxd /sys/class/i2c-adapter/i2c-1/of_node/clock-frequency | awk -F': ' '{print $2}')"
var=${var//[[:blank:].\}]/}
printf "%d\n" 0x$var
```


```
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>

#include <linux/i2c-dev.h>
#include <i2c/smbus.h>

#include <errno.h>

#include <stdint.h>

#define ICHTHYIC_MAX_BUF 128

typedef struct ichthyic_type  {
  uint8_t i2c_fn[ICHTHYIC_MAX_BUF];
  int     i2c_adapter;
  int     i2c_worker_addr;
  int     i2c_fd;

  uint32_t i2c_from_buf_n;
  uint8_t i2c_from_buf[ICHTHYIC_MAX_BUF];

  uint32_t i2c_to_buf_n;
  uint8_t i2c_to_buf[ICHTHYIC_MAX_BUF];

} ichthyic_t;

ichthyic_t *ichthyic_alloc() { return malloc(sizeof(ichthyic_t)); }
void ichthyic_free(ichthyic_t *ich) { free(ich); }

void ichthyic_init(ichthyic_t *ich) {
  ich->i2c_from_buf[0] = '\0';
  ich->i2c_fn[0] = '\0';
  ich->i2c_adapter  = -1;
  ich->i2c_worker_addr = -1;
  ich->i2c_fd = -1;

  ich->i2c_to_buf_n = 0;
  ich->i2c_to_buf[0] = '\0';

  ich->i2c_from_buf_n = 0;
  ich->i2c_from_buf[0] = '\0';
}

int ichthyic_i2c_queuebuf(ichthyic_t *ich, uint8_t *buf, uint32_t nbuf) {
  int i;
  for (i=0; i<nbuf; i++) {
    ich->i2c_to_buf[i] = buf[i];
  }
  ich->i2c_to_buf[nbuf] = '\0';
  ich->i2c_to_buf_n = nbuf;
}

int ichthyic_i2c_read(ichthyic_t *ich) {
  int32_t res, dn=0;

  res = i2c_smbus_read_byte(ich->i2c_fd);
  if (res<0) { return -1; }
  if (res==0) { return 0; }

  dn=1;
  while (ich->i2c_from_buf_n < (ICHTHYIC_MAX_BUF-1)) {

    ich->i2c_from_buf[ich->i2c_from_buf_n] = res;
    ich->i2c_from_buf_n++;
    ich->i2c_from_buf[ich->i2c_from_buf_n] = '\0';

    res = i2c_smbus_read_byte(ich->i2c_fd);
    if (res<0) { return -1; }
    if (res==0) { break; }

    dn++;
  }

  return dn;
}

int ichthyic_i2c_write(ichthyic_t *ich) {
  int i;
  int32_t res;

  for (i=0; ich->i2c_to_buf[i]; i++) {
    res = i2c_smbus_write_byte(ich->i2c_fd, ich->i2c_to_buf[i]);
  }
  ich->i2c_to_buf_n = 0;
  ich->i2c_to_buf[0] = '\0';
}

int ichthyic_i2c_writebuf(ichthyic_t *ich, uint8_t *buf, uint32_t nbuf) {
  uint32_t i;
  int32_t res;
  for (i=0; i<nbuf; i++) {
    res = i2c_smbus_write_byte(ich->i2c_fd, buf[i]);
  }
}

int main(int argc, char **argv) {
  int i, ret, fd, adapter_nr, ch;
  char fn[32];
  int worker_addr = 0x08;

  FILE *msg_fp;
  char msg_fn[] = "msg/msg.txt";
  char *msg_buf=NULL;
  int msg_buf_n=0;

  struct timespec _sleepy, _sleepy_rem;

  ichthyic_t ich;

  // 1000000000 ns in 1 sec
  //
  _sleepy.tv_sec = 0;
  _sleepy.tv_nsec = 1000000;


  ichthyic_init(&ich);
  ich.i2c_worker_addr = 0x08;
  ich.i2c_adapter = 1;
  snprintf(ich.i2c_fn, 31, "/dev/i2c-%i", ich.i2c_adapter);
  ich.i2c_fd = open(ich.i2c_fn, O_RDWR);
  if (ich.i2c_fd < 0) {
    perror(ich.i2c_fn);
    exit(-1);
  }

  if (ioctl(ich.i2c_fd, I2C_SLAVE, ich.i2c_worker_addr) < 0) {
    perror(ich.i2c_fn);
    exit(-2);
  }

  msg_buf = malloc(sizeof(char)*1024);

  while (1) {

    // for debugging, process message file
    //
    msg_fp = fopen(msg_fn, "r");
    if (msg_fp) {
      msg_buf_n = 0;
      while (!feof(msg_fp)) {
        ch = fgetc(msg_fp);
        if (ch == EOF) { continue; }
        msg_buf[msg_buf_n++] = ch;
      }
      msg_buf[msg_buf_n] = '\0';
      //msg_buf_n++;
      fclose(msg_fp);
      unlink(msg_fn);

      printf("processing[%i]: '%s'\n", msg_buf_n, msg_buf);

      ichthyic_i2c_queuebuf(&ich, msg_buf, msg_buf_n);
    }

    ichthyic_i2c_write(&ich);
    ret = ichthyic_i2c_read(&ich);
    if (ret<0) {
      perror("i2c read");
    }
    if (ret > 0) {
      printf("# read +%i (%i,%i) i2c bytes\n", ret, ret, ich.i2c_from_buf_n);
    }

    if (ich.i2c_from_buf_n > 0) {
      if ((ich.i2c_from_buf[ ich.i2c_from_buf_n-1 ] == '\r') ||
          (ich.i2c_from_buf[ ich.i2c_from_buf_n-1 ] == '\n')) {
        printf("[%i]>:", ich.i2c_from_buf_n);
        for (i=0; i<ich.i2c_from_buf_n; i++) {
          if (ich.i2c_from_buf[i] == '\n') {
            printf("`");
          }
          else if (ich.i2c_from_buf[i] == '\r') {
            printf("~");
          }
          else if ((ich.i2c_from_buf[i] >= ' ') &&
                   (ich.i2c_from_buf[i] <= '~')) {
            printf("%c", ich.i2c_from_buf[i]);
          }
          else {
            printf("<%x>", ich.i2c_from_buf[i]);
          }
        }
        printf("\n");
        ich.i2c_from_buf[0] = '\0';
        ich.i2c_from_buf_n = 0;
      }
    }

    nanosleep(&_sleepy, &_sleepy_rem);

  }

  close(ich.i2c_fd);
}
```

Creating Virtual TTY
---

A virtual TTY pair can be created with `socat`:

```
socat -d -d pty,raw,echo=0,link=/tmp/ttyPTich pty,raw,echo=0,link=/tmp/ttyPT
```

`ichthyic-passthrough` can be used to connect the two, logging to `/tmp/ich.log`:

```
./ichthyic-passthrough -i /tmp/ttyPTich -I /dev/i2c-1 -v -v -L /tmp/ich.log
```



Running
---

Once the Arduino has been programmed and the Raspberry Pi has been setup,
the programs can be run to test out.

References
---

* [I2C Arduino Raspberry Pi](https://dronebotworkshop.com/i2c-arduino-raspberry-pi/).

