MAX6956.cpp

Go to the documentation of this file.

// I2Cdev library collection - MAX6956 I2C device class
// Based on Maxim MAX6956 datasheet 19-2414; Rev 4; 6/10
//
// 2013-12-15 by Tom Beighley <tomthegeek@gmail.com>
// I2C Device Library hosted at http://www.i2cdevlib.com
//
// Changelog:
//     2013-12-15 - initial release
//

/* ============================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2013 Tom Beighley

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================
*/

#include "MAX6956.h"

MAX6956::MAX6956() {
    devAddr = MAX6956_DEFAULT_ADDRESS;
}

MAX6956::MAX6956(uint8_t address) {
    devAddr = address;
}

void MAX6956::initialize() {
    // Need this in setup() or here.
    // Fastwire::setup(400, false);
    reset();
    
    I2Cdev::writeByte(devAddr, MAX6956_RA_CONFIG_P7P6P5P4, 0x55);
    I2Cdev::writeByte(devAddr, MAX6956_RA_CONFIG_P11P10P9P8, 0x55);
}

bool MAX6956::testConnection() {
    if (I2Cdev::readByte(devAddr, MAX6956_RA_CONFIGURATION, buffer) == 1) {
        return true;
    }
    return false;
}

void MAX6956::reset() {
    disableAllPorts(); // set Port RA 0x2C-0x3F to 0
    setGlobalCurrent(0x00);  // Set global current to minimum on
    setConfigReg(0x00); // Shutdown Enabled,Current Control = Global, Transition Detection Disabled 
    setInputMask(0x00); // Set Input register mask to 0
    setTestMode(false); // disable test mode
    configAllPorts(MAX6956_INPUT_WO_PULL); // Configure all inputs as MAX6956_INPUT_WO_PULL
    setAllPortsCurrent(0x00); // Set current RA 0x16-01F to 0
}

uint8_t MAX6956::getConfigReg() {
    I2Cdev::readByte(devAddr, MAX6956_RA_CONFIGURATION, buffer);
    return buffer[0];
}
void MAX6956::setConfigReg(uint8_t config) {
    I2Cdev::writeByte(devAddr, MAX6956_RA_CONFIGURATION, config);
}

bool MAX6956::getPower() {
    I2Cdev::readBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_POWER_BIT, buffer);
    return buffer[0];
}
void MAX6956::setPower(bool power) {
    I2Cdev::writeBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_POWER_BIT, power);
}
void MAX6956::togglePower() {
    I2Cdev::readBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_POWER_BIT, buffer);
    buffer[0] = !(buffer[0]);
    I2Cdev::writeBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_POWER_BIT, buffer[0]);
}

bool MAX6956::getEnableIndividualCurrent() {
    I2Cdev::readBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_GLOBAL_CURRENT_BIT, buffer);
    return buffer[0];
}
void MAX6956::setEnableIndividualCurrent(bool global) {
    I2Cdev::writeBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_GLOBAL_CURRENT_BIT, global);
}

bool MAX6956::getEnableTransitionDetection() {
    I2Cdev::readBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_TRANSITION_BIT, buffer);
    return buffer[0];
}
void MAX6956::setEnableTransitionDetection(bool transition) {
    I2Cdev::writeBit(devAddr, MAX6956_RA_CONFIGURATION, MAX6956_CONFIG_TRANSITION_BIT, transition);
}

// Global Current
uint8_t MAX6956::getGlobalCurrent() {
    I2Cdev::readBits(devAddr, MAX6956_RA_GLOBAL_CURRENT, MAX6956_GLOBAL_CURRENT_BIT, MAX6956_GLOBAL_CURRENT_LENGTH, buffer);
    return buffer[0];
}
void MAX6956::setGlobalCurrent(uint8_t current) {
    I2Cdev::writeByte(devAddr, MAX6956_RA_GLOBAL_CURRENT, current);
}

