Pico-Arduino
PicoHardwareI2C.h
1 #pragma once
2 #include "HardwareI2C.h"
3 
8 class PicoHardwareI2C : public HardwareI2C {
9  public:
10  PicoHardwareI2C(i2c_inst_t *i2c, int maxBufferSize=100, int rxPin, int txPin){
11  this->i2c = i2c;
12  this->maxBufferSize = maxBufferSize;
13  gpio_set_function(rxPin, GPIO_FUNC_I2C);
14  gpio_set_function(txPin, GPIO_FUNC_I2C);
15  gpio_pull_up(rxPin);
16  gpio_pull_up(txPin);
17  }
18 
19  ~PicoHardwareI2C(){
20  end();
21  }
22 
23  virtual void begin() {
24  i2c_init(i2c, 100000);
25  i2c_set_slave_mode(i2c, false, 0);
26  is_slave_mode = false;
27  }
28 
29  virtual void begin(uint8_t address) {
30  i2c_set_slave_mode(i2c, true, address);
31  is_slave_mode = true;
32  }
33 
34  virtual void end() {
35  i2c_deinit(i2c);
36  }
37 
38  virtual void setClock(uint32_t baudrate) {
39  i2c_set_baudrate(i2c, baudrate);
40  }
41 
42  virtual void beginTransmission(uint8_t address) {
43  transmission_address=address;
44  }
45 
46  virtual uint8_t endTransmission(bool stopBit) {
47  flush(true);
48  transmission_address = -1;
49  }
50 
51  virtual uint8_t endTransmission(void) {
52  flush(false);
53  transmission_address = -1;
54  }
55 
56  virtual size_t write(uint8_t c) {
57  setupWriteBuffer();
58  if (pos>=maxBufferSize){
59  flush(false);
60  }
61  // we just write to a buffer
62  write_buffer[pos]=c;
63  pos++;
64  }
65 
66  size_t write(const char *buffer, size_t size) {
67  setupWriteBuffer();
68  return i2c_write_blocking(i2c, transmission_address, write_buffer, size, true);
69  }
70 
71  virtual size_t requestFrom(uint8_t address, size_t len, bool stopBit) {
72  read_address = address;
73  read_len = len;
74  read_stop_bit = stopBit;
75  }
76 
77  virtual size_t requestFrom(uint8_t address, size_t len) {
78  requestFrom(address, len, true);
79  }
80 
81  virtual int read() {
82  readBuffer();
83  return (read_pos<read_len) ? buffer[read_pos++] : -1;
84  }
85 
86  virtual int peek() {
87  readBuffer();
88  return (read_pos<read_len) ? buffer[read_pos] : -1;
89  }
90 
91  virtual int available() {
92  readBuffer();
93  int buffer_available = read_len - read_pos;
94  return buffer_available;
95  }
96 
97  virtual void onReceive(void(*recieveHandler)(int)) {
98  this->recieveHandler = recieveHandler;
99  Logger.error("onReceive not implemented yet");
100  }
101 
102  virtual void onRequest(void(*requestHandler)(void)) {
103  this->requestHandler = requestHandler;
104  Logger.error("onRequest not implemented yet");
105  };
106 
107  protected:
108  i2c_inst_t *i2c;
109  int maxBufferSize;
110  // write
111  uint8_t transmission_address;
112  int pos;
113  uint8_t *write_buffer;
114 
115  // read
116  size_t read_len;
117  size_t read_pos;
118  bool read_stop_bit;
119  uint8_t read_address;
120  uint8_t *read_buffer;
121 
122  // handler
123  void(*recieveHandler)(int);
124  void(*requestHandler)(void)
125 
126 
127  bool flush(bool end) {
128  int len = i2c_write_blocking(i2c, transmission_address, write_buffer, pos, !end);
129  pos = 0;
130  }
131 
132  void setupWriteBuffer(){
133  // setup buffer only if needed
134  if (write_buffer==nullptr){
135  write_buffer = new uint8_t(maxBufferSize);
136  }
137  }
138 
139  void readBuffer() {
140  // allocate buffer only if it is needed
141  if (read_buffer==nullptr)
142  read_buffer = new uint8_t(maxBufferSize);
143 
144  if (read_pos==read_len){
145  // fill read buffer
146  int len = min(i2c_get_read_available(i2c), maxBufferSize);
147  read_len = i2c_read_blocking(i2c, read_address, read_buffer, len, read_stop_bit);
148  read_pos = 0;
149  }
150  }
151 
152 };
Arduino I2C implementation using the Pico functionality.
Definition: PicoHardwareI2C.h:8
Definition: HardwareI2C.h:27