AMIS30543.h

Go to the documentation of this file.

// Copyright Pololu Corporation.  For more information, see http://www.pololu.com/

#pragma once

#include <stdint.h>
#include <Arduino.h>
#include <SPI.h>

class AMIS30543SPI
{
public:

    void init(uint8_t slaveSelectPin) { ssPin = slaveSelectPin;

        digitalWrite(ssPin, HIGH);
        pinMode(ssPin, OUTPUT);
    }

    uint8_t readReg(uint8_t address)
    {
        selectChip();
        transfer(address & 0b11111);
        uint8_t dataOut = transfer(0);
        deselectChip();
        return dataOut;
    }

    void writeReg(uint8_t address, uint8_t value)
    {
        selectChip();
        transfer(0x80 | (address & 0b11111));
        transfer(value);

        // The CS line must go high after writing for the value to actually take
        // effect.
        deselectChip();
    }

private:

    SPISettings settings = SPISettings(500000, MSBFIRST, SPI_MODE0);

    uint8_t transfer(uint8_t value)
    {
        return SPI.transfer(value);
    }

    void selectChip()
    {
        digitalWrite(ssPin, LOW);
        SPI.beginTransaction(settings);
    }

    void deselectChip()
    {
       digitalWrite(ssPin, HIGH);
       SPI.endTransaction();

       // The CS high time is specified as 2.5 us in the AMIS-30543 datasheet.
       delayMicroseconds(3);
    }

    uint8_t ssPin;
};

class AMIS30543
{
public:
    AMIS30543()
    {
        wr = cr0 = cr1 = cr2 = cr3 = 0;
    }

    enum stepMode
    {
        MicroStep128 = 128,
        MicroStep64 = 64,
        MicroStep32 = 32,
        MicroStep16 = 16,
        MicroStep8 = 8,
        MicroStep4 = 4,
        MicroStep2 = 2,
        MicroStep1 = 1,
        CompensatedHalf = MicroStep2,
        CompensatedFullTwoPhaseOn = MicroStep1,
        CompensatedFullOnePhaseOn = 200,
        UncompensatedHalf = 201,
        UncompensatedFull = 202,
    };

    enum nonLatchedStatusFlag
    {
        OPENY = (1 << 2),
        OPENX = (1 << 3),
        WD = (1 << 4),
        CPFAIL = (1 << 5),
        TW = (1 << 6),
    };

    enum latchedStatusFlag
    {
        OVCXNB = (1 << 3),
        OVCXNT = (1 << 4),
        OVCXPB = (1 << 5),
        OVCXPT = (1 << 6),
        TSD = (1 << 10),
        OVCYNB = (1 << 11),
        OVCYNT = (1 << 12),
        OVCYPB = (1 << 13),
        OVCYPT = (1 << 14),
    };

    enum regAddr
    {
        WR  = 0x0,
        CR0 = 0x1,
        CR1 = 0x2,
        CR2 = 0x3,
        CR3 = 0x9,
        SR0 = 0x4,
        SR1 = 0x5,
        SR2 = 0x6,
        SR3 = 0x7,
        SR4 = 0xA,
    };

    void init(uint8_t slaveSelectPin)
    {
        driver.init(slaveSelectPin);
    }

    void resetSettings()
    {
        wr = cr0 = cr1 = cr2 = cr3 = 0;
        applySettings();
    }

    bool verifySettings()
    {
        return driver.readReg(WR) == wr &&
            driver.readReg(CR0) == cr0 &&
            driver.readReg(CR1) == cr1 &&
            driver.readReg(CR2) == cr2 &&
            driver.readReg(CR3) == cr3;
    }

    void applySettings()
    {
        // Because of power interruption considerations, the register that
        // contains the MOTEN bit (CR2) must be written first, and whenever we
        // write to it we should also write to all the other registers.

        // CR2 is written first, because it contains the MOTEN bit, and there is
        // a risk that there might be a power interruption to the driver right
        // before CR2 is written.  This could result in the motor being enabled
        // with incorrect settings.  Also, whenever we do write to CR2, we want to
        // also write the other registers to make sure they are in the correct state.
        driver.writeReg(CR2, cr2);

        writeWR();
        writeCR0();
        writeCR1();
        writeCR3();
    }

    void enableDriver()
    {
        cr2 |= 0b10000000;
        applySettings();
    }

    void disableDriver()
    {
        cr2 &= ~0b10000000;
        applySettings();
    }

