Examples - Modules - Pressure

Pressure Sensor SCP1000

This Module can be used to plug a Pressure Sensor SCP1000 into your project. Connect your sensors to any digital pin on your board.


Download the source file

Table of contents

(top)

Source - modPressureSCP1000



/**************************************************************************************************
*
*  Pressure SCP1000
*
*   Version:      1.0.0 - Februar 2009
*   Author:       Christoph Wartmann / chair for caad - ETH Zürich  /  wartmann[at].arch.ethz.ch
*                 Etienne Ribeiro    / tutorial assistant caad      /  eribeiro[at]ethz.ch
*
*   Desc:         This Module makes it easy to run the SCP1000 Pressure Sensor in your projects.
*
*   Protocol:     SPI
*
*   Voltage:      typical 2.7V, max 3.3V
*
*   Features implemented:
*                 - SPI Protocol
*                 - all supported Operationmodes
*
*   Not yet implemented:
*                 - I2C (supported on Sparkfun Breakout; Software addresses!)
*                 - self test
*                 - [Operationmode 4 = Triggered Mode (Not supported on Sparkfun Breakout)]
*                 - Standby Mode
*                 - Interrupt
*                 - Reset
*
*  Pins:          use any digital pin. example:
*                 DRDY = 24; (optional)
*                 CSB = 25;
*                 DATAIN (MISO) = 26;
*                 DATAOUT (MOSI) = 27;
*                 SCK = 28;
*
*  Methodes:      boolean scp1000_AppendSensor (byte drdy, byte csb, byte datain, byte dataout, byte sckclock, byte Operationmode)
*                   drdy, csb, datain, dataout, sckclock: digital Pins, drdy is not needed and can be set to -1
*                   Operationmode:  0 = High speed (15bit, 9Hz), 1 = High resolution (17bit, 1.8Hz), 2 = Ultra low power (15bit, 1Hz)
*                   return false, if sensor coud not be initialized.
*                 void scp1000_setOperationMode(int modeid)
*                   change operation mode
*                   modeid:  0 = High speed (15bit, 9Hz), 1 = High resolution (17bit, 1.8Hz), 2 = Ultra low power (15bit, 1Hz)
*                 long scp1000_Read(char which)
*                   'p' = get pressure
*                   't' = get temperature
*                   's'= get status
*                   'o' = get operation mode
*                   'n' = get operation status
*                 void scp1000_parseDegrees (int val, int *retSign, int *ret1, int *ret2)
*                   Parse value to degrees. val = scp1000_Read('t') and scp1000_parseDegrees (val,...)
*                   *retSign: Return Value (sign) -1 or 1. Access this value by &var
*                   *ret1: Return Value (upper). Access this value by &var
*                   *ret2: Return Value (lower). Access this value by &var
*                 long scp1000_parsePa (long val)
*                   Parse value to Pascal. val = scp1000_Read('p') and scp1000_parsePa (val)
*                 void scp1000_parsePa (long val, long *ret1, long *ret2)
*                   Parse value to Pascal. val = scp1000_Read('p') and scp1000_parsePa (val,...)
*                   *ret1: Return Value (upper). Access this value by &var
*                   *ret2: Return Value (lower). Access this value by &var
*                 boolean scp1000_printStatus (byte state)
*                   Print current state of sensor. state = scp1000_Read('s') and scp1000_printStatus (state)
*                 boolean scp1000_printOperation (byte operation)
*                   Print operation mode. operationmode = scp1000_Read('o') and scp1000_printOperation (operationmode)
*
***************************************************************************************************/






//
// Const

// direct access:
#define Reg_REVID 0x00
#define Reg_DATAWR 0x01
#define Reg_ADDPTR 0x02
#define Reg_OPERATION 0x03
byte const Reg_OPERATION_modes[] = {0x09, 0x0A, 0x0B, 0x0C};  // (0x0C or TRIG pin)
#define Reg_OPSTATUS 0x04
#define Reg_RSTR 0x06
#define Reg_STATUS 0x07
byte const Reg_STATUS_startupbit = 0;
#define Reg_DATARD8 0x1F
byte const Reg_DATARD8_checksumerror = 0x00;
#define Reg_DATARD16 0x20 // 16bit
#define Reg_TEMPOUT 0x21 // 16bit
// indirect access:
#define Reg_CFG 0x00
#define Reg_TWIADD 0x05
#define Reg_USERDATA1 0x29
#define Reg_USERDATA2 0x2A
#define Reg_USERDATA3 0x2B
#define Reg_USERDATA4 0x2C


// more consts
int temp_factor = 20;
int pressure_factor = 4;


//
// Var

int scp1000_DRDY;        // 24 1: availability of new measurement
int scp1000_CSB;         // 25 selects the chip on multi-chip SPI bus
int scp1000_DATAIN;      // 26 MISO (Master In Slave Out)
int scp1000_DATAOUT;     // 27 MOSI (Master Out Slave In)
int scp1000_SCKCLOCK;    // 28 Clock




