BRIX5

/***************************************************

  This is a library for the Adafruit DRV2605L Haptic Driver

  ----> http://www.adafruit.com/products/2306

  Check out the links above for our tutorials and wiring diagrams

  This motor/haptic driver uses I2C to communicate

  Adafruit invests time and resources providing this open source code,

  please support Adafruit and open-source hardware by purchasing

  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.

  MIT license, all text above must be included in any redistribution

 ****************************************************/

#if ARDUINO >= 100

#include "Arduino.h"

#else

#include "WProgram.h"

#endif

#include "Adafruit_DRV2605.h"

/**************************************************************************/

/*!

    @brief  Instantiates a new DRV2605 class

*/

/**************************************************************************/

// I2C, no address adjustments or pins

Adafruit_DRV2605::Adafruit_DRV2605(uint8_t channel) {

  _channel = channel;

}

/**************************************************************************/

/*!

    @brief  Setups the HW

*/

/**************************************************************************/

boolean Adafruit_DRV2605::begin() {

  uint8_t id = readRegister8(DRV2605_REG_STATUS);

  //Serial.print("Status 0x"); Serial.println(id, HEX);

  writeRegister8(DRV2605_REG_MODE, 0x00); // out of standby

  writeRegister8(DRV2605_REG_RTPIN, 0x00); // no real-time-playback

  writeRegister8(DRV2605_REG_WAVESEQ1, 1); // strong click

  writeRegister8(DRV2605_REG_WAVESEQ2, 0);

  writeRegister8(DRV2605_REG_OVERDRIVE, 0); // no overdrive

  writeRegister8(DRV2605_REG_SUSTAINPOS, 0);

  writeRegister8(DRV2605_REG_SUSTAINNEG, 0);

  writeRegister8(DRV2605_REG_BREAK, 0);

  writeRegister8(DRV2605_REG_AUDIOMAX, 0x64);

  // ERM open loop

  // turn off N_ERM_LRA

  writeRegister8(DRV2605_REG_FEEDBACK, readRegister8(DRV2605_REG_FEEDBACK) & 0x7F);

  // turn on ERM_OPEN_LOOP

  writeRegister8(DRV2605_REG_CONTROL3, readRegister8(DRV2605_REG_CONTROL3) | 0x20);

  return true;

}

void Adafruit_DRV2605::setWaveform(uint8_t slot, uint8_t w) {

  writeRegister8(DRV2605_REG_WAVESEQ1 + slot, w);

}

void Adafruit_DRV2605::selectLibrary(uint8_t lib) {

  writeRegister8(DRV2605_REG_LIBRARY, lib);

}

void Adafruit_DRV2605::go() {

  writeRegister8(DRV2605_REG_GO, 1);

}

void Adafruit_DRV2605::setMode(uint8_t mode) {

  writeRegister8(DRV2605_REG_MODE, mode);

}

void Adafruit_DRV2605::setRealtimeValue(uint8_t rtp) {

  writeRegister8(DRV2605_REG_RTPIN, rtp);

}

/********************************************************************/

uint8_t Adafruit_DRV2605::readRegister8(uint8_t reg) {

  selectChannel(_channel);

  uint8_t x ;

  // use i2c

  Wire.beginTransmission(DRV2605_ADDR);

  Wire.write((byte)reg);

  Wire.endTransmission();

  Wire.requestFrom((byte)DRV2605_ADDR, (byte)1);

  x = Wire.read();

  //  Serial.print("$"); Serial.print(reg, HEX);

  //  Serial.print(": 0x"); Serial.println(x, HEX);

  return x;

}

void Adafruit_DRV2605::writeRegister8(uint8_t reg, uint8_t val) {

  selectChannel(_channel);

  // use i2c

  Wire.beginTransmission(DRV2605_ADDR);

  Wire.write((byte)reg);

  Wire.write((byte)val);

  Wire.endTransmission();

}

/****************/

// Allow users to use ERM motor or LRA motors

void Adafruit_DRV2605::useERM ()

{ 

  writeRegister8(DRV2605_REG_FEEDBACK, readRegister8(DRV2605_REG_FEEDBACK) & 0x7F);

}

void Adafruit_DRV2605::useLRA ()

{

  writeRegister8(DRV2605_REG_FEEDBACK, readRegister8(DRV2605_REG_FEEDBACK) | 0x80);

}

void Adafruit_DRV2605::selectChannel (uint8_t channel)

{

  // choose channel, all address bits to gnd on PCA9546A/TCA9548A = 0x70

  Wire.beginTransmission(0x70);

  Wire.write(1 << channel);

  Wire.endTransmission();

}

/***************************************************

  This is a library for the Adafruit DRV2605L Haptic Driver

  ----> http://www.adafruit.com/products/2305

  Check out the links above for our tutorials and wiring diagrams

  This motor/haptic driver uses I2C to communicate

  Adafruit invests time and resources providing this open source code,

  please support Adafruit and open-source hardware by purchasing

  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.

  MIT license, all text above must be included in any redistribution

 ****************************************************/

#if ARDUINO >= 100

#include "Arduino.h"

#else

#include "WProgram.h"

#endif

#if defined(__MK20DX128__) || defined(__MK20DX256__)

#include "i2c_t3.h"

#else

#include "Wire.h"

#endif

#define DRV2605_ADDR 0x5A

#define DRV2605_REG_STATUS 0x00

#define DRV2605_REG_MODE 0x01

#define DRV2605_MODE_INTTRIG  0x00

#define DRV2605_MODE_EXTTRIGEDGE  0x01

#define DRV2605_MODE_EXTTRIGLVL  0x02

#define DRV2605_MODE_PWMANALOG  0x03

