Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD DETAIL:  FIELD | CONSTR | METHOD

com.dalsemi.onewire.container
Class OneWireContainer04

java.lang.Object
  |
  +--com.dalsemi.onewire.container.OneWireContainer
        |
        +--com.dalsemi.onewire.container.OneWireContainer04
All Implemented Interfaces:
ClockContainer, OneWireSensor
public class OneWireContainer04
extends OneWireContainer
implements ClockContainer

1-Wire container for 512 byte memory iButton Plus Time, DS1994 and 1-Wire Chip, DS2404. This container encapsulates the functionality of the iButton family type 04 (hex)

This iButton is primarily used as a read/write portable memory device with real-time-clock, timer and experation features.

Features

Appended to the clock page data retrieved with 'readDevice' are 4 bytes that represent a bitmap of changed bytes. These bytes are used in the 'writeDevice' method in conjuction with the 'set' methods to only write back the changed clock register bytes. The 'readDevice' method will clear any pending alarms.

WARNING: If write-protect alarm options have been set prior to a call to 'writeDevice' then the operation is non-reversable.

Alternate Names

Memory

The memory can be accessed through the objects that are returned from the getMemoryBanks method.

The following is a list of the MemoryBank instances that are returned:

Clock

The clock methods can be organized into the following categories. Note that methods that are implemented for the ClockContainer interface are marked with (*):

Usage

See the usage examples in ClockContainer for basic clock operations.
See the usage example in OneWireContainer to enumerate the MemoryBanks.
See the usage examples in MemoryBank and PagedMemoryBank for bank specific operations.

DataSheets

http://pdfserv.maxim-ic.com/arpdf/DS1992-DS1994.pdf
http://pdfserv.maxim-ic.com/arpdf/DS2404.pdf
http://pdfserv.maxim-ic.com/arpdf/DS1427.pdf

Version:
0.00, 28 Aug 2000
See Also:
MemoryBank, PagedMemoryBank, ClockContainer

Constructor Summary
OneWireContainer04()
          Create an empty container that is not complete until after a call to setupContainer.
OneWireContainer04(DSPortAdapter sourceAdapter, byte[] newAddress)
          Create a container with the provided adapter instance and the address of the iButton or 1-Wire device.
OneWireContainer04(DSPortAdapter sourceAdapter, long newAddress)
          Create a container with the provided adapter instance and the address of the iButton or 1-Wire device.
OneWireContainer04(DSPortAdapter sourceAdapter, String newAddress)
          Create a container with the provided adapter instance and the address of the iButton or 1-Wire device.
 
