0.1.1 PCA9632

Author: RobTillaart

libraries/PCA9632/CHANGELOG.md

@@ -6,6 +6,23 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 
+
+
+## [0.1.1] - 2025-05-05
+- fix #2, wrong color
+- fix version number in library.properties
+- give **writeRegister() / readRegister()** full name.
+- add **PCA9632_AUTO_INCR_ALL** in **write(array)**
+- add **allOff()**
+- sync PCA9634 (not tested)
+  - add **getGroupPWM() + setGroupPWM(uint8_t value)**
+  - add **getGroupFREQ() + setGroupFREQ(uint8_t value)**
+  - add **subCall()** and **allCall()** functions.
+- update readme.md
+- update keywords.txt
+- minor edits
+
+
 ## [0.1.0] - 2024-11-25
 - initial version
 

libraries/PCA9632/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024-2024 Rob Tillaart
+Copyright (c) 2024-2025 Rob Tillaart
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

libraries/PCA9632/PCA9632.cpp

@@ -2,13 +2,21 @@
 //    FILE: PCA9632.cpp
 //  AUTHOR: Rob Tillaart
 //    DATE: 2024-11-25
-// VERSION: 0.1.0
-// PURPOSE: Arduino library for PCA9632 and PCA9633 4 channel, I2C LED driver.
+// VERSION: 0.1.1
+// PURPOSE: Arduino library for PCA9632 and PCA9633 I2C 8 bit PWM LED driver, 4 channel.
 //     URL: https://github.com/RobTillaart/PCA9632
 
 
 #include "PCA9632.h"
 
+#define PCA9632_NO_INCREMENT      0x00
+#define PCA9632_AUTO_INCR_ALL     0x80
+//  not used.
+//  #define PCA963X_AUTO_INCR_xxx    0xA0
+//  #define PCA963X_AUTO_INCR_xxx    0xC0
+//  #define PCA963X_AUTO_INCR_xxx    0xE0
+
+
 
 //////////////////////////////////////////////////////////////
 //
@@ -46,28 +54,34 @@ uint8_t PCA9632::getAddress()
 }
 
 
+uint8_t PCA9632::channelCount()
+{
+  return 4;
+}
+
+
 /////////////////////////////////////////////////////
 //
 //  WRITE
 //
 uint8_t PCA9632::writeR(uint8_t R)
 {
-  return writeReg(PCA9632_PWM0, R);
+  return writeRegister(PCA9632_PWM0, R);
 }
 
 uint8_t PCA9632::writeG(uint8_t G)
 {
-  return writeReg(PCA9632_PWM1, G);
+  return writeRegister(PCA9632_PWM1, G);
 }
 
 uint8_t PCA9632::writeB(uint8_t B)
 {
-  return writeReg(PCA9632_PWM2, B);
+  return writeRegister(PCA9632_PWM2, B);
 }
 
 uint8_t PCA9632::writeW(uint8_t W)
 {
-  return writeReg(PCA9632_PWM3, W);
+  return writeRegister(PCA9632_PWM3, W);
 }
 
 uint8_t PCA9632::write(uint8_t channel, uint8_t value)
@@ -77,7 +91,7 @@ uint8_t PCA9632::write(uint8_t channel, uint8_t value)
     _error = PCA9632_ERR_CHAN;
     return _error;
   }
-  return writeReg(PCA9632_PWM0 + channel, value);
+  return writeRegister(PCA9632_PWM0 + channel, value);
 }
 
 uint8_t PCA9632::write(uint8_t R, uint8_t G, uint8_t B, uint8_t W)