// *************************
//
//  Functions
//


//
// scp1000_AppendSensor
//  -> Operationmode: 0: High speed (15bit, 9Hz), 1: High resolution (17bit, 1.8Hz), 2: Ultra low power (15bit, 1Hz), [3 Low poser but triggerd (15bit to 17bit, 1.8Hz) not supported on Sparkfun Breakout]
boolean scp1000_AppendSensor (byte drdy, byte csb, byte datain, byte dataout, byte sckclock, byte Operationmode) {

        // Variables
        scp1000_DRDY = drdy;
        scp1000_CSB = csb;
        scp1000_DATAIN = datain;
        scp1000_DATAOUT = dataout;
        scp1000_SCKCLOCK = sckclock;


        // Pins
        pinMode(scp1000_DRDY, INPUT);
        pinMode(scp1000_CSB, OUTPUT);
        pinMode(scp1000_DATAOUT, OUTPUT);
        pinMode(scp1000_DATAIN, INPUT);
        pinMode(scp1000_SCKCLOCK, OUTPUT);
        digitalWrite(scp1000_CSB, HIGH); //disable device
        digitalWrite(scp1000_DATAOUT, LOW);
        digitalWrite(scp1000_SCKCLOCK, LOW);


        // startup device
        boolean success1 = scp1000_startup();
        boolean success2 = scp1000_checksumTest();
        if (success1 == false || success2==false)
        return false;


        // Select operation mode
        if (Operationmode < 0 || Operationmode > 3) Operationmode = 0;
        scp1000_setOperationMode (Operationmode); // Values 0 to 3


        // Return
        return true;

}



//
// Startup SCP1000

boolean scp1000_startup() {

        delay (60); // 60 ms startup delay

        for (int i=0;i<6;i++) { // check if startup has finished

                int val = scp1000_SPI_read8(Reg_STATUS);
                if (int(1<<Reg_STATUS_startupbit & val) == 0) // Startup successfully
                return true;
                delay (10);

        }

        return false; // start-up has failed

}



//
// Test Checksum

boolean scp1000_checksumTest() {

        int checksum = scp1000_SPI_read8(Reg_DATARD8);
        if (Reg_DATARD8_checksumerror == checksum) {// todo
                return false;
        }


        return true;

}



//
// Set operation mode

void scp1000_setOperationMode(int modeid) {

        // Stop active Mode (if SCP1000 is already powerd up and running)
        scp1000_SPI_write(Reg_OPERATION, 0x00);
        delay (50);


        // Check if DRDY is LOW (If DRDY is HIGH it is necessary to read the output data before activating new measurement mode)
        if (scp1000_DRDY != -1) {
                if (digitalRead(scp1000_DRDY) == HIGH)
                scp1000_SPI_read16(Reg_DATARD16);
        }


        // Select an operation mode
        byte cmd = Reg_OPERATION_modes[modeid]; // Command to write to register (0C)
        scp1000_SPI_write(Reg_OPERATION, cmd);

}




//
// scp1000_Read
//   'p' -> 16bit pressure, 't' -> 16bit temperature, 's' -> status, 'o' -> operation mode, 'n' -> operation status

long scp1000_Read(char which) {

        //
        long val;
        switch(which) {

                case 'P':case 'p': // 3bit + 16bit pressure

                val = scp1000_SPI_read8(Reg_DATARD8);
                val <<= 16;
                unsigned int tmpval;
                tmpval = scp1000_SPI_read16(Reg_DATARD16);
                val += tmpval;
                return val;

                case 'T':case 't': // 16bit temperature

                val = scp1000_SPI_read16(Reg_TEMPOUT);

                // if negativ value:
                if (int(1<<13 & val) != 0) {    // bit 13 == 1
                        val ^= 16383;                 // Invert 14 bits (16 bits would be 65535)
                        val += 1;                     // plus 1
                        val *= -1;
                }

                return val;
                break;

                case 'S':case 's': // status

                return scp1000_SPI_read8(Reg_STATUS);
                break;

                case 'O':case 'o': // operation mode

                return scp1000_SPI_read8(Reg_OPERATION);
                break;

                case 'N':case 'n': // operation status

                return scp1000_SPI_read8(Reg_OPSTATUS);
                break;

        }

}



//
// scp1000_parseDegrees
//   Parse Value to Degres

void scp1000_parseDegrees (int val, int *retSign, int *ret1, int *ret2) {

        *retSign = 1;
        if (val < 0)
        *retSign = -1;
        *ret1 = abs(val / temp_factor);
        *ret2 = abs(val  % temp_factor * 100 / temp_factor);

}



//
// scp1000_parseDegrees
//   Parse Value to Pascal