Method Summary
 boolean canDisableClock()
          Query to see if the clock can be disabled.
 boolean canReadAfterExpire(byte[] state)
          Check if the device can be read after a write protected alarm has occured.
 String getAlternateNames()
          Get the alternate Dallas Semiconductor part numbers or names.
 long getClock(byte[] state)
          Extracts the Real-Time clock value in milliseconds.
 long getClockAlarm(byte[] state)
          Extracts the clock alarm value for the Real-Time clock.
 long getClockResolution()
          Query to get the clock resolution in milliseconds
 long getCycleCounter(byte[] state)
          Get the power cycle count value.
 long getCycleCounterAlarm(byte[] state)
          Get the cycle count Alarm Value.
 String getDescription()
          Get a short description of the function of this iButton or 1-Wire Device type.
 long getIntervalTimer(byte[] state)
          Get the Interval Timer Value in milliseconds.
 long getIntervalTimerAlarm(byte[] state)
          Get the Interval Timer Alarm Value.
 Enumeration getMemoryBanks()
          Get an enumeration of memory bank instances that implement one or more of the following interfaces: MemoryBank, PagedMemoryBank, and OTPMemoryBank.
 String getName()
          Get the Dallas Semiconductor part number of the iButton or 1-Wire Device as a string.
 boolean hasClockAlarm()
          Query to see if the clock has an alarm feature.
 boolean isAutomaticDelayLong(byte[] state)
          Checks if the automatic delay for the Inteval Timer and the Cycle counter is either 3.5ms (regular) or 123ms (long).
 boolean isClockAlarmEnabled(byte[] state)
          Checks if the clock alarm is enabled.
 boolean isClockAlarming(byte[] state)
          Checks if the clock alarm flag has been set.
 boolean isClockRunning(byte[] state)
          Checks if the device's oscillator is enabled.
 boolean isClockWriteProtected(byte[] state)
          Check if the Real-Time clock/Alarm is write protected.
 boolean isCycleCounterAlarmEnabled(byte[] state)
          Check if the Cycle Alarm is enabled.
 boolean isCycleCounterAlarming(byte[] state)
          Check if the Cycle Alarm flag has been set.
 boolean isCycleCounterWriteProtected(byte[] state)
          Check if the Cycle Counter and Alarm is write protected.
 boolean isIntervalTimerAlarmEnabled(byte[] state)
          Check if the Interval Timer Alarm is enabled.
 boolean isIntervalTimerAlarming(byte[] state)
          Check if the Interval Timer Alarm flag has been set.
 boolean isIntervalTimerAutomatic(byte[] state)
          Checks if the Interval timer is automatic or manual.
 boolean isIntervalTimerStopped(byte[] state)
          Check if the Interval timer is stopped.
 boolean isIntervalTimerWriteProtected(byte[] state)
          Check if the Interval Timer and Interval Timer Alarm register is write protected.
 byte[] readDevice()
          Retrieves the 1-Wire device sensor state.
 void setAutomaticDelayLong(boolean delayLong, byte[] state)
          Sets the automatic delay for the Inteval Timer and the Cycle counter to either 123ms (long) or 3.5ms (regular).
 void setClock(long time, byte[] state)
          Sets the Real-Time clock.
 void setClockAlarm(long time, byte[] state)
          Sets the clock alarm.
 void setClockAlarmEnable(boolean alarmEnable, byte[] state)
          Enables or disables the clock alarm.
 void setClockRunEnable(boolean runEnable, byte[] state)
          Enables or disables the oscillator, turning the clock 'on' and 'off'.
 void setCycleCounter(long cycles, byte[] state)
          Sets power Cycle Counter.
 void setCycleCounterAlarm(long cycles, byte[] state)
          Sets the power Cycle Count Alarm.
 void setCycleCounterAlarmEnable(boolean alarmEnable, byte[] state)
          Sets the Cycle counter Alarm enable.
 void setIntervalTimer(long time, byte[] state)
          Sets the Interval Timer.
 void setIntervalTimerAlarm(long time, byte[] state)
          Sets the Interval Timer Alarm.
 void setIntervalTimerAlarmEnable(boolean alarmEnable, byte[] state)
          Sets the Interval Timer Alarm enable.
 void setIntervalTimerAutomatic(boolean autoTimer, byte[] state)
          Sets the Interval timer to automatic or manual mode.
 void setIntervalTimerRunState(boolean runState, byte[] state)
          Sets the Interval timer run/stop mode.
 void setReadAfterExpire(boolean readAfter, byte[] state)
          Sets the read state of the device after a write protected alarm has occured.
 void writeDevice(byte[] state)
          Writes the 1-Wire device sensor state that have been changed by 'set' methods.
 void writeProtectClock(byte[] state)
          Sets the write protect options for the Real-Time clock/Alarm.
 void writeProtectCycleCounter(byte[] state)
          Sets the write protect options for the Cycle Counter and Alarm register.
 void writeProtectIntervalTimer(byte[] state)
          Sets the write protect options for Interval Timer and Interval Timer Alarm register.
 
Methods inherited from class com.dalsemi.onewire.container.OneWireContainer
doSpeed, getAdapter, getAddress, getAddressAsLong, getAddressAsString, getMaxSpeed, isAlarming, isPresent, setSpeed, setupContainer, setupContainer, setupContainer
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

OneWireContainer04

public OneWireContainer04()
Create an empty container that is not complete until after a call to setupContainer.

This is one of the methods to construct a container. The others are through creating a OneWireContainer with parameters.

See Also:
super.setupContainer()

OneWireContainer04

public OneWireContainer04(DSPortAdapter sourceAdapter,
                          byte[] newAddress)
Create a container with the provided adapter instance and the address of the iButton or 1-Wire device.

This is one of the methods to construct a container. The other is through creating a OneWireContainer with NO parameters.

Parameters:
sourceAdapter - adapter instance used to communicate with this iButton
newAddress - Address of this 1-Wire device
See Also:
OneWireContainer04, utils.Address

OneWireContainer04

public OneWireContainer04(DSPortAdapter sourceAdapter,
                          long newAddress)
Create a container with the provided adapter instance and the address of the iButton or 1-Wire device.