@@ -90,7 +104,8 @@ uint8_t PCA9632::write(uint8_t R, uint8_t G, uint8_t B, uint8_t W)
 uint8_t PCA9632::write(uint8_t * arr)
 {
   _wire->beginTransmission(_address);
-  _wire->write(PCA9632_PWM0);
+  //  auto increment all  page 8 - table 5.
+  _wire->write(PCA9632_AUTO_INCR_ALL + PCA9632_PWM0);
   for (uint8_t i = 0; i < 4; i++)
   {
     _wire->write(arr[i]);
@@ -105,33 +120,208 @@ uint8_t PCA9632::write(uint8_t * arr)
   return _error;
 }
 
+uint8_t PCA9632::allOff()
+{
+  uint8_t arr[4] = {0, 0, 0, 0};
+  return write(arr);
+}
+
 
 /////////////////////////////////////////////////////
 //
 //  WRITE MODE REGISTERS
 //
 uint8_t PCA9632::setMode1(uint8_t value)
 {
-  return writeReg(PCA9632_MODE1, value);
+  return writeRegister(PCA9632_MODE1, value);
 }
 
-
 uint8_t PCA9632::setMode2(uint8_t value)
 {
-  return writeReg(PCA9632_MODE2, value);
+  return writeRegister(PCA9632_MODE2, value);
 }
 
-
 uint8_t PCA9632::getMode1()
 {
-  return readReg(PCA9632_MODE1);
+  return readRegister(PCA9632_MODE1);
 }
 
-
 uint8_t PCA9632::getMode2()
 {
-  return readReg(PCA9632_MODE2);
+  return readRegister(PCA9632_MODE2);
+}
+
+
+/////////////////////////////////////////////////////
+//
+//  GROUP REGISTERS
+//
+uint8_t PCA9632::setGroupPWM(uint8_t value)
+{
+  return writeRegister(PCA9632_GRPPWM, value);
+}
+
+uint8_t PCA9632::getGroupPWM()
+{
+  return readRegister(PCA9632_GRPPWM);
+}
+
+uint8_t PCA9632::setGroupFREQ(uint8_t value)
+{
+  return writeRegister(PCA9632_GRPFREQ, value);
+}
+
+uint8_t PCA9632::getGroupFREQ()
+{
+  return readRegister(PCA9632_GRPFREQ);
+}
+
+
+/////////////////////////////////////////////////////
+//
+//  SUB CALL - to be tested
+//
+bool PCA9632::enableSubCall(uint8_t nr)
+{
+  if ((nr == 0) || (nr > 3)) return false;
+  uint8_t prev = getMode1();
+  uint8_t mask = prev;
+  if (nr == 1)      mask |= PCA9632_MODE1_SUB1;
+  else if (nr == 2) mask |= PCA9632_MODE1_SUB2;
+  else              mask |= PCA9632_MODE1_SUB3;
+  //  only update if changed.
+  if (mask != prev)
+  {
+    setMode1(mask);
+    //  TODO error handling ...
+  }
+  return true;
+}
+
+
+bool PCA9632::disableSubCall(uint8_t nr)
+{
+  if ((nr == 0) || (nr > 3)) return false;
+  uint8_t prev = getMode1();
+  uint8_t mask = prev;
+  if (nr == 1)      mask &= ~PCA9632_MODE1_SUB1;
+  else if (nr == 2) mask &= ~PCA9632_MODE1_SUB2;
+  else              mask &= ~PCA9632_MODE1_SUB3;
+  //  only update if changed.
+  if (mask != prev)
+  {
+    setMode1(mask);
+    //  TODO error handling ...
+  }
+  return true;
+}
+
+
+bool PCA9632::isEnabledSubCall(uint8_t nr)
+{
+  if ((nr == 0) || (nr > 3)) return false;
+  uint8_t mask = getMode1();
+  if (nr == 1) return (mask & PCA9632_MODE1_SUB1) > 0;
+  if (nr == 2) return (mask & PCA9632_MODE1_SUB2) > 0;
+  return (mask & PCA9632_MODE1_SUB3) > 0;
+}
+
+
+bool PCA9632::setSubCallAddress(uint8_t nr, uint8_t address)
+{
+  if ((nr == 0) || (nr > 3))
+  {
+    //  _error = ??  TODO
+    return false;
+  }
+  writeRegister(PCA9632_SUBADR(nr), address);
+  return true;
 }
+
+
+uint8_t PCA9632::getSubCallAddress(uint8_t nr)
+{
+  if ((nr == 0) || (nr > 3))
+  {
+    //  _error = ??  TODO
+    return 0;
+  }
+  uint8_t address = readRegister(PCA9632_SUBADR(nr));
+  return address;
+}
+
+
+/////////////////////////////////////////////////////
+//
+//  ALL CALL - to be tested
+//
+bool PCA9632::enableAllCall()
+{
+  uint8_t prev = getMode1();
+  uint8_t mask = prev | PCA9632_MODE1_ALLCALL;
+  //  only update if changed.
+  if (mask != prev)
+  {
+    setMode1(mask);
+    //  error handling TODO
+  }
+  return true;
+}
+
+
+bool PCA9632::disableAllCall()
+{
+  uint8_t prev = getMode1();
+  uint8_t mask = prev & ~PCA9632_MODE1_ALLCALL;
+  //  only update if changed.
+  if (mask != prev)
+  {
+    setMode1(mask);
+    //  error handling TODO
+  }
+  return true;
+}
+
+
+bool PCA9632::isEnabledAllCall()
+{
+  uint8_t mask = getMode1();
+  return (mask & PCA9632_MODE1_ALLCALL) > 0;
+}
+
+
+bool PCA9632::setAllCallAddress(uint8_t address)
+{
+  writeRegister(PCA9632_ALLCALLADR, address);
+  return true;
+}
+
+
+uint8_t PCA9632::getAllCallAddress()
+{
+  uint8_t address = readRegister(PCA9632_ALLCALLADR);
+  return address;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 /////////////////////////////////////////////////////
@@ -147,7 +337,7 @@ uint8_t PCA9632::setLedDriverModeAll(uint8_t mode)
   }
   //  all 4 channels same mode.
   uint8_t mask = mode | mode << 2 | mode << 4 | mode << 6;
-  return writeReg(PCA9632_LEDOUT, mask);
+  return writeRegister(PCA9632_LEDOUT, mask);
 }
 
 
