update.

Author: yasir-shahzad

examples/CS5530_basic/CS5530_basic.ino

@@ -19,7 +19,7 @@ https://github.com/yasir-shahzad/CS5530
 
 #include "Arduino.h"
 
-#include "CS5530.h"
+#include <CS5530.h>
 #include "SPI.h"
 #include <avr/pgmspace.h>
 
@@ -34,40 +34,47 @@ void setup()
 
     if (cell.reset())
         Serial.println("CS5530 Initialized Successfully");
-    else
-        Serial.println("Starting CS5530 failed");
+    else {
+        Serial.println("CS5530 Initialization Failed");
+        while (1);
+    }
+        
 
     //  cell.CS5530_Write_Reg(CMD_GAIN_WRITE, 0x3);
 
-    uint32_t tmp = cell.getRegister(ConfigRead);
+   // uint32_t tmp = cell.getRegister(Command::ConfigRead);
+    uint32_t tmp = cell.getRegister(static_cast<uint8_t>(Command::ConfigRead));
+
     Serial.print("CONFIG Register:");
     Serial.println(tmp, BIN);
 
     // uint32_t tmpdata = REG_CONFIG_UNIPOLAR | REG
 
-    cell.setRegister(ConfigWrite, CS5530_UNIPOLAR);
+    cell.setRegister(static_cast<uint8_t>(Command::ConfigWrite), CS5530_UNIPOLAR);
 
-    cell.convert(CONTINUED_CONVERSION, 1, 1, (int)WORD_RATE_3200SPS);
+  //  cell.convert(CONTINUED_CONVERSION, 1, 1, (int)WORD_RATE_3200SPS);
 
-    uint32_t cmpl = cell.calculateTwoComplement(0xFFFFFFFF);
+   uint32_t cmpl = cell.calculateTwoComplement(0xFFFFFFFF);
 