This is one of the methods to construct a container. The other is through creating a OneWireContainer with NO parameters.

Parameters:
sourceAdapter - adapter instance used to communicate with this 1-Wire device
newAddress - Address of this 1-Wire device
See Also:
OneWireContainer04, utils.Address

OneWireContainer04

public OneWireContainer04(DSPortAdapter sourceAdapter,
                          String newAddress)
Create a container with the provided adapter instance and the address of the iButton or 1-Wire device.

This is one of the methods to construct a container. The other is through creating a OneWireContainer with NO parameters.

Parameters:
sourceAdapter - adapter instance used to communicate with this 1-Wire device
newAddress - Address of this 1-Wire device
See Also:
OneWireContainer04, utils.Address
Method Detail

getName

public String getName()
Get the Dallas Semiconductor part number of the iButton or 1-Wire Device as a string. For example 'DS1992'.
Overrides:
getName in class OneWireContainer
Returns:
iButton or 1-Wire device name

getAlternateNames

public String getAlternateNames()
Get the alternate Dallas Semiconductor part numbers or names. A 'family' of 1-Wire Network devices may have more than one part number depending on packaging. There can also be nicknames such as 'Crypto iButton'.
Overrides:
getAlternateNames in class OneWireContainer
Returns:
1-Wire device alternate names

getDescription

public String getDescription()
Get a short description of the function of this iButton or 1-Wire Device type.
Overrides:
getDescription in class OneWireContainer
Returns:
device description

getMemoryBanks

public Enumeration getMemoryBanks()
Get an enumeration of memory bank instances that implement one or more of the following interfaces: MemoryBank, PagedMemoryBank, and OTPMemoryBank.
Overrides:
getMemoryBanks in class OneWireContainer
Returns:
Enumeration of memory banks

hasClockAlarm

public boolean hasClockAlarm()
Query to see if the clock has an alarm feature.
Specified by:
hasClockAlarm in interface ClockContainer
Returns:
true if the Real-Time clock has an alarm
See Also:
getClockAlarm(byte[]), isClockAlarmEnabled(byte[]), isClockAlarming(byte[]), setClockAlarm(long,byte[]), setClockAlarmEnable(boolean,byte[])

canDisableClock

public boolean canDisableClock()
Query to see if the clock can be disabled.
Specified by:
canDisableClock in interface ClockContainer
Returns:
true if the clock can be enabled and disabled
See Also:
isClockRunning(byte[]), setClockRunEnable(boolean,byte[])

getClockResolution

public long getClockResolution()
Query to get the clock resolution in milliseconds
Specified by:
getClockResolution in interface ClockContainer
Returns:
the clock resolution in milliseconds

readDevice

public byte[] readDevice()
                  throws OneWireIOException,
                         OneWireException
Retrieves the 1-Wire device sensor state. This state is returned as a byte array. Pass this byte array to the 'get' and 'set' methods. If the device state needs to be changed then call the 'writeDevice' to finalize the changes.
Specified by:
readDevice in interface OneWireSensor
Returns:
1-Wire device sensor state
Throws:
OneWireIOException - on a 1-Wire communication error such as reading an incorrect CRC from a 1-Wire device. This could be caused by a physical interruption in the 1-Wire Network due to shorts or a newly arriving 1-Wire device issuing a 'presence pulse'.
OneWireException - on a communication or setup error with the 1-Wire adapter

writeDevice

public void writeDevice(byte[] state)
                 throws OneWireIOException,
                        OneWireException
Writes the 1-Wire device sensor state that have been changed by 'set' methods. Only the state registers that changed are updated. This is done by referencing a field information appended to the state data.
Specified by:
writeDevice in interface OneWireSensor
Parameters:
state - 1-Wire device sensor state
Throws:
OneWireIOException - on a 1-Wire communication error such as reading an incorrect CRC from a 1-Wire device. This could be caused by a physical interruption in the 1-Wire Network due to shorts or a newly arriving 1-Wire device issuing a 'presence pulse'.
OneWireException - on a communication or setup error with the 1-Wire adapter

getClock

public long getClock(byte[] state)
Extracts the Real-Time clock value in milliseconds.
Specified by:
getClock in interface ClockContainer
Parameters:
state - current state of the device returned from readDevice()
Returns:
the time represented in this clock in milliseconds since 1970
See Also:
OneWireSensor.readDevice(), setClock(long,byte[])

getClockAlarm

