MSS
Maxim DS1683 Total-Elapsed -Time and Event Recorder with Alarm
Diff: DS1683.cpp
- Revision:
- 0:7c0469e71fa2
- Child:
- 1:8fa5400054bd
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/DS1683.cpp Wed Jan 18 23:26:24 2017 +0000
@@ -0,0 +1,391 @@
+#include "mbed.h"
+#include "DS1683.h"
+
+/* ETC stands for Elapsed Time Counter */
+
+/* Command Register */
+#define REG_COMMAND 0x00
+/* Status Register */
+#define REG_STATUS 0x01
+/* Password Entry Register 0x02 - 0x05 */
+#define REG_PWE 0x02
+/* Event Counter Register 0x08 - 0x09 */
+#define REG_EVENT 0x08
+/* ETC Register */
+#define REG_ETC 0x0A
+/* Event Counter Alarm Limit Register 0x10 - 0x11 */
+#define REG_ECAL 0x10
+/* ETC Alarm Limit Register 0x12 - 0x15 */
+#define REG_ETCAL 0x12
+/* Configuration Register */
+#define REG_CONFIG 0x16
+/* Password Value 0x1A - 0x1D */
+#define REG_PWV 0x1A
+/* User EEPROM 0x20 - 0x2F */
+#define REG_USR 0x20
+
+/* Command Register Bits */
+/* bit[7:1] Reserved */
+/* bit[0] CLR_ALM write 1 to unlatch the acvie ALARM output */
+// Clear Alarm Bit. This bit reads as a 0. Writing this bit to a 1
+// unlatches the active ALARM output, setting the ALARM pin to
+// its inactive state if the alarm condition is no longer present.
+// If the alarm condition persists, the ALARM pin once again
+// asserts to its active state.
+#define CLR_ALM_BIT 0x01
+
+/* Status Register Bits */
+/* bit[7:3] Reserved */
+/* bit[2] EVENT */
+// This bit indicates the status of the EVENT pin's logic level,
+// detected after the tG glitch filter time.
+#define EVENT_BIT 0x04
+
+/* bit[1] EVENT AF */
+// Default value = 0. If the value in the Event Counter SRAM value is
+// greater than or equal to the Event Counter Alarm Limit value,
+// then this bit is automatically set to a value of 1 to indecate
+// the ALARM event. When the EVENT SRAM Counter value is less than
+// the Event Counter Alarm Limit, this bit automatically set to a value of 0,
+// indicating that there is no EVENT alarm.
+#define EVENT_AF_BIT 0x02
+
+/* bit[0] ETC AF */
+// Default value = 0. If the value in the ETC SRAM value is greater than
+// or equal to the ETC Alarm Limit value, then this bit is automatically
+// set to a value of 1 to indicate an ALARM event. When the ETC SRAM value
+// is less than the ETC Alarm Limit, this bit automatically set to a value of 0,
+// indicating that there is no ETC alarm.
+#define ETC_AF_BIT 0x01
+
+/* Configuration Register */
+/* bit[7:3] Reserved */
+/* bit[2] ETC ALARM EN */
+// Default value = 0, which is disabled. When set to a 1,
+// and if the ETC register is equal to or greater than the ETC Alarm limit,
+// then this device triggers the ETC Alarm Flag (ETC AF),
+// and the ALARM pin goes to its active state.
+#define ETC_ALARM_EN_BIT 0x04
+
+/* bit[1] EVENT ALARM EN */
+// Default value = 0, which is disabled. When set to a 1, and if the Event
+// Counter register is equal to or greater than the Event Counter Alarm limit,
+// then this device triggers the Event Count Alarm Flag (EVENT AF),
+// and the ALARM pin goes to its active state.
+#define EVENT_ALARM_EN_BIT 0x02
+
+/* bit[0] ALARM POL */
+// Default value = 0, which sets the ALARM output active low.
+// When set to a 1, the ALARM output is active high.
+#define ALRM_POL_BIT 0x01
+
+/* Member Functions */
+
+DS1683::DS1683(PinName sda, PinName scl, PinName eventpin, PinName alarmpin, int addr) :
+event(eventpin), alarm(alarmpin), m_i2c(sda, scl), m_addr(addr<<1)
+{
+ m_i2c.frequency(100000) ;
+ setConfig(0x00) ; /* disable ETC_ALRM_EN and EVENT_ALRM_EN */
+ alarmPol(0) ; /* Low Active */
+// alarmPol(1) ; /* Active High */
+}
+
+DS1683::~DS1683()
+{
+}
+
+int DS1683::read(int addr, uint8_t *data, int len)
+{
+ int result ;
+ result = readRegs(addr, data, len) ;
+ wait(0.01) ;
+ return( result ) ;
+}
+
+int DS1683::write(int addr, uint8_t *data, int len)
+{
+ uint8_t *buf ;
+ int ack ;
+ buf = new uint8_t[len+1] ;
+ buf[0] = addr ;
+ for (int i = 0 ; i < len ; i++ ) {
+ buf[i+1] = data[i] ;
+ }
+ ack = writeRegs(buf, len+1) ;
+ wait(0.01) ;
+ delete buf ;
+ return( ack ) ;
+}
+
+int DS1683::readRegs(int addr, uint8_t * data, int len) {
+ int result ;
+ char t[1] = {addr};
+ m_i2c.write(m_addr, t, 1, true);
+ result = m_i2c.read(m_addr, (char *)data, len);
+ return( result ) ;
+}
+
+int DS1683::writeRegs(uint8_t * data, int len) {
+ int ack ;
+ m_i2c.stop() ;
+ wait(0.01) ;
+ ack = m_i2c.write(m_addr, (char *)data, len);
+ m_i2c.stop() ;
+ return( ack ) ;
+}
+
+uint8_t DS1683::readReg8(int addr)
+{
+ uint8_t data[1] ;
+ readRegs(addr, data, 1) ;
+ return( data[0] ) ;
+}
+
+void DS1683::writeReg8(int addr, uint8_t value)
+{
+ uint8_t data[2] ;
+ data[0] = addr ;
+ data[1] = value ;
+ writeRegs(data, 2) ;
+}
+
+uint16_t DS1683::readReg16(int addr)
+{
+ uint8_t data[2] ;
+ uint16_t value = 0 ;
+ readRegs(addr, data, 2) ;
+ value = data[1] ;
+ value = (value << 8) | data[1] ;
+ return(value) ;
+}
+
+void DS1683::writeReg16(int addr, uint16_t value)
+{
+#if 0
+ uint8_t data[3] ;
+ data[0] = addr ;
+ data[1] = value & 0xFF ;
+ data[2] = (value >> 8) & 0xFF ;
+ writeRegs(data, 3) ;
+#endif
+ uint8_t data[2] ;
+ data[0] = addr ;
+ data[1] = value & 0xFF ;
+ writeRegs(data, 2) ;
+ data[0] = addr+1 ;
+ data[1] = (value >> 8) & 0xFF ;
+ writeRegs(data, 2) ;
+}
+
+uint32_t DS1683::readReg32(int addr)
+{
+ uint8_t data[4] ;
+ uint32_t value = 0 ;
+ readRegs(addr, data, 4) ;
+ value = data[3] ;
+ value = (value << 8) | data[2] ;
+ value = (value << 8) | data[1] ;
+ value = (value << 8) | data[0] ;
+ return(value) ;
+}
+
+void DS1683::writeReg32(int addr, uint32_t value)
+{
+#if 0
+ uint8_t data[5] ;
+ data[0] = addr ;
+ data[1] = value & 0xFF ;
+ data[2] = (value >> 8) & 0xFF ;
+ data[3] = (value >> 16) & 0xFF ;
+ data[4] = (value >> 24) & 0xFF ;
+ writeRegs(data, 5) ;
+#endif
+ uint8_t data[2] ;
+ data[0] = addr ;
+ data[1] = value & 0xFF ;
+printf("mem[%02X] = %02x\n", data[0], data[1]) ;
+// writeRegs(data, 2) ;
+ writeReg8(data[0], data[1]) ;
+ data[0] = addr + 1;
+ data[1] = (value >> 8) & 0xFF ;
+printf("mem[%02X] = %02x\n", data[0], data[1]) ;
+// writeRegs(data, 2) ;
+ writeReg8(data[0], data[1]) ;
+ data[0] = addr +2 ;
+ data[1] = (value >> 16) & 0xFF ;
+printf("mem[%02X] = %02x\n", data[0], data[1]) ;
+// writeRegs(data, 2) ;
+ writeReg8(data[0], data[1]) ;
+ data[0] = addr + 3;
+ data[1] = (value >> 24) & 0xFF ;
+printf("mem[%02X] = %02x\n", data[0], data[1]) ;
+// writeRegs(data, 2) ;
+ writeReg8(data[0], data[1]) ;
+}
+
+void DS1683::setConfig(uint8_t conf)
+{
+ writeReg8(REG_CONFIG, conf) ;
+}
+
+uint8_t DS1683::getConfig(void)
+{
+ return( readReg8(REG_CONFIG) ) ;
+}
+
+uint8_t DS1683::getStatus(void)
+{
+ return(readReg8(REG_STATUS)) ;
+}
+
+void DS1683::setETC(uint32_t count)
+{
+ writeReg32(REG_ETC, count) ;
+}
+
+uint32_t DS1683::getETC(void)
+{
+ return(readReg32(REG_ETC)) ;
+}
+
+void DS1683::setEventCount(uint16_t count)
+{
+ writeReg16(REG_EVENT, count) ;
+}
+
+uint16_t DS1683::getEventCount(void)
+{
+ return(readReg16(REG_EVENT)) ;
+}
+
+void DS1683::dumpRegs(void)
+{
+ uint8_t data[5] ;
+// printf("m_addr = 0x%02X ", m_addr) ;
+data[0] = 0 ;
+ readRegs(REG_COMMAND, data, 1) ;
+ printf("Command: 0x%02X ", data[0]) ;
+ printf("Status: 0x%02X ", getStatus()) ;
+ printf("Config: 0x%02X\n", getConfig()) ;
+}
+
+void DS1683::enterPW(uint32_t pass)
+{
+ uint8_t data[5] ;
+ data[0] = REG_PWE ; /* Password Entry */
+ data[1] = pass & 0xFF ;
+ data[2] = (pass >> 8) & 0xFF ;
+ data[3] = (pass >> 16) & 0xFF ;
+ data[4] = (pass >> 24) & 0xFF ;
+ writeRegs(data, 5) ;
+}
+
+void DS1683::dumpETC(void)
+{
+ uint32_t data[2] ;
+ data[0] = getETC() ;
+ data[1] = getETCAlarm() ;
+ printf("ETC count: 0x%08X / limit: 0x%08X flag: ", data[0], data[1]) ;
+ if (getStatus() & ETC_AF_BIT) {
+ printf("ON") ;
+ } else {
+ printf("OFF") ;
+ }
+ printf("\n") ;
+}
+
+void DS1683::dumpEvent(void)
+{
+ uint16_t data[2] ;
+ data[0] = getEventCount() ;
+ data[1] = getEventAlarm() ;
+ printf("Event Counter count: %04X / limit: %04X flag: ", data[0], data[1]) ;
+ if (getStatus() & EVENT_AF_BIT) {
+ printf("ON") ;
+ } else {
+ printf("OFF") ;
+ }
+ printf("\n") ;
+}
+
+void DS1683::setETCAlarm(uint32_t count)
+{
+ writeReg32(REG_ETCAL, count) ;
+}
+
+uint32_t DS1683::getETCAlarm(void)
+{
+ return(readReg32(REG_ETCAL)) ;
+}
+
+void DS1683::clearAlarm(void)
+{
+ uint8_t data[2] ;
+ data[0] = REG_COMMAND ;
+ data[1] = 0x01 ;
+ writeRegs(data, 2) ;
+}
+
+void DS1683::clearEvent(void)
+{
+ writeReg16(REG_EVENT, 0x0000) ;
+}
+
+void DS1683::setEventAlarm(uint16_t count)
+{
+ writeReg16(REG_ECAL, count) ;
+}
+
+uint16_t DS1683::getEventAlarm(void)
+{
+ return(readReg16(REG_ECAL)) ;
+}
+
+void DS1683::clearETC(void)
+{
+ writeReg32(REG_ETC, 0x00000000) ;
+}
+
+void DS1683::enableETCAlarm(void)
+{
+ uint8_t config ;
+ config = getConfig() ;
+ config |= ETC_ALARM_EN_BIT ;
+ setConfig(config) ;
+}
+
+void DS1683::disableETCAlarm(void)
+{
+ uint8_t config ;
+ config = getConfig() ;
+ config &= ~ETC_ALARM_EN_BIT ;
+ setConfig(config) ;
+}
+
+void DS1683::enableEventAlarm(void)
+{
+ uint8_t config ;
+ config = getConfig() ;
+ config |= EVENT_ALARM_EN_BIT ;
+ setConfig(config) ;
+}
+
+void DS1683::disableEventAlarm(void)
+{
+ uint8_t config ;
+ config = getConfig() ;
+ config &= ~EVENT_ALARM_EN_BIT ;
+ setConfig(config) ;
+}
+
+void DS1683::alarmPol(int pol)
+{
+ uint8_t config ;
+ config = getConfig() ;
+ if (pol) {
+ config |= 0x01 ;
+ } else {
+ config &= ~0x01 ;
+ }
+ setConfig(config) ;
+}
\ No newline at end of file