> For the complete documentation index, see [llms.txt](https://docs.feelix.xyz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.feelix.xyz/downloads/arduino-library-documentation/i2c-communication/master-device.md).

# Master Device

{% hint style="info" %}
Download the library with example codes [here](/downloads/c-library.md#arduino-library-for-exported-feelix-effects). Version 1.8 and later.
{% endhint %}

Define the addresses for each of the slaves that will be connected to the master.

```objective-cpp
#define SLAVE_0_ADDRESS 0x70
#define SLAVE_1_ADDRESS 0x71
#define SLAVE_2_ADDRESS 0x72
```

Create MasterDevice object. \
Pass an array with the addresses of all slaves as argument.

<pre class="language-c++"><code class="lang-c++"><strong>uint8_t slaves[] = { SLAVE_0_ADDRESS, SLAVE_1_ADDRESS };
</strong>
/* initialize master device */
MasterDevice I2C_Master(slaves);
</code></pre>

#### Initialization

Initialize master device in **void setup()**

```objective-cpp
/* initialize as Master device */
I2C_Master.init(
    ESP32_SDA,              //I2C Data (SDA)
    ESP32_SCL,              //I2C Clock (SCL)
    CLOCK_SPEED::SLOW_MODE, //Clock frequency 
                            // CLOCK_SPEED::SLOW_MODE = 100000 
                            // CLOCK_SPEED::FAST_MODE = 400000 
    DEBUG,                  //(optional) 
                            // bool debug (set to false before production)
    callbackArr,            //(optional)
                            // array with callback functions (functionPtr)
    callbackLength);        //(optional) size of array
```

#### Receiving motor parameters

Request motor parameters (angle, velocity, voltage, status) from slave device in **void loop()**

```c++
I2C_Master.requestDeviceParameters(SLAVE_0_ADDRESS)
```

Create a callback function to receive the device parameters from the slave. Call before **void setup()**

```c++
/* callback to receive parameters from slave */
void callBack_receiveParameter_slave() {
    I2C_Master.receiveDeviceParameters(); // masterCallbackIndex 0
}

/* array to store callback functions */
const functionPtr callbackArr[] = { 
    callBack_receiveParameter_slave //masterCallbackIndex 0
};
/* calculate length of array (do not change) */
uint8_t callbackLength = sizeof(callbackArr)/sizeof(functionPtr);
```

The received data is stored in the following variables

```c++
I2C_Master.slaves[slaveIndex].motor.angle
I2C_Master.slaves[slaveIndex].motor.velocity
I2C_Master.slaves[slaveIndex].motor.voltage
I2C_Master.slaves[slaveIndex].motor.status
```

#### Sending variables to slave

Send a **float** variable to the slave. The function triggers a callback at the slave side at slaveCallbackIndex of the callback array.

* float data,&#x20;
* uint8\_t slaveAddress,&#x20;
* uint8\_t slaveCallbackIndex

```c++
 float velocity = 3.0; 
 I2C_Master.sendFloat(velocity, SLAVE_0_ADDRESS, 0);
```

Send an **integer** variable to the slave. The function triggers a callback at the slave side at slaveCallbackIndex of the callback array.

* int16\_t data,&#x20;
* uint8\_t slaveAddress,&#x20;
* uint8\_t slaveCallbackIndex

```c++
 int16_t randomVariable = random(10000);
 I2C_Master.sendInt(randomVariable, SLAVE_0_ADDRESS, 1);
```

Send a **byte** variable to the slave. The function triggers a callback at the slave side at slaveCallbackIndex of the callback array.

* uint8\_t data,&#x20;
* uint8\_t slaveAddress,&#x20;
* uint8\_t slaveCallbackIndex

```c++
 uint8_t activeEffect = !activeEffect;
 I2C_Master.sendByte(activeEffect, SLAVE_0_ADDRESS, 2);
```

Send a **char array** to the slave. The function triggers a callback at the slave side at slaveCallbackIndex of the callback array.

* char (\&data)\[]&#x20;
* uint16\_t dataSize
* uint8\_t slaveAddress,&#x20;
* uint8\_t slaveCallbackIndex

```objective-cpp
char arr[] = "hello";
I2C_Master.sendCharArray(arr, sizeof(arr), SLAVE_0_ADDRESS, 3);
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.feelix.xyz/downloads/arduino-library-documentation/i2c-communication/master-device.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.