public long getClockAlarm(byte[] state)
                   throws OneWireException
Extracts the clock alarm value for the Real-Time clock.
Specified by:
getClockAlarm in interface ClockContainer
Parameters:
state - current state of the device returned from readDevice()
Returns:
milliseconds since 1970 that the clock alarm is set to
Throws:
OneWireException - if this device does not have clock alarms
See Also:
OneWireSensor.readDevice(), hasClockAlarm(), isClockAlarmEnabled(byte[]), isClockAlarming(byte[]), setClockAlarm(long,byte[]), setClockAlarmEnable(boolean,byte[])

isClockAlarming

public boolean isClockAlarming(byte[] state)
Checks if the clock alarm flag has been set. This will occur when the value of the Real-Time clock equals the value of the clock alarm.
Specified by:
isClockAlarming in interface ClockContainer
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if the Real-Time clock is alarming
See Also:
OneWireSensor.readDevice(), hasClockAlarm(), isClockAlarmEnabled(byte[]), getClockAlarm(byte[]), setClockAlarm(long,byte[]), setClockAlarmEnable(boolean,byte[])

isClockAlarmEnabled

public boolean isClockAlarmEnabled(byte[] state)
Checks if the clock alarm is enabled.
Specified by:
isClockAlarmEnabled in interface ClockContainer
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if clock alarm is enabled
See Also:
OneWireSensor.readDevice(), hasClockAlarm(), isClockAlarming(byte[]), getClockAlarm(byte[]), setClockAlarm(long,byte[]), setClockAlarmEnable(boolean,byte[])

isClockRunning

public boolean isClockRunning(byte[] state)
Checks if the device's oscillator is enabled. The clock will not increment if the clock oscillator is not enabled.
Specified by:
isClockRunning in interface ClockContainer
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if the clock is running
See Also:
OneWireSensor.readDevice(), canDisableClock(), setClockRunEnable(boolean,byte[])

getIntervalTimer

public long getIntervalTimer(byte[] state)
Get the Interval Timer Value in milliseconds.
Parameters:
state - current state of the device returned from readDevice()
Returns:
time in milliseconds that have occured since the interval counter was started
See Also:
OneWireSensor.readDevice(), setIntervalTimer(long,byte[])

getCycleCounter

public long getCycleCounter(byte[] state)
Get the power cycle count value. This is the total number of power cycles that the DS1994 has seen since the counter was reset.
Parameters:
state - current state of the device returned from readDevice()
Returns:
power cycle count
See Also:
OneWireSensor.readDevice(), setCycleCounter

getIntervalTimerAlarm

public long getIntervalTimerAlarm(byte[] state)
Get the Interval Timer Alarm Value.
Parameters:
state - current state of the device returned from readDevice()
Returns:
time in milliseconds that have the interval timer alarm is set to
See Also:
OneWireSensor.readDevice(), setIntervalTimerAlarm

getCycleCounterAlarm

public long getCycleCounterAlarm(byte[] state)
Get the cycle count Alarm Value.
Parameters:
state - current state of the device returned from readDevice()
Returns:
total number of power cycles that the DS1994 has to to see before the alarm will be triggered
See Also:
OneWireSensor.readDevice(), setCycleCounterAlarm

isIntervalTimerAlarming

public boolean isIntervalTimerAlarming(byte[] state)
Check if the Interval Timer Alarm flag has been set.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if interval timer is alarming
See Also:
OneWireSensor.readDevice(), isIntervalTimerAlarmEnabled, setIntervalTimerAlarmEnable

isCycleCounterAlarming

public boolean isCycleCounterAlarming(byte[] state)
Check if the Cycle Alarm flag has been set.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if cycle counter is alarming
See Also:
OneWireSensor.readDevice(), isCycleCounterAlarmEnabled, setCycleCounterAlarmEnable

isIntervalTimerAlarmEnabled

public boolean isIntervalTimerAlarmEnabled(byte[] state)
Check if the Interval Timer Alarm is enabled.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if interval timer alarm is enabled
See Also:
OneWireSensor.readDevice(), isIntervalTimerAlarming, setIntervalTimerAlarmEnable

isCycleCounterAlarmEnabled

public boolean isCycleCounterAlarmEnabled(byte[] state)
Check if the Cycle Alarm is enabled.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true true if cycle counter alarm is enabled
See Also:
OneWireSensor.readDevice(), isCycleCounterAlarming, setCycleCounterAlarmEnable