// Test mode
bool MAX6956::getTestMode() {
    I2Cdev::readBit(devAddr, MAX6956_RA_DISPLAY_TEST, MAX6956_DISPLAY_TEST_BIT, buffer);
    return buffer[0];
}
void MAX6956::setTestMode(bool test) {
    I2Cdev::writeByte(devAddr, MAX6956_RA_DISPLAY_TEST, test);
}

// Input mask register
uint8_t MAX6956::getInputMask() {
    I2Cdev::readByte(devAddr, MAX6956_RA_TRANSITION_DETECT, buffer);
    return buffer[0];
}

void MAX6956::setInputMask(uint8_t mask) {
    I2Cdev::writeByte(devAddr, MAX6956_RA_TRANSITION_DETECT, mask);
}


void MAX6956::configPort(uint8_t port, uint8_t portConfig) {
    uint8_t bitPosition = (((port - 44) % 4) * 2) + 1; // bit position to start flipping 
    uint8_t pcArrayIndex = (port - 44) / 4; // array index
    uint8_t portConfigRA = pcArrayIndex + 11; // port config register
    I2Cdev::writeBits(devAddr, portConfigRA, bitPosition, 2, portConfig);
    // Update portConfig array
    bitPosition--; // Remove 1 bit offset
    portsConfig[pcArrayIndex] &=  ~(3 << bitPosition);
    portsConfig[pcArrayIndex] |=  portConfig << bitPosition;   
}

void MAX6956::configPorts(uint8_t lower, uint8_t upper, uint8_t portConfig) {

    Serial.print("lower ");
    Serial.print(lower, HEX);
    Serial.print(" upper ");
    Serial.print(upper, HEX);
    Serial.print(" portConfig ");
    Serial.println(portConfig, BIN);
    
    uint8_t bitPosition = 0;
    uint8_t pcArrayIndex = 0;
    uint8_t portConfigRA = 0;
    uint8_t i = lower;
    
    while ( i <= upper ) { 
        bitPosition = (((i - 44) % 4) * 2) + 1; // bit position to start flipping 
        pcArrayIndex = (i - 44) / 4; // array index
        portConfigRA = pcArrayIndex + 11; // port config register
        Serial.print("i ");
        Serial.print(i);
        Serial.print(" bitPosition ");
        Serial.print(bitPosition);
        Serial.print(" pcArrayIndex");
        Serial.print(pcArrayIndex);
        Serial.print(" portConfigRA ");
        Serial.println(portConfigRA, HEX);
        I2Cdev::writeBits(devAddr, portConfigRA, bitPosition, 2, portConfig);
        // Update portConfig array
        Serial.print("portsConfig ");
        Serial.print(portsConfig[pcArrayIndex], BIN);
        bitPosition--; // Remove 1 bit offset
        portsConfig[pcArrayIndex] &=  ~(3 << bitPosition); //3 == B00000011 Shift over correct number of bits then invert to create the mask
        portsConfig[pcArrayIndex] |=  portConfig << bitPosition; 
        Serial.print(" >> ");
        Serial.println(portsConfig[pcArrayIndex], BIN);
        i++;
    }
  
}

void MAX6956::configAllPorts(uint8_t portConfig) {
    // build byte with config bits shifted to all 4 slots
    portConfig = portConfig << 6 + portConfig << 4 + portConfig << 2 + portConfig;
    // copy byte to portsConfig array slots
    memset (portsConfig, portConfig, 5);
    // write bytes all at once to device
    I2Cdev::writeBytes(devAddr, MAX6956_RA_CONFIG_P15P14P13P12, 5, portsConfig);
}