long scp1000_parsePa (long val) {

        long ret1;
        long ret2;
        scp1000_parsePa (val, &ret1, &ret2);
        return ret1;

}
void scp1000_parsePa (long val, long *ret1, long *ret2) {

        *ret1 = val / pressure_factor;
        *ret2 = abs(val  % pressure_factor * 100 / pressure_factor);

}




//
// scp1000_printStatus
//   Print status in natural language

boolean scp1000_printStatus (byte state) {

        Serial.print("Status: ");
        Serial.print(state, BIN);
        Serial.print(": ");
        if (int(1<<6 & state) != 0) // byte 0100 0000
        Serial.print (" Acquisition is running."); // externally triggered
        if (int(1<<5 & state) != 0) // byte 0010 0000
        Serial.print (" New results are available.");
        if (int(1<<4 & state) != 0) // byte 0001 0000
        Serial.print (" Real time error!"); // interrupt has not been serviced in time, cleared by DATARD16 read operation
        if (int(1<<0 & state) != 0) // byte 0000 0001
        Serial.print (" Start-up procedure still running");

}


//
// scp1000_printOperation
//   Print operation-register value in natural language

boolean scp1000_printOperation (byte operation) {

        Serial.print("Operation: 0x");
        Serial.print(operation, HEX);
        Serial.print(": ");

        switch (operation) {

                case 0x00:

                Serial.print (" NO OPERATION! Select an operation mode!");
                break;

                case 0x09:

                Serial.print (" High speed acquisition mode (continuous measurement).");
                break;

                case 0x0A:

                Serial.print (" High resolution acquisition mode (continuous measurement).");
                break;

                case 0x0B:

                Serial.print (" ultra low power acquisition mode (continuous measurement).");
                break;

                case 0x0C:

                Serial.print (" low power acquisition mode. (external TRIG, NOT SUPPORTED ON SPARKFUN BREAKOUT!)");
                break;

                default:

                Serial.print (" see Datasheet on page 18 Table 11");
                break;

        }

}









// ***************************
//
//  SPI - Functions
//



//
// SPI_write

void scp1000_SPI_write (byte registerByte, byte commandByte) {

        digitalWrite(scp1000_CSB, LOW); //turn on device

        // 6 bits register address
        for (int i=5; i>=0; i--){

                // write bit
                if (int(1<<i & registerByte) == 0) digitalWrite(scp1000_DATAOUT, LOW); else digitalWrite(scp1000_DATAOUT, HIGH);
                // cycle clock
                digitalWrite(scp1000_SCKCLOCK, HIGH);
                digitalWrite(scp1000_SCKCLOCK, LOW);

        }

        digitalWrite(scp1000_DATAOUT, HIGH); // Indicate that we are Writing
        digitalWrite(scp1000_SCKCLOCK, HIGH);
        digitalWrite(scp1000_SCKCLOCK, LOW);
        digitalWrite(scp1000_DATAOUT, LOW); // LOW
        digitalWrite(scp1000_SCKCLOCK, HIGH);
        digitalWrite(scp1000_SCKCLOCK, LOW);


        // write 8 bits register content
        for (int i=7; i>=0; i--){

                // write bit
                if (int(1<<i & commandByte) == 0) digitalWrite(scp1000_DATAOUT, LOW); else digitalWrite(scp1000_DATAOUT, HIGH);
                // cycle clock
                digitalWrite(scp1000_SCKCLOCK, HIGH);
                digitalWrite(scp1000_SCKCLOCK, LOW);

        }


        digitalWrite(scp1000_CSB, HIGH); //turn off device

}



//
// SPI_read8

int scp1000_SPI_read8 (byte registerByte) {

        digitalWrite(scp1000_CSB, LOW); //turn on device

        // 6 bits register address
        for (int i=5; i>=0; i--){

                // write bit
                if (int(1<<i & registerByte) == 0) digitalWrite(scp1000_DATAOUT, LOW); else digitalWrite(scp1000_DATAOUT, HIGH);
                // cycle clock
                digitalWrite(scp1000_SCKCLOCK, HIGH);
                digitalWrite(scp1000_SCKCLOCK, LOW);

        }

        digitalWrite(scp1000_DATAOUT, LOW); // Indicate that we are Reading
        digitalWrite(scp1000_SCKCLOCK, HIGH);
        digitalWrite(scp1000_SCKCLOCK, LOW);
        digitalWrite(scp1000_SCKCLOCK, HIGH);
        digitalWrite(scp1000_SCKCLOCK, LOW);

        // read 8 bits register content
        int returnValue = 0;
        for (int i=7; i>=0; i--){

                // read bit
                returnValue += digitalRead (scp1000_DATAIN) << i;
                // cycle clock
                digitalWrite(scp1000_SCKCLOCK, HIGH);
                digitalWrite(scp1000_SCKCLOCK, LOW);

        }


        digitalWrite(scp1000_CSB, HIGH); //turn off device

        return returnValue;

}