#define DRV2605_MODE_AUDIOVIBE  0x04

#define DRV2605_MODE_REALTIME  0x05

#define DRV2605_MODE_DIAGNOS  0x06

#define DRV2605_MODE_AUTOCAL  0x07

#define DRV2605_REG_RTPIN 0x02

#define DRV2605_REG_LIBRARY 0x03

#define DRV2605_REG_WAVESEQ1 0x04

#define DRV2605_REG_WAVESEQ2 0x05

#define DRV2605_REG_WAVESEQ3 0x06

#define DRV2605_REG_WAVESEQ4 0x07

#define DRV2605_REG_WAVESEQ5 0x08

#define DRV2605_REG_WAVESEQ6 0x09

#define DRV2605_REG_WAVESEQ7 0x0A

#define DRV2605_REG_WAVESEQ8 0x0B

#define DRV2605_REG_GO 0x0C

#define DRV2605_REG_OVERDRIVE 0x0D

#define DRV2605_REG_SUSTAINPOS 0x0E

#define DRV2605_REG_SUSTAINNEG 0x0F

#define DRV2605_REG_BREAK 0x10

#define DRV2605_REG_AUDIOCTRL 0x11

#define DRV2605_REG_AUDIOLVL 0x12

#define DRV2605_REG_AUDIOMAX 0x13

#define DRV2605_REG_RATEDV 0x16

#define DRV2605_REG_CLAMPV 0x17

#define DRV2605_REG_AUTOCALCOMP 0x18

#define DRV2605_REG_AUTOCALEMP 0x19

#define DRV2605_REG_FEEDBACK 0x1A

#define DRV2605_REG_CONTROL1 0x1B

#define DRV2605_REG_CONTROL2 0x1C

#define DRV2605_REG_CONTROL3 0x1D

#define DRV2605_REG_CONTROL4 0x1E

#define DRV2605_REG_VBAT 0x21

#define DRV2605_REG_LRARESON 0x22

class Adafruit_DRV2605 {

  public:

    Adafruit_DRV2605(uint8_t channel);

    boolean begin(void);

    void selectChannel(uint8_t channel);

    void writeRegister8(uint8_t reg, uint8_t val);

    uint8_t readRegister8(uint8_t reg);

    void setWaveform(uint8_t slot, uint8_t w);

    void selectLibrary(uint8_t lib);

    void go(void);

    void setMode(uint8_t mode);

    void setRealtimeValue(uint8_t rtp);

    // Select ERM (Eccentric Rotating Mass) or LRA (Linear Resonant Actuator) vibration motor

    // The default is ERM, which is more common

    void useERM();

    void useLRA();

  private:

    uint8_t _channel;

};

// Demo Sketch for 4x TI DRV2605 and I2C MUX

//

// Usage:

// Serial Connect w/ 9600 baud

// 0-3 send a buzz on channel 0-3 respectively

#include "Adafruit_DRV2605.h"

const uint8_t channelCount = 4; // belt has 3 channels

Adafruit_DRV2605 drvs[channelCount] = {

  Adafruit_DRV2605(0),  

  Adafruit_DRV2605(1),

  Adafruit_DRV2605(2),

  Adafruit_DRV2605(3)

};

uint8_t library = 6; // LRA

char motor = '!'; // '!' = disabled

bool debug = false;

void setup() {

  Wire.begin();

  // wait for serial port to connect

  while (!Serial); 

  Serial.begin(9600);

  delay(250);

  for (uint8_t i = 0; i < channelCount; i++) {

    drvs[i].begin();

    drvs[i].selectLibrary(library);

    drvs[i].useLRA();

    drvs[i].setMode(DRV2605_MODE_REALTIME);

  }

}

void loop() {

  if (Serial.available()) {

    char cmd = Serial.read();

    if (debug) {

      Serial.print("Received: ");

      Serial.println(cmd);

    }

    uint8_t intensity = 0;

    int duration = 0;

    switch (cmd) {

      if (debug) {

          Serial.print("playing on channel ");

          Serial.println(cmd);

      }

      case ('0'):

      // single motor: play 'rare' case

      case ('0'):

      case ('1'):

      case ('2'):

      case ('3'): // disabled for 3 motors

        motor = cmd;

        intensity = 255;

        duration = 200;

    }

    if (intensity > 0) {

      // single channel

      // convert ASCII channel string to int

      uint8_t channel = ((uint8_t)motor) - 48;

      if ((motor != '!') && (channel < channelCount)) {

        playRTP(channel, intensity, duration);

        motor = '!'; // reset to normal mode

      } else {

        playRTP(intensity, duration);

      }

      intensity = 0;

      duration = 0;

    }

    if (debug) {

      Serial.println();

    }

  }

}

// all channels

void playRTP(uint8_t intensity, uint16_t duration) {

  if (debug) {

    Serial.print("Playing intensity ");

    Serial.print(intensity);

    Serial.print(" for ");

    Serial.print(duration);

    Serial.println("ms on all channels");

  }

  for (uint8_t channel; channel < channelCount; channel++) {

    drvs[channel].setRealtimeValue(intensity);

  }

  delay(duration);

  for (uint8_t channel; channel < channelCount; channel++) {

    drvs[channel].setRealtimeValue(0x00);

  }

}

// single channel

void playRTP(uint8_t channel, uint8_t intensity, uint16_t duration) {

  if (debug) {

    Serial.print("Playing intensity ");

    Serial.print(intensity);

    Serial.print(" for ");

    Serial.print(duration);

    Serial.print("ms on channel ");

    Serial.println(channel);

  }

  drvs[channel].setRealtimeValue(intensity);

  delay(duration);

  drvs[channel].setRealtimeValue(0x00);

}