void MAX6956::setPortLevel(uint8_t port, uint8_t power) {
    if ( port >= 44 && port <= 63 && power >= 0 && power <= 15 ) { 
        //power = sqrt(2) * power; // Convert linear to log scale

        psArrayIndex = (port - 44) / 8; // array index
        psBitPosition = (port - 44) % 8; // bit position to flip 

        if ( power > 0 ) { 
            // When not at 100% power decrement power by one because 0 is 
            // really an "on" power level and the lower levels are more important.
            if ( power < 15 ) power--;
            
            // Calculate current register from port address
            // set current bit offset
            if ( port % 2 ) { //port is odd
                portCurrentRA = (port - 1) / 2;
                portCurrentBit = 7;
            } 
            else {
                portCurrentRA = port / 2;
                portCurrentBit = 3;
            }
            
            // Write changes
            I2Cdev::writeBits(devAddr, portCurrentRA, portCurrentBit, 4, power); // Write changes
            I2Cdev::writeByte(devAddr, port, MAX6956_ON); // turn on port

            #ifdef MAX6956_SERIAL_DEBUG
                Serial.print("port ");
                Serial.print(port);
                Serial.print(" portCurrentBit ");
                Serial.print(portCurrentBit);
                Serial.print(" portCurrentRA ");
                Serial.print(portCurrentRA, HEX);
                Serial.print(" power ");
                Serial.println(power    );
            #endif
            // Update portStatus array
            portsStatus[psArrayIndex] |=  1 << psBitPosition;   
        } else {
            I2Cdev::writeByte(devAddr, port, MAX6956_OFF); // turn off port
            portsStatus[psArrayIndex] &=  ~(1 << psBitPosition);   // Update portStatus array

            #ifdef MAX6956_SERIAL_DEBUG
                Serial.print("port ");
                Serial.print(port);
                Serial.println(" is off");
            #endif
        }
    } 
}


void MAX6956::setPortCurrent(uint8_t port, uint8_t power) {
    if ( port >= 44 && port <= 63 && power >= 0 && power <= 15 ) { 
        //power = sqrt(2) * power; /** TODO Convert linear to log scale */

        psArrayIndex = (port - 44) / 8; // array index
        psBitPosition = (port - 44) % 8; // bit position to flip 

        // Calculate current register from port address
        // set current bit offset
        if ( port % 2 ) { //port is odd
            portCurrentRA = (port - 1) / 2;
            portCurrentBit = 7;
        } 
        else {
            portCurrentRA = port / 2;
            portCurrentBit = 3;
        }
        
        // Write changes
        I2Cdev::writeBits(devAddr, portCurrentRA, portCurrentBit, 4, power); // Write changes
        I2Cdev::writeByte(devAddr, port, MAX6956_ON); // turn on port

        #ifdef MAX6956_SERIAL_DEBUG
            Serial.print("port ");
            Serial.print(port);
            Serial.print(" portCurrentBit ");
            Serial.print(portCurrentBit);
            Serial.print(" portCurrentRA ");
            Serial.print(portCurrentRA, HEX);
            Serial.print(" power ");
            Serial.println(power    );
        #endif
        // Update portStatus array
        portsStatus[psArrayIndex] |=  1 << psBitPosition;   
    } 
}
void MAX6956::setAllPortsCurrent(uint8_t power) {
   for (int portCurrentRA=MAX6956_RA_CURRENT_0xP13P12; portCurrentRA <= MAX6956_RA_CURRENT_0xP31P30; portCurrentRA++){
    I2Cdev::writeByte(devAddr, portCurrentRA, power);
   } 
}

void MAX6956::enableAllPorts() {
    // set portStatus array to all 1's
    memset (portsStatus, 0xFF, 3);
    // write bytes
    I2Cdev::writeByte(devAddr, MAX6956_RA_PORTS12_19, portsStatus[0]);
    I2Cdev::writeByte(devAddr, MAX6956_RA_PORTS20_27, portsStatus[1]);
    I2Cdev::writeByte(devAddr, MAX6956_RA_PORTS28_31, portsStatus[2]);
}

void MAX6956::disableAllPorts() {
    // set portStatus array to all 0's
    memset (portsStatus, 0x00, 3);
    // write bytes
    I2Cdev::writeByte(devAddr, MAX6956_RA_PORTS12_19, portsStatus[0]);
    I2Cdev::writeByte(devAddr, MAX6956_RA_PORTS20_27, portsStatus[1]);
    I2Cdev::writeByte(devAddr, MAX6956_RA_PORTS28_31, portsStatus[2]);
}