isClockWriteProtected

public boolean isClockWriteProtected(byte[] state)
Check if the Real-Time clock/Alarm is write protected.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if real time clock/alarm is write protected
See Also:
OneWireSensor.readDevice(), writeProtectClock

isIntervalTimerWriteProtected

public boolean isIntervalTimerWriteProtected(byte[] state)
Check if the Interval Timer and Interval Timer Alarm register is write protected.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if interval timer and interval timer alarm is write protected
See Also:
OneWireSensor.readDevice(), writeProtectIntervalTimer

isCycleCounterWriteProtected

public boolean isCycleCounterWriteProtected(byte[] state)
Check if the Cycle Counter and Alarm is write protected.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if cycle counter/alarm is write protected
See Also:
OneWireSensor.readDevice(), writeProtectCycleCounter

canReadAfterExpire

public boolean canReadAfterExpire(byte[] state)
Check if the device can be read after a write protected alarm has occured.
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if the device can be read after a write protected alarm has occured
See Also:
OneWireSensor.readDevice(), setReadAfterExpire

isIntervalTimerAutomatic

public boolean isIntervalTimerAutomatic(byte[] state)
Checks if the Interval timer is automatic or manual. If it is automatic then the interval counter will increment while the devices I/O line is high after the delay select period has elapsed (either 3.5 or 123 ms, see the isAutomaticDelayLong() method).
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if the interval timer is set to automatic mode
See Also:
OneWireSensor.readDevice(), setIntervalTimerAutomatic

isIntervalTimerStopped

public boolean isIntervalTimerStopped(byte[] state)
Check if the Interval timer is stopped. This only has meaning if the interval timer is in manual mode (not isIntervalTimerAutomatic).
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if the interval timer is stopped
See Also:
OneWireSensor.readDevice(), isIntervalTimerAutomatic, setIntervalTimerAutomatic, setIntervalTimerRunState

isAutomaticDelayLong

public boolean isAutomaticDelayLong(byte[] state)
Checks if the automatic delay for the Inteval Timer and the Cycle counter is either 3.5ms (regular) or 123ms (long).
Parameters:
state - current state of the device returned from readDevice()
Returns:
true if the automatic interval/cycle counter delay is in the long (123ms) mode, else it is 3.5ms
See Also:
OneWireSensor.readDevice(), setAutomaticDelayLong

setClock

public void setClock(long time,
                     byte[] state)
Sets the Real-Time clock. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Specified by:
setClock in interface ClockContainer
Parameters:
time - new value for the Real-Time clock, in milliseconds since January 1, 1970
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), getClock(byte[])

setClockAlarm

public void setClockAlarm(long time,
                          byte[] state)
                   throws OneWireException
Sets the clock alarm. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]). Also note that not all clock devices have alarms. Check to see if this device has alarms first by calling the hasClockAlarm() method.
Specified by:
setClockAlarm in interface ClockContainer
Parameters:
time - - new value for the Real-Time clock alarm, in milliseconds since January 1, 1970
state - current state of the device returned from readDevice()
Throws:
OneWireException - if this device does not have clock alarms
See Also:
OneWireSensor.writeDevice(byte[]), hasClockAlarm(), isClockAlarmEnabled(byte[]), getClockAlarm(byte[]), isClockAlarming(byte[]), setClockAlarmEnable(boolean,byte[])

setClockRunEnable

public void setClockRunEnable(boolean runEnable,
                              byte[] state)
                       throws OneWireException
Enables or disables the oscillator, turning the clock 'on' and 'off'. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]). Also note that not all clock devices can disable their oscillators. Check to see if this device can disable its oscillator first by calling the canDisableClock() method.
Specified by:
setClockRunEnable in interface ClockContainer
Parameters:
runEnable - true to enable the clock oscillator
state - current state of the device returned from readDevice()
Throws:
OneWireException - if the clock oscillator cannot be disabled
See Also:
OneWireSensor.writeDevice(byte[]), canDisableClock(), isClockRunning(byte[])

setClockAlarmEnable

public void setClockAlarmEnable(boolean alarmEnable,
                                byte[] state)
                         throws OneWireException