@@ -168,8 +358,8 @@ uint8_t PCA9632::setLedDriverMode(uint8_t channel, uint8_t mode)
   uint8_t shift = channel * 2;  // 0,2,4,6 places
   uint8_t setmask = mode << shift;
   uint8_t clrmask = ~(0x03 << shift);
-  uint8_t value = (readReg(PCA9632_LEDOUT) & clrmask) | setmask;
-  return writeReg(PCA9632_LEDOUT, value);
+  uint8_t value = (readRegister(PCA9632_LEDOUT) & clrmask) | setmask;
+  return writeRegister(PCA9632_LEDOUT, value);
 }
 
 
@@ -183,7 +373,7 @@ uint8_t PCA9632::getLedDriverMode(uint8_t channel)
   }
 
   uint8_t shift = channel * 2;  //  0, 2, 4, 6 places
-  uint8_t value = (readReg(PCA9632_LEDOUT) >> shift ) & 0x03;
+  uint8_t value = (readRegister(PCA9632_LEDOUT) >> shift ) & 0x03;
   _error = PCA9632_OK;
   return value;
 }
@@ -204,9 +394,10 @@ int PCA9632::lastError()
 //
 //  LOW LEVEL
 //
-uint8_t PCA9632::writeReg(uint8_t reg, uint8_t value)
+uint8_t PCA9632::writeRegister(uint8_t reg, uint8_t value)
 {
   _wire->beginTransmission(_address);
+  //  no Auto-Increment  page 8 - table 5.
   _wire->write(reg);
   _wire->write(value);
   _error = _wire->endTransmission();
@@ -216,7 +407,7 @@ uint8_t PCA9632::writeReg(uint8_t reg, uint8_t value)
 }
 
 
-uint8_t PCA9632::readReg(uint8_t reg)
+uint8_t PCA9632::readRegister(uint8_t reg)
 {
   _wire->beginTransmission(_address);
   _wire->write(reg);