    void setCurrentMilliamps(uint16_t current)
    {
        // This comes from Table 13 of the AMIS-30543 datasheet.
        uint8_t code = 0;
        if      (current >= 3000) { code = 0b11001; }
        else if (current >= 2845) { code = 0b11000; }
        else if (current >= 2700) { code = 0b10111; }
        else if (current >= 2440) { code = 0b10110; }
        else if (current >= 2240) { code = 0b10101; }
        else if (current >= 2070) { code = 0b10100; }
        else if (current >= 1850) { code = 0b10011; }
        else if (current >= 1695) { code = 0b10010; }
        else if (current >= 1520) { code = 0b10001; }
        else if (current >= 1405) { code = 0b10000; }
        else if (current >= 1260) { code = 0b01111; }
        else if (current >= 1150) { code = 0b01110; }
        else if (current >= 1060) { code = 0b01101; }
        else if (current >=  955) { code = 0b01100; }
        else if (current >=  870) { code = 0b01011; }
        else if (current >=  780) { code = 0b01010; }
        else if (current >=  715) { code = 0b01001; }
        else if (current >=  640) { code = 0b01000; }
        else if (current >=  585) { code = 0b00111; }
        else if (current >=  540) { code = 0b00110; }
        else if (current >=  485) { code = 0b00101; }
        else if (current >=  445) { code = 0b00100; }
        else if (current >=  395) { code = 0b00011; }
        else if (current >=  355) { code = 0b00010; }
        else if (current >=  245) { code = 0b00001; }

        cr0 = (cr0 & 0b11100000) | code;
        writeCR0();
    }

    uint16_t readPosition()
    {
        uint8_t sr3 = readStatusReg(SR3);
        uint8_t sr4 = readStatusReg(SR4);
        return ((uint16_t)sr3 << 2) | (sr4 & 3);
    }

    void setDirection(bool value)
    {
        if (value)
        {
            cr1 |= 0x80;
        }
        else
        {
            cr1 &= ~0x80;
        }
        writeCR1();
    }

    bool getDirection()
    {
        return cr1 >> 7 & 1;
    }

    void setStepMode(uint8_t mode)
    {
        // Pick 1/32 micro-step by default.
        uint8_t esm = 0b000;
        uint8_t sm = 0b000;

        // The order of these cases matches the order in Table 12 of the
        // AMIS-30543 datasheet.
        switch(mode)
        {
        case MicroStep32: sm = 0b000; break;
        case MicroStep16: sm = 0b001; break;
        case MicroStep8: sm = 0b010; break;
        case MicroStep4: sm = 0b011; break;
        case CompensatedHalf: sm = 0b100; break; /* a.k.a. MicroStep2 */
        case UncompensatedHalf: sm = 0b101; break;
        case UncompensatedFull: sm = 0b110; break;
        case MicroStep128: esm = 0b001; break;
        case MicroStep64: esm = 0b010; break;
        case CompensatedFullTwoPhaseOn: esm = 0b011; break;  /* a.k.a. MicroStep 1 */
        case CompensatedFullOnePhaseOn: esm = 0b100; break;
        }

        cr0 = (cr0 & ~0b11100000) | (sm << 5);
        cr3 = (cr3 & ~0b111) | esm;
        writeCR0();
        writeCR3();
    }

    void sleep()
    {
        cr2 |= (1 << 6);
        applySettings();
    }

    void sleepStop()
    {
        cr2 &= ~(1 << 6);
        applySettings();
    }

    void stepOnRisingEdge()
    {
        cr1 &= ~0b01000000;
        writeCR1();
    }

    void stepOnFallingEdge()
    {
        cr1 |= 0b01000000;
        writeCR1();
    }

    void setPwmFrequencyDouble()
    {
        cr1 |= (1 << 3);
        writeCR1();
    }

    void setPwmFrequencyDefault()
    {
        cr1 &= ~(1 << 3);
        writeCR1();
    }

    void setPwmJitterOn()
    {
        cr1 |= (1 << 2);
        writeCR1();
    }

    void setPwmJitterOff()
    {
        cr1 &= ~(1 << 2);
        writeCR1();
    }

    void setPwmSlope(uint8_t emc)
    {
        cr1 = (cr1 & ~0b11) | (emc & 0b11);
        writeCR1();
    }

    void setSlaGainDefault()
    {
        cr2 &= ~(1 << 5);
        applySettings();
    }

    void setSlaGainHalf()
    {
        cr2 |= (1 << 5);
        applySettings();
    }

    void setSlaTransparencyOff()
    {
        cr2 &= ~(1 << 4);
        applySettings();
    }

    void setSlaTransparencyOn()
    {
        cr2 |= (1 << 4);
        applySettings();
    }

    uint16_t readNonLatchedStatusFlags()
    {
        return readStatusReg(SR0);
    }

    uint16_t readLatchedStatusFlagsAndClear()
    {
        uint8_t sr1 = readStatusReg(SR1);
        uint8_t sr2 = readStatusReg(SR2);
        return (sr2 << 8) | sr1;
    }

protected:

    uint8_t wr, cr0, cr1, cr2, cr3;

    uint8_t readStatusReg(uint8_t address)
    {
        // Mask off the parity bit.
        // (Later we might add code here to check the parity
        // bit and record errors.)
        return driver.readReg(address) & 0x7F;
    }

    void writeWR()
    {
        driver.writeReg(WR, wr);
    }

    void writeCR0()
    {
        driver.writeReg(CR0, cr0);
    }

    void writeCR1()
    {
        driver.writeReg(CR1, cr1);
    }

    void writeCR3()
    {
        driver.writeReg(CR3, cr3);
    }

public:
    AMIS30543SPI driver;
};