(Wire.available()

对不起，我之前理解错了。Wire.available()函数是用于检查I2C设备是否有数据可供读取的。在I2C通信中，数据是通过主设备向从设备发送请求来获取的，因此在主设备中使用Wire.available()函数可以检查从设备是否有数据可供读取。如果有数据可供读取，可以使用Wire.read()函数来读取数据。但是，Wire函数并不能直接接收串口发过来的数据，需要使用Serial库中的函数来实现。

相关问题

#include <Wire.h>

#include <Wire.h> 是一个Arduino库，用于实现I2C通信协议。I2C是一种串行通信协议，可以用于连接多个设备，其中一个设备作为主机，其他设备作为从机。通过使用Wire库，可以在Arduino主机和从机之间进行数据传输。

在引用中的代码中，Wire库被用于设置Arduino Uno作为从机，并接收来自主机的数据。在setup()函数中，Wire.begin(4)用于初始化I2C总线，并将Arduino Uno的地址设置为4。Wire.onReceive(receiveEvent)用于注册一个回调函数receiveEvent，当主机发送数据时，该函数将被调用。在receiveEvent()函数中，通过Wire.available()检查是否有数据可用，然后使用Wire.read()读取数据，并通过Serial.print()将数据打印到串口。

在引用中的代码中，Wire库被用于设置Arduino Mega作为主机，并发送数据给从机。在setup()函数中，Wire.begin()用于初始化I2C总线。在loop()函数中，使用Wire.beginTransmission(4)开始向地址为4的从机发送数据。使用Wire.write()将数据写入发送缓冲区，然后使用Wire.endTransmission()发送数据。通过递增com变量，可以发送不同的数据。delay(500)用于延迟500毫秒。

Wire.h和Wire.c代码

Wire.h和Wire.c是Arduino中用于I2C通信的库文件，其中Wire.h是头文件，包含了I2C通信所需要的常量和函数的声明，而Wire.c是源文件，包含了I2C通信所需要的具体实现代码。

以下是Wire.h的代码示例：

#ifndef TwoWire_h
#define TwoWire_h

#include <inttypes.h>

#define BUFFER_LENGTH 32

class TwoWire {
  public:
    TwoWire();
    void begin();
    void begin(uint8_t);
    void begin(int);
    void end();
    void setClock(uint32_t);
    void setClockStretchLimit(uint32_t);
    void beginTransmission(uint8_t);
    void beginTransmission(int);
    uint8_t endTransmission(void);
    uint8_t endTransmission(uint8_t);
    uint8_t requestFrom(uint8_t, uint8_t);
    uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
    uint8_t requestFrom(int, int);
    uint8_t requestFrom(int, int, int);
    virtual size_t write(uint8_t);
    virtual size_t write(const uint8_t *, size_t);
    virtual int available(void);
    virtual int read(void);
    virtual int peek(void);
    virtual void flush(void);
    void onReceive(void(*)(int));
    void onRequest(void(*)(void));
    void onService(void);
  private:
    static uint8_t rxBuffer[];
    static uint8_t rxBufferIndex;
    static uint8_t rxBufferLength;
    static uint8_t txAddress;
    static uint8_t txBuffer[];
    static uint8_t txBufferIndex;
    static uint8_t txBufferLength;
    static uint8_t transmitting;
    static void (*user_onRequest)(void);
    static void (*user_onReceive)(int);
    static void onRequestService(void);
    static void onReceiveService(uint8_t*, int);
};

extern TwoWire Wire;

#endif

以下是Wire.c的代码示例：

#include "Wire.h"

#include <util/twi.h>

TwoWire Wire = TwoWire();

static void (*user_onRequest)(void);
static void (*user_onReceive)(int);

void onRequestService(void);
void onReceiveService(uint8_t*, int);

TwoWire::TwoWire() {
  rxBufferIndex = 0;
  rxBufferLength = 0;

  txBufferIndex = 0;
  txBufferLength = 0;

  transmitting = 0;

  user_onRequest = NULL;
  user_onReceive = NULL;
}

void TwoWire::begin() {
  twi_init();
}

void TwoWire::begin(uint8_t address) {
  twi_setAddress(address);
  twi_attachSlaveTxEvent(onRequestService);
  twi_attachSlaveRxEvent(onReceiveService);
  twi_init();
}

void TwoWire::begin(int address) {
  begin((uint8_t)address);
}

void TwoWire::end() {
  twi_disable();
}

void TwoWire::setClock(uint32_t frequency) {
  twi_setFrequency(frequency);
}

void TwoWire::setClockStretchLimit(uint32_t limit) {
  twi_setClockStretchLimit(limit);
}

uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity) {
  if(quantity > BUFFER_LENGTH){
    quantity = BUFFER_LENGTH;
  }
  rxBufferLength = quantity;
  rxBufferIndex = 0;

  twi_readFrom(address, rxBuffer, quantity);

  return quantity;
}

uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop) {
  twi_setStop(sendStop);
  return requestFrom(address, quantity);
}

uint8_t TwoWire::requestFrom(int address, int quantity) {
  return requestFrom((uint8_t)address, (uint8_t)quantity);
}

uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop) {
  return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)sendStop);
}

void TwoWire::beginTransmission(uint8_t address) {
  txAddress = address;
  txBufferLength = 0;
  transmitting = 1;
}

void TwoWire::beginTransmission(int address) {
  beginTransmission((uint8_t)address);
}

uint8_t TwoWire::endTransmission() {
  return endTransmission(true);
}

uint8_t TwoWire::endTransmission(uint8_t sendStop) {
  uint8_t ret = twi_writeTo(txAddress, txBuffer, txBufferLength, 1, sendStop);
  txBufferLength = 0;
  transmitting = 0;
  return ret;
}

size_t TwoWire::write(uint8_t data) {
  if(transmitting){
    if(txBufferLength >= BUFFER_LENGTH){
      return 0;
    }
    txBuffer[txBufferLength++] = data;
    return 1;
  }else{
    return 0;
  }
}

size_t TwoWire::write(const uint8_t *data, size_t quantity) {
  if(transmitting){
    for(size_t i = 0; i < quantity; ++i){
      if(txBufferLength >= BUFFER_LENGTH){
        return i;
      }
      txBuffer[txBufferLength++] = data[i];
    }
    return quantity;
  }else{
    return 0;
  }
}

int TwoWire::available(void) {
  return rxBufferLength - rxBufferIndex;
}

int TwoWire::read(void) {
  int value = -1;

  if(rxBufferIndex < rxBufferLength){
    value = rxBuffer[rxBufferIndex];
    ++rxBufferIndex;
  }

  return value;
}

int TwoWire::peek(void) {
  int value = -1;

  if(rxBufferIndex < rxBufferLength){
    value = rxBuffer[rxBufferIndex];
  }

  return value;
}

void TwoWire::flush(void) {
  // XXX: to be implemented.
}

void TwoWire::onReceive(void(*function)(int)) {
  user_onReceive = function;
}

void TwoWire::onRequest(void(*function)(void)) {
  user_onRequest = function;
}

void TwoWire::onService(void) {
  if(twi_isAddressed()){
    // onRequest callback
    if(twi_isMasterWrite()){
      if(user_onRequest){
        user_onRequest();
      }
    }
    // onReceive callback
    else {
      if(user_onReceive){
        user_onReceive(twi_receiveByte());
      }
    }
  }
}

void onRequestService(void) {
  if(Wire.user_onRequest){
    Wire.user_onRequest();
  }
}

void onReceiveService(uint8_t* inBytes, int numBytes) {
  Wire.rxBuffer = inBytes;
  Wire.rxBufferIndex = 0;
  Wire.rxBufferLength = numBytes;

  if(Wire.user_onReceive){
    Wire.user_onReceive(numBytes);
  }
}