//
// SPI_read16

int scp1000_SPI_read16 (byte registerByte) {

        digitalWrite(scp1000_CSB, LOW); //turn on device

        // 6 bits register address
        for (int i=5; i>=0; i--){

                // write bit
                if (int(1<<i & registerByte) == 0) digitalWrite(scp1000_DATAOUT, LOW); else digitalWrite(scp1000_DATAOUT, HIGH);
                // cycle clock
                digitalWrite(scp1000_SCKCLOCK, HIGH);
                digitalWrite(scp1000_SCKCLOCK, LOW);

        }

        digitalWrite(scp1000_DATAOUT, LOW); // Indicate that we are Reading
        digitalWrite(scp1000_SCKCLOCK, HIGH);
        digitalWrite(scp1000_SCKCLOCK, LOW);
        digitalWrite(scp1000_SCKCLOCK, HIGH);
        digitalWrite(scp1000_SCKCLOCK, LOW);


        // read 8 bits register content
        int returnValue = 0;
        for (int i=15; i>=0; i--){

                // read bit
                returnValue += digitalRead (scp1000_DATAIN) << i;
                // cycle clock
                digitalWrite(scp1000_SCKCLOCK, HIGH);
                digitalWrite(scp1000_SCKCLOCK, LOW);

        }

        digitalWrite(scp1000_CSB, HIGH); //turn off device

        return returnValue;

}

(top)

Source - Main



/**************************************************************************************************
*
*  Pressure SCP1000
*
*   Version:      1.0.0 - Februar 2009
*   Author:       Christoph Wartmann / chair for caad - ETH Zürich  /  wartmann[at].arch.ethz.ch
*                 Etienne Ribeiro    / tutorial assistant caad      /  eribeiro[at]ethz.ch
*
*   Desc:         Shows the use of a SCP1000 Pressure Sensor using SPI.
*
***************************************************************************************************/




//
// Const

byte const DRDY = -1; // 24;        // 1: availability of new measurement
byte const CSB = 10; // 25;         // selects the chip on multi-chip SPI bus
byte const DATAIN = 11; // 26;      // MISO (Master In Slave Out)
byte const DATAOUT = 12; // 27;     // MOSI (Master Out Slave In)
byte const SCKCLOCK = 13; // 28;    // Clock
int onboardLED = 48; // Wiring-Board: Pin 48, Arduino: Pin 13



//
// Var

boolean startupDone;



//
// Setup

void setup(){

        // LED (2 * blink)
        pinMode(onboardLED, OUTPUT);
        digitalWrite(onboardLED, HIGH);
        delay(200);
        digitalWrite(onboardLED, LOW);
        delay(200);
        digitalWrite(onboardLED, HIGH);


        // Start Serial
        Serial.begin(9600);


        // Append Pressure Sensor
        //  -> Operationmode: 0: High speed (15bit, 9Hz), 1: High resolution (17bit, 1.8Hz), 2: Ultra low power (15bit, 1Hz), [3 Low poser but triggerd (15bit to 17bit, 1.8Hz) not supported on Sparkfun Breakout]
        byte operationmode = 1;
        startupDone = true;
        if (scp1000_AppendSensor (DRDY, CSB, DATAIN, DATAOUT, SCKCLOCK, operationmode) == false) {

                Serial.println ("Failed to startup Pressure Sensor");
                scp1000_printStatus(scp1000_Read('s'));
                startupDone = false;

        }


        // Operation Mode
        scp1000_printOperation(scp1000_Read('o'));
        Serial.println ("");
        // Operation Status
        Serial.print ("Operation Status: 0x");
        Serial.print (scp1000_Read('n'), HEX);
        Serial.println ("");

}




//
// Loop

void loop() {

        if (startupDone) {

                // Temperature
                int sign;
                int temp1;
                int temp2;
                scp1000_parseDegrees(scp1000_Read('t'), &sign, &temp1, &temp2);
                Serial.print ("TEMPERATURE: ");
                if (sign == -1)
                Serial.print ("-");
                Serial.print (temp1, DEC);
                Serial.print (".");
                Serial.print (temp2, DEC);
                Serial.print (" Grad C   ");
                // Pressure
                long pressure = scp1000_parsePa(scp1000_Read('p'));
                Serial.print ("PRESSURE: ");
                Serial.print (pressure);
                Serial.print (" Pa    ");
                // Hight
                long heightCm = scp1000_getHeightCM (pressure);
                Serial.print ("Height: ");
                Serial.print (heightCm);
                Serial.print (" cm");
                Serial.println ("");


                // Status
                scp1000_printStatus(scp1000_Read('s'));
                Serial.println ("");

        }


        // Take a break
        delay(100);

}