Enables or disables the clock alarm. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]). Also note that not all clock devices have alarms. Check to see if this device has alarms first by calling the hasClockAlarm() method.
Specified by:
setClockAlarmEnable in interface ClockContainer
Parameters:
alarmEnable - true to enable the clock alarm
state - current state of the device returned from readDevice()
Throws:
OneWireException - if this device does not have clock alarms
See Also:
OneWireSensor.writeDevice(byte[]), hasClockAlarm(), isClockAlarmEnabled(byte[]), getClockAlarm(byte[]), setClockAlarm(long,byte[]), isClockAlarming(byte[])

setIntervalTimer

public void setIntervalTimer(long time,
                             byte[] state)
Sets the Interval Timer. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
time - interval in milliseconds to set (truncated to 1/256th of second)
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), getIntervalTimer

setCycleCounter

public void setCycleCounter(long cycles,
                            byte[] state)
Sets power Cycle Counter. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
cycles - initialize cycle counter value
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), getCycleCounter

setIntervalTimerAlarm

public void setIntervalTimerAlarm(long time,
                                  byte[] state)
Sets the Interval Timer Alarm. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
time - in milliseconds to set the inverval timer
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), getIntervalTimerAlarm

setCycleCounterAlarm

public void setCycleCounterAlarm(long cycles,
                                 byte[] state)
Sets the power Cycle Count Alarm. This counter holds the number of times the DS1994 must experience power cycles before it generates an alarm. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
cycles - power Cycle Count alarm
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), getCycleCounterAlarm

writeProtectClock

public void writeProtectClock(byte[] state)
Sets the write protect options for the Real-Time clock/Alarm. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).

WARNING: after calling this method and then writeDevice the device will be permanently write protected.


Parameters:
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isClockWriteProtected

writeProtectIntervalTimer

public void writeProtectIntervalTimer(byte[] state)
Sets the write protect options for Interval Timer and Interval Timer Alarm register. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).

WARNING: after calling this method and then writeDevice the device will be permanently write protected.


Parameters:
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isIntervalTimerWriteProtected

writeProtectCycleCounter

public void writeProtectCycleCounter(byte[] state)
Sets the write protect options for the Cycle Counter and Alarm register. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).

WARNING: after calling this method and then writeDevice the device will be permanently write protected.


Parameters:
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isCycleCounterWriteProtected

setReadAfterExpire

public void setReadAfterExpire(boolean readAfter,
                               byte[] state)
Sets the read state of the device after a write protected alarm has occured. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
readAfter - true to read device after it expires from a write protected alarm event
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), canReadAfterExpire

setIntervalTimerAutomatic

public void setIntervalTimerAutomatic(boolean autoTimer,
                                      byte[] state)
Sets the Interval timer to automatic or manual mode. When in automatic mode, the interval counter will increment while the devices I/O line is high after the delay select period has elapsed (either 3.5 or 123 ms, see the isAutomaticDelayLong() method). The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
autoTimer - true for the interval timer to operate in automatic mode
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isIntervalTimerAutomatic

setIntervalTimerRunState

public void setIntervalTimerRunState(boolean runState,
                                     byte[] state)
Sets the Interval timer run/stop mode. This only has meaning if the interval timer is in manual mode (not isIntervalTimerAutomatic()). The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
runState - true to set the interval timer to run
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isIntervalTimerAutomatic, isIntervalTimerStopped

setAutomaticDelayLong

public void setAutomaticDelayLong(boolean delayLong,
                                  byte[] state)
Sets the automatic delay for the Inteval Timer and the Cycle counter to either 123ms (long) or 3.5ms (regular). The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
delayLong - true to set the interval timer to cycle counter to increment after 123ms or false for 3.5ms
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isAutomaticDelayLong

setIntervalTimerAlarmEnable

public void setIntervalTimerAlarmEnable(boolean alarmEnable,
                                        byte[] state)
Sets the Interval Timer Alarm enable. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
alarmEnable - true to enable the interval timer alarm
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isIntervalTimerAlarmEnabled

setCycleCounterAlarmEnable

public void setCycleCounterAlarmEnable(boolean alarmEnable,
                                       byte[] state)
Sets the Cycle counter Alarm enable. The method writeDevice(byte[]) must be called to finalize changes to the device. Note that multiple 'set' methods can be called before one call to writeDevice(byte[]).
Parameters:
alarmEnable - true to enable the cycle counter alarm
state - current state of the device returned from readDevice()
See Also:
OneWireSensor.writeDevice(byte[]), isCycleCounterAlarmEnabled
Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD DETAIL:  FIELD | CONSTR | METHOD