-    cell.writeByte(CMD_CONVERSION_CONTINU);
-    cell.setRegister(CMD_OFFSET_WRITE, cmpl);
+   //cell.writeByte(ContinuousConversion);
+   cell.setRegister(OffsetWrite, cmpl);
 }
 
 void loop()
 {
     int32_t recData = cell.getReading();
 
+  Serial.println(recData);
     if (recData > 0)
     {
         value = 0.97 * value + 0.03 * recData; // running average
-        delay(5);
+         Serial.println(value);
+       // delay(5);
     }
 
     if (millis() > startTime)
     {
-        Serial.println(value);
+       
         //  Serial.println (String((value-111683)/18) + " grms");
         startTime = millis() + 200;
     }

src/CS5530.cpp

@@ -8,23 +8,23 @@
 
 CS5530::CS5530():
 _spiSettings(CS5530_DEFAULT_SPI_FREQUENCY, MSBFIRST, SPI_MODE0),
-_spi(&CS5530_DEFAULT_SPI), _ss(CS5530_SS)
+_spi(&CS5530_DEFAULT_SPI), _chipSelectPin(CS5530_SS)
 {
     _spi->begin();
 }
 
 int CS5530::begin()
 {
-    pinMode(_ss, OUTPUT);
-    digitalWrite(_ss, HIGH);
+    pinMode(_chipSelectPin, OUTPUT);
+    digitalWrite(_chipSelectPin, HIGH);
     _spi->begin();
 
     return 1;
 }
 
 void CS5530::setPin(int ss)
 {
-    _ss = ss;
+    _chipSelectPin = ss;
 }
 
 void CS5530::setSPI(SPIClass &spi)
@@ -54,7 +54,7 @@ bool CS5530::reset(void)
 
     tmp = getRegister(ConfigRead);
 //valid reset will set RV to 1
-    if (tmp & REG_CONFIG_RV) {
+    if (tmp & RESET_VALID) {
         return true;
     }
 
@@ -66,33 +66,31 @@ bool CS5530::reset(void)
 //x1, 2, 4, 8, 16, 32, 64 are avaialable
 bool CS5530::setGain(uint8_t gainValue)
 {
-    if (gainValue > 1 << 6)
-     gainValue = 1 << 6; //Error check
+  if (gainValue > 1 << 6)
+    gainValue = 1 << 6; // Error check
 
-    // Clear gain bits (bits 12, 13, 14, and 15)
-    registerValue &= ~(0b1111 << 12);
+  uint32_t value = getRegister(GainRead);
+  // Clear gain bits (bits 12, 13, 14, and 15)
+  value &= ~(0b1111 << 12);
+  // Mask in new bits
+  value |= (static_cast<uint32_t>(gainValue) << 12);
 
-   //Mask in new bits
-    registerValue |= (static_cast<uint32_t>(gainValue) << 12);
-
-    // Return true to indicate success
-    return true;
-    //TODO:
-   // return (setRegister(NAU7802_CTRL1, value));
+  // Return true to indicate success
+  return (setRegister(GainWrite, value));
 }
 
 //Set the readings per second
 //10, 20, 40, 80, and 320 samples per second is available
-bool CS5530::setSampleRate(uint8_t rate)
+bool CS5530::setSampleRate(uint32_t rate)
 {
   if (rate > 0b111)
     rate = 0b111; //Error check
 
-  uint8_t value = getRegister(NAU7802_CTRL2);
+  uint32_t value = getRegister(ConfigRead);
   value &= 0b10001111; //Clear CRS bits
-  value |= rate << 4;  //Mask in new CRS bits
+  value |= rate << 11;  //Mask in new CRS bits
 
-  return (setRegister(NAU7802_CTRL2, value));
+  return (setRegister(ConfigWrite, value));
 }
 
 //Call when scale is setup, level, at running temperature, with nothing on it
@@ -134,7 +132,7 @@ float CS5530::getCalibrationFactor()
 
 
 //Returns the y of y = mx + b using the current weight on scale, the cal factor, and the offset.
-float -CS5530::getWeight(bool allowNegativeWeights, uint8_t samplesToTake)
+float CS5530::getWeight(bool allowNegativeWeights, uint8_t samplesToTake)
 {
   int32_t onScale = getAverage(samplesToTake);
 
@@ -151,10 +149,10 @@ float -CS5530::getWeight(bool allowNegativeWeights, uint8_t samplesToTake)
   return (weight);
 }
 
-bool CS5530::setRegister(uint8_t reg, uint32_t dat)
+bool CS5530::setRegister(uint8_t command, uint32_t value)
 {
-  writeByte(reg);
-  write32(dat);
+  writeByte(command);
+  write32(value);
   return true;
 }
 
@@ -225,117 +223,65 @@ bool CS5530::getBit(uint8_t bitNumber, uint8_t registerAddress)
 // }
 
 void CS5530::writeByte(uint8_t data) {
-  digitalWrite(_ss, LOW);
+  digitalWrite(_chipSelectPin, LOW);
   _spi->beginTransaction(_spiSettings);
-  _spi->transfer(data);
+  _spi->transfer(data & 0xFF);
   _spi->endTransaction();
-  digitalWrite(_ss, HIGH);
+  digitalWrite(_chipSelectPin, HIGH);
 }
 
-
-// void CS5530::write32(uint32_t dat) {
-//     uint8_t i;
-//     uint8_t tmp;
-
-//     for(i=3; i>=0; i--) {
-//         tmp = (uint8_t)( (dat >> (8*i)) & 0xff);
-//         writeByte(tmp);
-//     }
-// }
-
 void CS5530::write32(uint32_t dat) 
 {
   for (int8_t i = 3; i >= 0; i--) {
       writeByte(static_cast<uint8_t>((dat >> (8 * i)) & 0xFF));
   }
 }
 
-// uint32_t CS5530::getRegister(uint8_t reg) {
-//     uint32_t dat;
-//     writeByte(reg);
-//     dat = read32();
-
-//     return dat;
-// }
-
-uint32_t CS5530::getRegister(uint8_t reg) {
-    writeByte(reg);
+uint32_t CS5530::getRegister(uint8_t command) {
+    writeByte(command);
     return read32();
 }
 
-
-// uint32_t CS5530::read32(void) {
-//     uint32_t dat = 0;
-
-//     for (int i = 0; i < 4; i++) {
-//         dat = (dat << 8) | readByte();
-//     }
-
-//     return dat;
-// }
-
 uint32_t CS5530::read32(void) {
   uint32_t result = 0;
-  
+
   for (int i = 0; i < 4; i++) {
-      result |= (static_cast<uint32_t>(readByte()) << (8 * i));
+    result = (result << 8) | readByte();
   }
-  
+
   return result;
 }
 
-
-// uint8_t CS5530::readByte(void) {
-//     uint8_t dat = 0;
-//     digitalWrite(_ss, LOW);
-//     _spi->beginTransaction(_spiSettings);
-//     dat = SPI.transfer(CMD_NULL);
-//     _spi->endTransaction();
-//     digitalWrite(_ss, HIGH);
-
-//     return dat;
-// }
-
-
 uint8_t CS5530::readByte() {
   uint8_t data = 0;
 
   _spi->beginTransaction(_spiSettings);
   digitalWrite(_chipSelectPin, LOW);
-  data = _spi->transfer(CMD_NULL);
+  data = _spi->transfer(Null);
   digitalWrite(_chipSelectPin, HIGH);
   _spi->endTransaction();
 
   return data;
 }
 
-
 bool CS5530::available(void) 
 {
   if(digitalRead(12) == 0)
-  {
       return true;
-  }
 
   return false;
 }
 
-uint32_t CS5530::getReading()
+int32_t CS5530::getReading()
 {
   if (!available())
-  {
-      // Return -2 for busy status
-      return -2;
-  }
-  
-  uint32_t rec_data = getRegister(CMD_NULL);
-  if ((rec_data & REG_DATA_OF) == 0)
-  {
+      return -2; // Return -2 for busy status
+
+  uint32_t recData = getRegister(Null);
+  if ((recData & REG_DATA_OF) == 0) {
       // Perform sign extension and return the result
-      return static_cast<int32_t>(rec_data << 24) >> 24;
-  }
-  else
-  {
+      return static_cast<int32_t>(recData << 24) >> 24;
+  } else {
       // Return -1 for overflow status
       return -1;
   }
@@ -426,14 +372,14 @@ uint8_t CS5530::convert(uint8_t convertType, uint8_t regNo, int wordRate)
         break;
     }
 
-    setRegister(CMD_WRITE_CFG_REG, cfgReg);
+    setRegister(ConfigWrite, cfgReg);
     writeByte(cmd);
     printf("Conversion begins...\n");
 
-    sleep(10);
+    delayMicroseconds(10); // waste some time
     u8 test = 0;
-    read_byte(&test, 1);
-    read_byte(convertResult, 4);
+   // readByte(&test, 1);
+   // readByte(convertResult, 4);
 
     Serial.print("The raw result is:");
     Serial.println(finalResult, BIN);

src/CS5530.h

@@ -11,6 +11,8 @@
 #ifndef CS5530_H
 #define CS5530_H
 
+#include <SPI.h>
+
 
 #define SYSTEM_OFFSET   3
 #define SYSTEM_GAIN     4
@@ -48,7 +50,7 @@ typedef enum {
  * @note This enumeration is based on the Tic Stepper Motor Controller User's Guide, available at
  * 
  */
-enum class Command : uint8_t
+typedef enum 
 {
     OffsetRead          = 0x09, ///< Read the offset value.
     OffsetWrite         = 0x01, ///< Write the offset value.
@@ -63,7 +65,7 @@ enum class Command : uint8_t
     Sync1               = 0xFF, ///< Part of the serial port re-initialization sequence.
     Sync0               = 0xFE, ///< End of the serial port re-initialization sequence.
     Null                = 0x00  ///< Clear a port flag and keep the converter in continuous conversion mode.
-};
+} Command;
 
 typedef enum
 {
@@ -150,10 +152,10 @@ class CS5530
     float getWeight(bool allowNegativeWeights = false, uint8_t samplesToTake = 8); //Once you've set zero offset and cal factor, you can ask the library to do the calculations for you.
 
     bool setGain(uint8_t gainValue); // Set the gain. x1, 2, 4, 8, 16, 32, 64, 128 are available
-    bool setSampleRate(uint8_t rate); // Set the readings per second. 10, 20, 40, 80, and 320 samples per second is available
+    bool setSampleRate(uint32_t rate); // Set the readings per second. 10, 20, 40, 80, and 320 samples per second is available
 
-    uint8_t getRegister(uint8_t registerAddress);             //Get contents of a register
-    bool setRegister(uint8_t registerAddress, uint32_t value); //Send a given value to be written to given address. Return true if successful
+    uint32_t getRegister(uint8_t commnad);             //Get contents of a register
+    bool setRegister(uint8_t command, uint32_t value); //Send a given value to be written to given address. Return true if successful
 
     uint8_t convert(uint8_t convertType, uint8_t regNo, int wordRate);
     uint8_t calibrate(uint8_t calibrateType, int cfgReg);
@@ -167,10 +169,13 @@ class CS5530
     private:
     SPISettings _spiSettings;
     SPIClass* _spi;
-    int _ss;
+    int _chipSelectPin;
+      //y = mx+b
+  int32_t _zeroOffset;      //This is b
+  float _calibrationFactor; //This is m. User provides this number so that we can output y when requested
 
     uint8_t readByte();
-    int32_t read32();
+    uint32_t read32();
     void write32(uint32_t value);
     void writeByte(uint8_t value);