2 #include "HardwareI2C.h"
3 #include "hardware/i2c.h"
4 #include "hardware/gpio.h"
5 #include "PicoLogger.h"
6 #include "pins_arduino.h"
27 this->maxBufferSize = maxBufferSize;
43 virtual void begin(uint8_t address) {
44 begin(address, -1, -1);
48 virtual void begin(
int sdaPin,
int sclPin) {
50 setupPins(sdaPin, sclPin);
51 i2c_init(i2c, 100000);
52 i2c_set_slave_mode(i2c,
false, 0);
53 is_slave_mode =
false;
58 virtual void begin(uint8_t address,
int sdaPin,
int sclPin) {
59 Logger.
printf(PicoLogger::Info,
"begin %d\n", address);
60 setupPins(sdaPin,sclPin);
61 transmission_address = address;
62 i2c_init(i2c, 100000);
63 i2c_set_slave_mode(i2c,
true, address);
72 if (read_buffer !=
nullptr){
74 read_buffer =
nullptr;
76 if (write_buffer !=
nullptr){
78 write_buffer =
nullptr;
84 Logger.
info(
"setClock");
85 i2c_set_baudrate(i2c, baudrate);
90 Logger.
printf(PicoLogger::Info,
"beginTransmission %d\n", address);
91 transmission_address=address;
96 Logger.
info(
"endTransmission", stopBit ?
"stop" :
"no-stop" );
97 uint8_t result = flush(stopBit);
98 transmission_address = -1;
109 Logger.
debug(
"write");
111 if (write_pos>=maxBufferSize){
115 if (write_pos<maxBufferSize){
117 write_buffer[write_pos]=c;
124 size_t write(
const char *buffer,
size_t size) {
125 Logger.
debug(
"write[]");
129 return i2c_write_blocking(i2c, transmission_address,(
const uint8_t * ) buffer, size,
true);
133 virtual size_t requestFrom(uint8_t address,
size_t len,
bool stopBit) {
134 Logger.
printf(PicoLogger::Info,
"requestFrom (%d, %ld, %s)\n", address,len, stopBit?
"stop":
"no-stop");
136 setupReadBuffer(len);
137 read_address = address;
140 if (this->requestHandler!=
nullptr){
141 Logger.
info(
"requestHandler");
142 (*this->requestHandler)();
146 read_len = i2c_read_blocking(i2c, read_address, read_buffer, len, !stopBit);
148 if (read_len==PICO_ERROR_GENERIC){
149 Logger.
warning(
"requestFrom->",
"PICO_ERROR_GENERIC");
152 Logger.
printf(PicoLogger::Debug,
"requestFrom -> %ld\n",read_len);
155 if (read_len>0 && this->recieveHandler!=
nullptr){
156 Logger.
info(
"recieveHandler");
157 (*this->recieveHandler)(read_len);
171 int result = (read_pos<read_len) ? read_buffer[read_pos++] : -1;
177 Logger.
debug(
"peek");
178 return (read_pos<read_len) ? read_buffer[read_pos] : -1;
183 int buffer_available = read_len - read_pos;
184 if (buffer_available < 0){
185 buffer_available = 0;
186 Logger.
error(
"buffer_available is negative - corrected to 0");
188 Logger.
printf(PicoLogger::Debug,
"available: %d\n", buffer_available);
189 return buffer_available;
194 this->recieveHandler = recieveHandler;
195 Logger.
info(
"onReceive");
200 this->requestHandler = requestHandler;
201 Logger.
info(
"onRequest");
209 uint8_t transmission_address;
211 uint8_t *write_buffer;
217 uint8_t read_address;
218 uint8_t *read_buffer;
221 void(*recieveHandler)(int);
222 void(*requestHandler)(void);
227 bool pin_is_setup =
false;
229 void setupPins(
int sda,
int scl){
237 gpio_set_function(sda_pin, GPIO_FUNC_I2C);
238 gpio_set_function(scl_pin, GPIO_FUNC_I2C);
239 gpio_pull_up(sda_pin);
240 gpio_pull_up(scl_pin);
246 int flush(
bool stop=
false) {
249 Logger.
printf(PicoLogger::Debug,
"flush address:%d, len:%d, end:%s\n",transmission_address, write_pos, stop ?
"stop":
"no-stop" );
250 int result = i2c_write_blocking(i2c, transmission_address, write_buffer, write_pos, !stop);
251 if (result == write_pos){
253 }
else if (result < write_pos){
259 Logger.
printf(PicoLogger::Debug,
"flush->%d\n", result);
266 void setupWriteBuffer(){
268 if (write_buffer==
nullptr){
269 Logger.
info(
"setupWriteBuffer");
270 write_buffer =
new uint8_t(maxBufferSize);
274 void setupReadBuffer(
int len){
275 if (read_buffer==
nullptr){
277 maxBufferSize = std::max(len, maxBufferSize);
278 read_buffer =
new uint8_t(maxBufferSize);
280 if (len>maxBufferSize){
283 delete[] read_buffer;
284 read_buffer =
new uint8_t(maxBufferSize);
Definition: HardwareI2C.h:27
Arduino I2C implementation using the Pico functionality. In Arduino we can read and write individal c...
Definition: PicoHardwareI2C.h:22
PicoHardwareI2C(i2c_inst_t *i2c, int maxBufferSize, int sdaPin, int sclPin)
Standard Constructor for PicoHardwareI2C class.
Definition: PicoHardwareI2C.h:25
virtual void onRequest(void(*requestHandler)(void))
Register a function to be called when a master requests data from this slave device.
Definition: PicoHardwareI2C.h:199
virtual int read()
Reads a byte that was transmitted from a slave device to a master after a call to requestFrom() or wa...
Definition: PicoHardwareI2C.h:169
virtual void setClock(uint32_t baudrate)
This function modifies the clock frequency for I2C communication. I2C slave devices have no minimum w...
Definition: PicoHardwareI2C.h:83
virtual size_t requestFrom(uint8_t address, size_t len, bool stopBit)
Used by the master to request bytes from a slave device. The bytes may then be retrieved with the ava...
Definition: PicoHardwareI2C.h:133
virtual void beginTransmission(uint8_t address)
Begin a transmission to the I2C slave device with the given address. Subsequently,...
Definition: PicoHardwareI2C.h:89
size_t write(const char *buffer, size_t size)
Writes data from a slave device in response to a request from a master, or queues bytes for transmiss...
Definition: PicoHardwareI2C.h:124
virtual int peek()
Peeks current unread byte that was transmitted from a slave device to a master after a call to reques...
Definition: PicoHardwareI2C.h:176
virtual void begin(uint8_t address, int sdaPin, int sclPin)
Initiate the Wire library and join the I2C bus as a slave. This should normally be called only once.
Definition: PicoHardwareI2C.h:58
virtual void begin(int sdaPin, int sclPin)
Initiate the Wire library and join the I2C bus as a master. This should normally be called only once.
Definition: PicoHardwareI2C.h:48
virtual int available()
Returns the number of bytes available for retrieval with read(). This should be called on a master de...
Definition: PicoHardwareI2C.h:182
virtual size_t requestFrom(uint8_t address, size_t len)
Used by the master to request bytes from a slave device. The bytes may then be retrieved with the ava...
Definition: PicoHardwareI2C.h:164
virtual size_t write(uint8_t c)
Writes data from a slave device in response to a request from a master, or queues bytes for transmiss...
Definition: PicoHardwareI2C.h:108
virtual uint8_t endTransmission(bool stopBit)
Ends a transmission to a slave device that was begun by beginTransmission() and transmits the bytes t...
Definition: PicoHardwareI2C.h:95
~PicoHardwareI2C()
Destructor for PicoHardwareI2C class.
Definition: PicoHardwareI2C.h:33
virtual void begin()
Initiate the Wire library and join the I2C bus as a master. This should normally be called only once.
Definition: PicoHardwareI2C.h:38
virtual void end()
Closes the Wire Library.
Definition: PicoHardwareI2C.h:69
virtual void begin(uint8_t address)
Initiate the Wire library and join the I2C bus as a slave. This should normally be called only once.
Definition: PicoHardwareI2C.h:43
virtual void onReceive(void(*recieveHandler)(int))
Registers a function to be called when a slave device receives a transmission from a master.
Definition: PicoHardwareI2C.h:193
virtual uint8_t endTransmission(void)
Ends a transmission to a slave device that was begun by beginTransmission() and transmits the bytes t...
Definition: PicoHardwareI2C.h:103
virtual int printf(LogLevel current_level, const char *fmt,...)
printf support
Definition: PicoLogger.h:65
virtual void error(const char *str, const char *str1=nullptr, const char *str2=nullptr)
logs an error
Definition: PicoLogger.h:45
virtual void info(const char *str, const char *str1=nullptr, const char *str2=nullptr)
logs an info message
Definition: PicoLogger.h:50
virtual void warning(const char *str, const char *str1=nullptr, const char *str2=nullptr)
logs an warning
Definition: PicoLogger.h:55
virtual void debug(const char *str, const char *str1=nullptr, const char *str2=nullptr)
writes an debug message
Definition: PicoLogger.h:60
Pico Arduino Framework.
Definition: Arduino.cpp:26