dataTaker - Data Loggers, Powerful and Flexible Data Acquisition & Data Logging Systems

The dataTaker data loggers have two types of memory for logging data

internal SRAM memory. The internal memory for Series 1 and Series 2 dataTakers stores 13,650 data items, and for Series 3 loggers stores 166,530 data items

memory cards that can be inserted into the logger. Series 1 and 2 dataTakers accept 512 Kbyte and 1 Mbyte cards, and Series 3 loggers accept 512 Kbyte, 1 Mbyte, 2 Mbyte and 4 Mbyte.

The Data Logging commands are similar for storing data in the internal data memory, and for storing data in a memory card. When a memory card is not inserted in the logger, the Data Logging commands apply to the internal data memory. When a memory card is inserted, the Data Logging commands apply to the memory card. The memory card has the highest priority for storage of data.

The internal data memory is used as a temporary data storage buffer for the memory card when memory cards are used. The internal data memory cannot be used as a separate area of memory when a memory card is installed.

The following descriptions of the Data Logging commands refer to a 'data memory'. If a memory card is inserted, then the data memory is the memory card. If however a memory card is not inserted, then the data memory is the internal memory.

Controlling Logging of Data 

The data produced by the Schedules is returned to the host computer by default, and is not logged into the internal data memory or memory card by default. Data logging has to be specifically enabled.

The logging of data can be controlled globally for all input channels scanned, and can be controlled for individual channels.

Logging Data - Global Control

Logging of real time Schedule data into the internal data memory or a memory card is globally enabled and disabled by the Data Logging commands as follows

LOGON      Enables data logging
LOGOFF     Disables data logging (Default)

The Data Logging commands can be included in programs, or can be entered separately as direct commands during system configuration.

The Data Logging command defaults to LOGOFF after a power up, or after execution of a RESET command or a CLEAR command.

The LOGON command must be entered after all schedules have been entered, because it ëlocksí the internal channel table. If you attempt to enter Schedules after a LOGON command, then an ëE4-clear data memoryí error will be returned.

Using DeTransfer, data logging is globally enabled in the following program

BEGIN
 RA10S
  1..5TK
END
LOGON

Using DeLogger, data logging is automatically globally enabled in programs. This is controlled from the Program Builder Settings tab. Right click on the Data Logging button, and select Data Logging On or Data Logging Off as required. The default is Data Logging On.

 

DeLogger automatically inserts a LOGON command into the program if Data Logging On is selected, and does not insert a LOGON command if Data Logging Off is selected.

The current state of the Data Logging command can be checked at any time by either the STATUS or the STATUS5 commands (See Section III ñ Status Command).

Using DeTransfer this can be checked by the command for example

STATUS5

returns the response of either  Logging is ON  or  Logging is OFF, depending on whether the last Data Logging command entered was LOGON or LOGOFF respectively, or a CLEAR or RESET command has been executed.

Using DeLogger, the state of the Data Logging command can be checked by selecting dataTaker:Status on the main menu or clicking the Status button on the toolbar, to open the dataTaker Status dialog. The state of the Data Logging command is shown as Logging On or Logging Off.

 

 

Logging Data - Individual Control

The logging of real time Schedule data can also be controlled for individual channels, using the No Log (NL) channel option (See Section III ñ Channel Options).

The NL Channel Option is applied to channels and Channel Variables that should not log real time data to the internal memory or memory card. NL only has effect when the LOGON command is enabled.

Using DeTransfer, the No Log Channel Option is used as follows

BEGIN
 RA2S
  1TK
  2TK(NL)
END
LOGON

Data logging is enabled by the LOGON command, and data will be logged for the first thermocouple but not for the second thermocouple. However data will be returned and displayed for both channels.

Using DeLogger, , the No Log Channel Option can be set in the Program Builder. After the channel is defined, right click on the Data Use icon and select PropertiesÖ The Channel Properties dialog opens with the Data Use tab open. Check Do NOT log data to memory.

 

 

Controlling Return of Data to the Host Computer

The data produced by the Data Schedules can be returned to the host computer, logged into the internal data memory or memory card if one is inserted, and displayed if a display is available

Sometimes it is not appropriate to return Schedule data in real time, particularly if it is being logged. The following commands allow control of returning data to the host computer.

Returning Data ñ Global Control

The return of real time Schedule data to the host computer is globally controlled by the Return Data Switch. The switch has no effect on the return of Logged data or Alarms data.

The Return Data Switch as defined as follows

/R            Enables return of Schedule data to the host computer (Default)
/r             Disables return of Schedule data to the host computer

The Return Data Switch defaults to /R whenever the dataTaker is initially powered up, hardware reset or executes a RESET command.

The current setting of the Return Data Switch can be checked at any time by the STATUS command or the STATUS9 command (See Section III ñ Status Command).

DeTransfer and DeLogger generally manage the Return Data Switch automatically, to suit the operation of the dataTaker / software interface. However it may be necessary to manage the switch if you are supervising the logger from other software, or if you are using some form of telemetry.

Returning Data - Individual Control

The return of real time Schedule data to the host computer can also be controlled for individual channels and Channel Variables, with the No Return (NR) channel option (See Section III ñ Channel Options).

The NR Channel Option is applied to channels and Channel Variables that should not return real time data to the host computer. NR only has effect when the Return Data Switch is enabled.

Using DeTransfer, the Return Data Switch and No Return Channel Option are used as follows

/R
BEGIN
 RA2S
  1TK(NR)
  2TK
END
LOGON

The Return Data Switch is enabled, and data will be returned from the second thermocouple channel but not from the first thermocouple channel. The data can still be logged and displayed for both channels.

Using DeLogger, the No Return Channel Option can be set in the Program Builder. After the channel is defined, right click on the Data Use icon and select PropertiesÖ The Channel Properties dialog opens with the Data Use tab open. Check Do NOT return data to host computer.

 

 

Setting the No Return option here will prevent this data being displayed or charted, etc in DeLogger.

Controlling Displaying of Data

The data produced by the Data Schedules can be returned to the host computer, logged into the internal data memory or memory card if one is inserted, and displayed if a display is available

Sometimes it is not appropriate to display Schedule data in real time, particularly if it is being logged. The following commands allow control of displaying data on the display panel.

The display of realtime data can be controlled for individual channels, using the No Display (ND) channel option (See Section III ñ Channel Options). By default all of the channel data is displayed.

The ND Channel Option is applied to channels and Channel Variables that should not display real time data on the dataTaker display panel. NL only has effect when the LOGON command is enabled.

Note : The No Display channel option only applies to dataTakers fitted with a display panel. If the ND channel option is used for a dataTaker without a display, then an 'E3 - channel option error' will be returned.

Using DeTransfer, the No Display Channel Option is used as follows

BEGIN
 RA2S
  1TK(ND)
  2TK(NR,NL)
END
LOGON

Data will be logged and returned for the first thermocouple channel but not displayed. Data will be displayed for the second thermocouple channel, but not logger or returned.

Using DeLogger, , the No Display Channel Option can be set in the Program Builder. After the channel is defined, right click on the Data Use icon and select PropertiesÖ The Channel Properties dialog opens with the Data Use tab open. Check Do NOT show data on display.

 

 

Individual channels can also be disabled from display from the keypad on the display panel itself (See Section III ñ Keypad and Display Panel).

Controlling Intermediate Data

Often programs include steps where input channel data is loaded into Channel Variables, etc. for further calculation. This intermediate or 'working' data is not to be returned, logged or displayed.

Such channels can have the NR, NL and ND channel options applied, or can have the Working channel (W) option applied which is a short form of NR, NL and ND.

Using DeTransfer, the Working Channel Option is used as follows

BEGIN
 RA2S
  1TK(W,=1CV)
  2TK
END
LOGON

Data from the thermocouple on channel 1 is saved into the Channel Variable, and not returned, logged or displayed. Data from the thermocouple on channel 2 goes to all destinations.

Using DeLogger, , the Working Option can be set in the Program Builder. After the channel is defined, right click on the Data Use icon and select PropertiesÖ The Channel Properties dialog opens with the Data Use tab open. Check Working channel.

 

 

Modes of Data Logging

The internal data memory and the memory cards can log data in either of two modes as follows

as a stack, where the data is written to the data memory until the memory is filled,
and then data logging ceases.

 as a circular buffer, where the data is written to the data memory until the memory is filled,
and then new data is written over the oldest data.

The mode of data logging is defined by the Data Memory Overwrite Switch as follows

/o            Overwrite disabled, data store is a stack (Default)
/O           Overwrite enabled, data store is a circular buffer

The default setting for the Data Memory Overwrite Switch is /o, and the data memory functions as a stack. This default setting is selected following initial power up, or execution of a RESET command.

The current setting of the Data Memory Overwrite Switch can be checked at any time by the STATUS command or the STATUS9 command (See Section III ñ Status Command).

The Data Memory Overwrite Switch should not be changed after memory overwrite has begun.

Data Store Overwrite Switch Disabled (/o)

When data is being logged to the data memory, logging will continue until the data memory fills.

When the data memory fills, the dataTaker then responds according to the setting of the Data Store Overwrite Switch. If the switch is disabled (/o), the dataTaker responds as follows

if there is no memory card installed in the logger, then data logging ceases and the message
'E5ñdata memory full' is returned to the host computer

if a memory card is installed, the memory card is made invalid and data is then logged into the internal memory until that fills. When the internal memory is filled, data logging ceases and the message 'E5ñdata memory full' is returned to the host computer.

if the memory card is removed, then data logging continues into the internal data memory. If a new or cleared memory card is later inserted, the data stored in the internal data memory is then transferred into the card and the internal memory is cleared. Data logging continues into the memory card until that fills.

In each case data that is acquired after the internal data memory is filled, will be lost. This will produce a discontinuity in the data if a new or cleared memory card is later inserted to allow further data logging. If memory cards are used in this mode of memory configuration, it is important that card replacement be managed carefully to avoid this discontinuity of data.

When all available data memory is filled, the Schedules continue to run and data will continue to return to the host continues if enabled by the Return Data Switch /R. Data logging remains enabled (LOGON) such that if a new or cleared memory card is later inserted, then data logging can continue to the card.

Data Store Overwrite Switch Enabled (/O)

When data is being logged to the data memory, logging will continue until the data memory fills.

If the Data Store Overwrite Switch is enabled (/O), then the data memory behaves as a circular buffer. When the memory fills, new data is progressively written over the oldest data. The data memory therefore contains a continuously updated recent history of data.

When the data memory fills, the dataTaker then responds as follows

if there is no memory card installed, then data logging continues in the internal memory with the newest data being written over the oldest data. If a new or cleared memory card is inserted, the data stored in the internal data memory is transferred into the card, and the internal memory is cleared. Data logging then continues in the card in overwrite mode.

if a memory card is installed, then data logging continues in the memory card with the newest data being written over the oldest data. The internal data memory is not used in this mode.

if the memory card is removed, then the data is logged into the internal data memory in overwrite mode. If a new or cleared memory card is later inserted, the data stored in the internal data memory is transferred into the card, and the internal memory is cleared. Data logging then continues in the card in overwrite mode.

If a memory card is used in the overwrite mode, and is removed, the data is then logged into the internal data memory in overwrite mode. If the memory card is not replaced before the newest data commences to overwrite the oldest data in the internal memory, then there will be a discontinuity in the data between memory cards.

Entering New Schedules When Logging

When data is logged into the internal data memory, the data is stored without details of channel number, input mode or engineering units. When the logged data is later read from the internal memory and returned to the host computer, the internal channel table created from the original Schedule lists is used to interpret the stored data.

Similarly when data is logged into a memory card, the data is stored without details of channel number, input mode or engineering units. A copy of the internal channel table is also stored in the memory card. This allows the memory card to be read and the data interpreted by another dataTaker, or by the MCI-04 Memory Card Interface.

This technique was developed to increase the data storage capacity of given memory size, more than could be stored in ASCII text as is seen at the host computer.

However this technique has important implications. If a new program is entered into the logger, then the original data could no longer be interpreted.

Therefore if data has been stored in the internal data memory, then entry of new program is rejected and the dataTaker will return the error message 'E4ñclear data memory'. The dataTaker will also return this error if LOGON is enabled, even if there is no data in the memory yet.

However if there is a memory card inserted in the logger that contains data from the current program, then entry new program will process as follows

if the new program is identical to the current program, then the new program is accepted and executed. New data is appended to data already stored in the memory card. This scenario is typical of a logger losing power during an application, and being restarted when power is resumed.

if the new program is different in any way to the current program, then the memory card is made invalid. If the internal memory is clear, then the new program is accepted and executed and new data is stored in the internal memory only. However if the internal memory contains data, then the new program is rejected and the dataTaker will return the error message 'E4ñclear data memory'

These actions preserve the original channel table until the data in the data memory has been returned (See Section III ñ Returning Data from Memory) and the internal data memory or memory card is cleared.

Priorities for Returning and Logging Data

When data from Schedules is logged to internal data memory or a memory card (LOGON), and also returned to the host computer (/R), the logging of data has priority over the returning of data.

Each time the Schedules run, the data is logged immediately, and is then returned to the host if time permits. However if the next Schedule trigger occurs before all of the data is returned, then returning of data is aborted and the Schedule runs.

This priority can be reversed if required by the Data Priority Switch, as follows

/Y      Return all data to host when data logging is enabled, ignore new triggers
/y      Return data to the host when data logging is enabled, only if time permits

The Data Priority Switch defaults to disabled (/y) following initial power up, or execution of a RESET command.

If data is not being logged to the internal data memory or a memory card, then all data will be returned to the host. If new Schedule triggers occur before all of the data is returned, then all new Schedule triggers are ignored until return of the original data set completes. There is no alternative to this.

Checking the Data Memory Configuration

The current settings of the various Data Logging commands can be checked at any time by the STATUS command (See Section III ñ Status Command).

Using DeTransfer, the status of the logger can be returned by the command

STATUS

which will include information of the current settings of the data logging commands

Logging is OFF
/o
/R
/y

These settings can be also be checked specifically by

the STATUS5 command for the setting of LOGON / LOGOFF

the STATUS9 command for the settings of the Data Memory Overwrite Switch,
Return Data Switch and Data Priority Switch.

Checking Data Storage

The amount of data stored in the internal memory, and in the memory card, can be checked

by the STATUS command

the System Variables for internal memory and memory card data storage

Checking Data Storage in the Internal Memory

The STATUS command or STATUS6 command will return the amount of data stored, and the amount of free data space, in the internal data memory.

Using DeTransfer, the status of the internal memory can be returned by the commands

STATUS
STATUS6

which will include information about the internal data memory

103895,62635 Internal Data Points Free,Stored

Data storage in the internal data memory can also be returned by the System Variables as follows

1SV          - returns the amount of free internal memory, in terms of data points
2SV          - returns the amount of stored internal memory, in terms of data points

The amount of data currently stored in the internal data memory can be returned as part of the Schedule data, and can be used in Alarms to warn of full memory conditions.

For example

R10M  1..10V 2SV LOGON

ALARM1(1SV<100)"Memory Card is Full^M^J"

Checking Data Storage in the Memory Card

The STATUS command or STATUS7 command will return the amount of data stored, and the amount of free data space, in the memory card.

Using DeTransfer, the status of the memory card can be returned by the command

STATUS
STATUS7

which will include information about the internal data memory

79265,1670 Card Data Points Free,Stored

Note 1:  When a valid memory card is inserted, and is not filled, then no will be data stored in the internal memory. The internal memory in this situation is a buffer for memory card change-over.

Note 2:  When an invalid memory card is inserted, then stored data may be indicated for both internal memory and memory card.

Data storage in the memory card can also be returned by the System Variables as follows

3VS          - returns the amount of free card memory, in terms of data points
4SV          - returns the amount of stored card memory, in terms of data points

The amount of data currently stored in the internal data memory can be returned as part of the Schedule data, and can be used in Alarms to warn of full memory conditions.

For example

R10M  1..10V 4SV LOGON

ALARM1(3SV<100)"Memory Card is Full^M^J"

 


The dataTaker is able to store data into the internal data memory, as the data is produced by the Schedules reading input channels, reading internal channels, performing calculations, etc.

The dataTaker also supports removable memory cards, that can be inserted into the memory card socket of the logger and used to store data (See Section III ñ Logging Data to Memory Cards).

The Internal Data Memory

The dataTaker has 512 Kbytes of internal memory, of which approximately 12 Kbytes is used for system memory and approximately 500 Kbytes is used for data memory.

The dataTaker is able to store 166,530 data points or readings in the internal data memory. Stored data is written serially into the data memory, and the memory is managed as a First In First Out buffer.

The data memory can be configured as a data stack, where data logging stops when the memory becomes full, and new data is lost. Alternatively, the data memory can be configured as a circular buffer, where the newest data overwrites the oldest data when the memory becomes full.

Data is logged into the internal data memory as the Schedules run, producing the data by reading input channels, performing calculations, etc.

Once programmed, the dataTaker can scan input channels, perform calculations, and log the data to memory independent of a host computer. The computer can later be reconnected to the logger to recover the logged data.

The internal memory is backed by a ½AA lithium battery, which maintains the internal memory when the dataTaker loses power supply. If the logger slowly loses power supply (not less that 2 seconds), such as a battery power supply failing, then the logger will preserve the environment during the outage such that the internal data will be available when power is returned. However if power loss is sudden, then data stored in the internal memory will be lost.

Capacity of the Internal Data Memory

The dataTaker can store up to 166,530 data points or readings in the internal data memory. All data is stored in a compact 3 byte floating point format. Each 3 byte storage element is referred to as a 'data point equivalent' of data memory.

When the Schedules run, the data is produced as blocks of data. Each block contains the data for a single iteration of one Schedule.

When each block of data is logged into the internal data memory, the block is preceded by a header. This header is used to store information about the particular Schedule, and a timestamp (the date and time) for when the Schedule ran, that produced the block of data.

Storage of the header also consumes 3 bytes of memory.

The number of executions of Schedules that can actually be logged into the internal data memory varies depending on the number of channels being scanned, and calculations performed, and hence the number of data points stored in each block of data.

For example if the data from one channel is being logged, then there is a header associated with each block of data containing one data point. In this case there is a header overhead of 50%, resulting in the storage of approximately 83,250 data points total.

Alternatively if the data from 9 channels is being logged, then there is a header associated with each block of data containing 9 data points. In this case the header overhead is 10%, resulting in the storage of approximately 149,800 data points.

The amount of data stored in the internal data memory, and the amount of internal data memory free or unused, can be checked at any time by the STATUS command or the STATUS6 command (See Section III ñ Checking Data Storage and Section III ñ Status Command).

Clearing Internal Data Memory

Reading the data from the internal data memory does not clear the data memory. Consequently, data can be returned from the internal data memory as many times as required.

The internal data memory is cleared of data by the command

CLEAR

The CLEAR command also changes the Data Logging command to LOGOFF. The Data Logging command must be set to LOGON again before data logging can re-commence.

Using DeTransfer, the internal memory is cleared by the command for example

CLEAR

Using DeLogger, the internal memory is cleared by selecting dataTaker:ClearÖ from the main menu bar, or clicking the Clear button on the main toolbar. This will open the Clear Memory dialog.

Check Internal memory, and click OK to clear the internal data memory in the logger. There is also the option to clear either All data, or Unloaded data only. Normally this is set to clear All data,

 

 

 

 

 

 

 

Whenever there is data stored in the internal data memory, new Schedules cannot be entered into the logger until the data memory has been cleared by a CLEAR command.

The CLEAR command does not clear the data area of an inserted memory card. The data area of memory cards is cleared by the CDATA command.

 


The dataTaker supports external memory cards, which can be plugged into the logger and used to store data. The logger can progressively store data into the memory card as the data is produced, or data can be transferred from internal memory to the memory card if one is inserted after data has been stored in internal memory.

Whenever a memory card is inserted into the dataTaker, the card is powered from the logger power supply. Some memory cards also have a lithium cell, which powers the card for up to 3 years while the card is removed from the logger. Other memory cards have a rechargeable cell, which recharges while the card is inserted in the logger. These cards may suffer a discharged battery, in which case the card should be inserted in the logger for several days to recharge. Under normal use however, this should never be a problem.

When the memory cards are inserted into the dataTaker, insertion should be swift and the memory card should be fully inserted into the memory card socket. The memory card must not be left partially inserted in the memory card socket.

During the insertion of a memory card, the loggerís microprocessor is temporarily halted. This halt state must be kept to a minimum to avoid loss of time, and loss of any characters currently being received on the RS232 COMMS or NETWORK (dataTaker 500/600 series loggers) serial interfaces.

Format of dataTaker Memory Cards

The dataTaker uses a proprietary format for memory cards, which is not compatible with any other formats. In particular the memory card format is not compatible with Microsoft DOS file format, and so these cards cannot be read directly if plugged into the PCMCIA or PC Card slots of computers.

The normal procedure is to read the dataTaker memory cards either

using a dataTaker data logger

using the dataTaker MCI-04 Memory Card Interface

The dataTaker MCI-04 Memory Card Interface is supplied with MCI Assistant software, which supports the interface in Microsoft Windows to transfer data from the memory cards to a file compatible with DeLogger and other applications. DeLogger 4 versions 4.2.16 or later also have this interface integrated into the package.

Data Transfer to Memory Cards

A memory card can be inserted into a dataTaker that has been already collecting data into internal memory. When the memory card is inserted, the dataTaker will transfer the data from the internal memory to the card of the card is clear.

The transfer of 166,530 readings from the internal data memory to a memory card takes 3 seconds . Therefore to be safe, do not remove a memory card for 5 seconds after inserting if you are transferring data.

When data is transferred from the internal memory to the memory card, the data is written to the card then verified. If the memory card is removed during this transfer or verification period, then the check will fail. The whole of the data being transferred is retained in the internal memory, until another memory card is inserted. What is on the memory card is anyoneís guess!!!

The worst case result of untimely removal of a memory card is that there could be a copy of the data on the memory card, and a copy in the internal data memory.

 

During data transfer, dataTakers fitted with a display will display the message

Transfering data
Card name

If the memory card already contains data from another program when inserted into the logger, then no transfer occurs. DataTakers fitted with a display will display the message

Can't copy data
Card name

As a general guide, the following procedures should be adopted to ensure maximum data integrity

whenever data is to be collected from the internal data memory, the memory card should be inserted for 3 seconds minimum, 5 seconds preferred.

whenever a memory card is removed during data acquisition, try to remove the card during the interval between scans, as can be observed on the 'Converting LED'.

Function of the Internal Data Memory with Memory Cards

The dataTaker has 512 Kbytes of internal battery backed memory, of which approximately 12 Kbytes is used for system memory and approximately 500 Kbytes is allocated to data memory.

When there is no memory card inserted, the internal memory is used as the data memory for logging of data. However whenever a memory card is inserted, the internal data memory is used as a data buffer for the memory card. The data buffer can store 166,530 readings.

The function of the internal data memory as a data buffer for the memory card is illustrated by the following scenario

a memory card is inserted into the dataTaker and data is logged to the card

the memory card may be removed for reading elsewhere, or for entering a program, etc.

data acquired during while the memory card is removed is buffered into the internal data memory

when the memory card is later inserted, the data in the internal memory is transferred to the card

It is the users responsibility to ensure that the internal data buffer does not overflow while the memory card is withdrawn, otherwise data will be lost.

Capacity of Memory Cards

The dataTaker Series 3 loggers support SRAM memory cards with capacities up to 4 Mbytes.

The dataTaker Series 1 and 2 loggers support SRAM memory cards with capacities up to 1 Mbyte.

The memory cards are automatically initialised when plugged into the logger (see below), and the available memory is divided as follows

4 Kbytes (4090 characters) is allocated to the program area for storing dataTaker commands

8 Kbytes is allocated for storing system and card management information

the balance of the card memory is allocated for data storage. The size of the data area depends on the card capacity.

All data is stored in the memory card in floating point format. The storage of each data point consumes 3 bytes of the card memory, irrespective of the magnitude of the data. This 3 byte format is referred to as a 'data point equivalent' of data memory.

The number of data points or readings which can be stored in the range of memory card sizes that are supported by the dataTaker is summarised in the table overleaf

 

Capacity

System Area
(Kbytes)

Program Area
(Characters)

Data Area
(Kbytes)

512 Kbytes

8

4090

170,666

1 Mbytes

8

4090

343,980

2 Mbytes

8

4090

693,420

4 Mbytes

8

4090

1,392,300

Internal Memory

   

166,530

 

When input channels are scanned, the data is produced as blocks of data. Each block contains the individual channel data for a single iteration of one Schedule.

When each data block is logged into the memory card, the data block is preceded by a header. This header is used to store information about the particular Schedule, and the timestamp (the date and time) for when the Schedule ran, that produced the block of data.

The header consumes 3 bytes of memory.

The number of executions of Schedules that can actually be logged into a memory card varies depending on the number of channels being scanned, calculations performed, and hence the number of data points stored in each block of data.

For example if the data from one channel is being logged into a 1 Mbyte memory card, then there is a header associated with each block of data containing one data point. Therefore there is a header overhead of 50%, resulting in the storage of approximately 172,700 data points.

Alternatively if the data from 9 channels is being logged into a 1 Mbyte memory card, then there is a header associated with each block of data containing 9 data points. In this case the header overhead is 10%, resulting in the storage of approximately 310,800 data points.

The amount of data stored in a memory card, and the amount of free or unused memory card capacity, can be checked by the STATUS command or STATUS7 command (See Section III ñ Checking Data Storage and Section III ñ Status Command).

Initializing Memory Cards

Before a memory card can be used by the dataTaker to store data and program commands, the memory card must first be initialised or formatted.

Initializing New Memory Cards

Whenever a new memory card is inserted into the dataTaker, the card is automatically initialised and the data storage mode is enabled.

Similarly whenever a memory card in which the battery has been replaced is inserted into the dataTaker, the memory card will be automatically initialised.

Note :  Whenever a memory card battery is replaced, the card memory powers down and loses initialization. Therefore memory cards can be cleared of data in the field if necessary, by removing and replacing the battery.

Initialization of memory cards involves several processes

the integrity of the card memory is checked, and the card capacity is determined

the card memory is divided into system, program and data areas

the program and data areas are cleared

a unique system identification code is assigned to the card

a default user CardID label of "Untitled" is assigned to the card

the memory card is enabled for data storage

if data logging is enabled and data has been stored into the internal data memory before the new card was inserted, then this data is transferred to the data area of the memory card

There are no initialization or formatting commands that must be executed when inserting new memory cards.

Initializing Used Memory Cards

Memory cards which have previously been initialised and used to store data, can be re-initialised at any time by the CDATA and CPROG commands (see below).

The memory card can be tested by the CTEST command, which destructively tests the integrity of the card memory. All stored data and programs are destroyed by this test command.

These commands do not change the system identification code or the user identification.

Memory Card Identification

Whenever a memory card is initialised by the dataTaker, a unique system identification code is assigned to the card. This system identification code is also stored in the dataTaker, and is used to identify the memory card.

Memory cards can also be given a user identification label, which can be used to identify memory cards according to the user name, application, site, data collection period, etc.

The user identification label replaces the default identification label of 'Untitled', which is assigned during initialization of the memory card.

User identification of a memory card is entered by the Memory Card Identification Command, in the general format

CARDID="label"
where label is a text string of up to 40 characters.

The label text string can contain any ASCII characters including spaces and control characters. Control characters are entered in the format ^G (Bell), ^J (LF), ^M (CR). While two characters are required to enter control characters, only one character is stored internally.

Using DeTransfer, a memory card can be labelled by the command for example

CARDID="My Card"

The user identification label for a currently inserted memory card can be returned by the command

CARDID

which for the above example would return

My Card

Using DeLogger, a memory card can be labelled by selecting dataTaker:Memory CardÖ on the main menu bar, or by clicking on the Memory Card button on the main toolbar, to open the Card Options dialog. Click on the Data tab, and enter your card ID into the Card ID field. Click Apply to label the card (which must be inserted into the logger!) and click Close

 

 

 

The user identification label of a memory card can be changed at any time, without effecting the data stored in the memory card.

The identification label is also displayed on the display when any memory card related messages are displayed.

Logging Data to Memory Cards

Whenever a memory card is inserted into the dataTaker, then all data will be logged into the memory card if data logging is enabled (LOGON), and the memory card is enabled for storing data.

Data can only be logged to memory cards which are enabled for data logging by the dataTaker into which the memory card has been inserted.

This policy has been designed to provide greatest security for data already stored in a memory card, and prevents accidental erasure or overwriting of potentially valuable data.

Enabling Memory Cards for Data Logging

There are no specific commands to enable a memory card for data logging. A memory card is enabled for data logging when it is inserted into the dataTaker, in response to a number of criteria as follows

if the memory card inserted is a new memory card, then it is initialised and enabled for data logging

if the memory card inserted is a memory card whose battery has been replaced, then it is initialised and enabled for data logging

if the data area of the memory card inserted has been cleared by the CDATA command elsewhere such as with another dataTaker logger or the dataTaker Memory Card Interface, then it is enabled for data logging

if the memory card inserted has data in the data area, and is cleared by a CDATA command from the host, then the memory card is enabled for data logging

if the memory card inserted has a CDATA command in the program area (see below), then this command is executed. The data area of the memory card is cleared, and the memory card is then enabled for data logging

Note :  The CLEAR and RESET commands cannot be used to clear the data area of a memory card. These commands only clear the internal data memory.

When a newly inserted memory card has data stored in the data area of the card, and there are no commands either in the card or from the host to clear that data, then data cannot be logged to that card.

When a memory card containing data is inserted into the dataTaker, the error message 'E17-clear card data' is returned to the host computer.

The single fundamental rule that determines whether a newly inserted memory card can be enabled for data logging, is that the data area of the card must be clear of data.

Logging Data to the Internal Memory When a Memory Card is Inserted

Whenever a memory card is inserted into the dataTaker, data will always be logged to the memory card if possible. Data will only be logged to the internal data memory in particular circumstances as follows

when the memory card has filled, the data is buffered into the internal data memory for transferring into another memory card when the present card is replaced

when an unfilled memory card is removed, data is buffered into the internal memory for transferring into another memory card when inserted

when a newly inserted memory card contains data and is not enabled for data logging, the data is buffered into the internal memory for transferring into another memory card when inserted

The internal data memory cannot be deliberately used for data storage when a memory card which is enabled for data logging is installed in the dataTaker.

Commencing Data Logging to Memory Cards

A procedure for commencing a data logging application where data is to be logged into a memory card inserted in the dataTaker, is suggested below

insert the memory card into the dataTaker, and clear the data and program areas of the memory card as required using the CDATA and CPROG commands. These commands are described in the sections below

or insert a new memory card

enter the program into the dataTaker. The logging of data to the memory card will commence at the next Schedule trigger when data will first be produced.

Removing and Changing Memory Cards While Logging Data

Most data logging applications involving the use of memory cards often require that the memory cards are periodically removed and changed. Removal and changing of memory cards during a data logging task allows for a variety of scenarios for data collection and transfer.

However the three most common scenarios are as follows

removing a memory card from a remotely located dataTaker.
The memory card is transferred to a central facility where the data is read and processed. The same card is cleared of data after reading, and later returned to the logger.

changing the memory card of a remotely located dataTaker.
The original memory card is removed from the logger for transfer to a central facility where the data will be read and processed. A cleared memory card is installed into the logger at the time that the original card is removed.

remove the memory card from a local dataTaker, and insert memory cards from other dataTakers for reading. The local dataTaker can continue a local data logging application while reading the 'foreign' memory cards, logging the local data into the internal memory. A cleared card is later inserted into the local dataTaker to continue the long term local data logging application.

The implications of each of these scenarios are discussed in the sections below.

Re-inserting the Same Memory Card

If a memory card is removed from a dataTaker, and then re-inserted into the dataTaker which is still running the same program, then the logger

will transfer any data from the internal memory to the memory card, appending this data to that already in the card

will continue to log data to the memory card

This scenario is similar to the scenario where a logger running a program and logging data to a memory card is powered down, powered up and reprogrammed – the logger will continue to log data to the same memory card as previous.

The dataTaker generates a ëunique signatureí for each program entered, and writes this signature to the new/cleared memory card before logging the first data. Each time the logger attempts to write data to a memory card, it checks the signature stored on the memory card with that for the current program

if there is no signature on the card, then the logger accepts this as a new/cleared card and writes the current program signature to the card, then stores data to the card beginning at the start of card data memory area. This is the situation of first use of a new or cleared memory card.

if the two signatures match, then the logger appends the new data block to the existing data records in the card. This is the situation of continued use of an inserted card, or first use of a valid card that has been removed and re-inserted.

if the two signatures do not match, then the logger invalidates the memory card and stores the new data block in the internal memory. This is the situation of a card being exchanged with one that has ‘foreigní data on it.

While a memory card is removed from the dataTaker, the data is logged into the internal memory. If the internal data memory fills or overwrites while the card is removed, then data will be lost. It is the user's responsibility to manage the continuity of data. The data buffered in the internal memory of the logger while the card was removed, is copied to the memory card when the cleared card is re-inserted.

The inverse of this rule is where a dataTaker running a program and logging data to memory card, is reset and a new program entered. In this case the memory card and current program signatures will be different and the card will be invalidated by the logger. The memory card will not be used even though it has not been removed from the logger.

In this case data buffered in the internal memory is not copied to the memory card, and current data continues to be buffered into the internal memory.

When a memory card containing ëforeigní data is inserted into the dataTaker during a data logging application, the card can still be read and cleared by commands from the host computer to the logger. Only data logging to the card is disabled.

Inserting a Different Memory Card

Whenever the memory card is exchanged during a data logging task, the replacement memory card is tested for suitability for data logging as follows

if the memory card is a new card, the card is initialised, any data in the internal memory is transferred to the memory card, and data logging continues to the card

if the memory card is already initialised and has no data in the data area, any data in the internal memory is transferred to the memory card, and data logging continues to the card

if the memory card contains data in the data area, then data cannot be logged to the memory card. The current data continues to be logged into the internal memory, and can be recovered when a new or cleared memory card is inserted.

When a memory card containing ëforeigní data is inserted into the dataTaker during a data logging application, the card can still be read and cleared by commands from the host. Only data logging to the card is disabled.

Controlling the Transfer of Data to Memory Cards

When a memory card is inserted into the dataTaker, the program area of the memory card is searched first and any commands found are downloaded into the logger and executed (See Section III ñ Programming from Memory Cards).

 

Following the execution of any commands present, and if the data area of the card is clear, then any data in the internal data memory is automatically transferred to the memory card.

However the automatic transfer of data can be controlled if required, to synchronize data transfer with programs stored on the memory card.

Forcing the Transfer of Data

The transfer of data can be forced at any time during the execution of a card program, rather than automatically after execution of the card programs. The command

COPY

instructs the dataTaker to transfer data from the internal memory to the memory card when the command is executed, rather than later in the normal course of events.

The following example illustrates the use of the COPY command in a card program. This program is stored in the program area of a memory card.

;COPY
;CLEAR CSCANS
;R10S  1..10TK  LOGON

When the memory card is inserted into a logger, this program in the memory card will

transfer the data from the internal data memory to the data area of the memory card

clear the internal memory and channel table, disable data logging ready for a new program

load the new program Schedules and enable logging again.

If the COPY command had not been used in the above program, the internal memory would have been cleared by the CLEAR command before the dataTaker could automatically transfer the data.

The COPY command is only appropriate for use in programs stored in the memory card. The command has no use when entered directly from a host computer to the dataTaker.

Preventing the Transfer of Data

The automatic transfer of data from the internal data memory to the memory card can be prevented by the command

NOCOPY

which instructs the dataTaker not to transfer data from the internal data memory to the data area of the inserted memory card. The NOCOPY state remains active until the memory card which contains the command is removed. When another memory card is inserted, automatic data transfer is again enabled.

The following example illustrates the use of the NOCOPY command in a card program. This program is stored in the program area of a memory card.

;NOCOPY
;ALARM5(1TK>100)"Temperature Alarm"
;ALARM6(2TK>105)AND
;ALARM7(3TK<140)4DSO

The NOCOPY command is used in this program to instruct the logger not to transfer data from the internal data memory to the memory card at any time while this memory card is inserted in the logger.

This programming example is typical of a memory card being used as a program only card, to enter new alarms or alarm setpoints, change Schedule triggers, etc. while the current program continues.

The data from this operation is logged to the internal memory while this memory card is inserted, but can be copied into the next memory card that is inserted if valid.

The NOCOPY command is only appropriate for use in programs stored in the memory card. The command has no use when entered directly from a host computer or terminal.

Clearing Data from Memory Cards

The data area of memory cards can be cleared of stored data by the command

CDATA

If a host computer is not available, a memory card can be cleared by removing and replacing the internal battery, to allow the card memory to power down.

When the memory card is next inserted into the logger, the card is recognised as a new card and is automatically initialised again for data logging.

Note 1:  The CLEAR command cannot be used to clear the data area of a memory card. The CLEAR command only clears the internal data memory of the dataTaker.

Note 2:  The RESET command cannot be used to clear the data area of a memory card. This command resets the dataTaker, and clears the internal data memory.

Memory Card Test

Memory cards can be tested for integrity by the dataTaker. Insert the memory card intothe logger, and run the CTEST command on the logger. This will perform a write:read test of the card memory, then reformat the card. The dataTaker will then return a response of whether the card passed or failed CTEST.

Beware :  CTEST will erase all data and programs stored on the memory card.

Summary of Memory Card Insertion

The following flow chart indicates how the memory card is managed on insertion.

 

 


The dataTaker has many options available for the returning of data from internal memory and memory cards. When data is unloaded from the memory the memory it is NOT cleared, and can therefore be unloaded in many different formats as many times as required.

Reading of data from memory cards has priority over reading data from the internal data memory. However commands are available to select the internal memory or an inserted memory card for reading.

If data is being logged to the internal data memory, and a memory card that contains ëforeigní data is inserted, then that data can be read from the memory card while local logging continues to the internal memory. Logged data can read be from any inserted memory card, regardless of its validity for data logging.

The Unload Command

Data logged into the internal data memory or into a memory card is returned to the host computer by the Unload command.

The Unload command by default unloads all data from the memory, beginning from the first record. Extensions to the Unload command allow particular data to be unloaded from data memory in terms of the source, schedule and period.

The Unload command is specified in the general format

source schedule (start time,start date)(end time,end date)

where

U                    specifies the Unload command
source             I                     - unloads data from the internal memory
                      M                   - unloads data from the memory card 
                      none                - unloads data from a memory card if inserted,
                                             otherwise from internal memory

schedule          specifies the schedule to be unloaded
                      A, B, C, D, X    - specified schedule is unloaded
                      none                - all schedules are unloaded.

start                sets time and date to unload from
                      time                 - unload from specified time
                      date                - unload from specified date
                      BEGIN             - unload from the beginning of data
                      LAST               - unload from the end of the last unload
                      none                - unload from the beginning of stored data

end                 sets time and date to unload to
                      time                 - unload to specified time
                      date                - unload to specified date
                      END                - unload to the end of data
                      LAST               - unload to the last unload
                      none                - unload to the end of stored data

Each of the above specifiers is optional, however the (end ) can only be included if the (start) is included.

Data is unloaded from the oldest data first. Schedules are merged chronologically and in the order of X, A, B, C, and D.

Each of the Unload command specifiers is discussed in the following sections.

Unloading Data from a Specific Source

Logged data can be selectively unloaded from the internal memory or from an inserted memory card.

If the source is not specified, then the Unload command will unload data from memory as follows

if no memory card is inserted, data is unloaded from the internal memory

if a valid memory card is inserted, then the data is unloaded firstly from the memory card, and then from the internal memory if data for the current task has been logged there. This is only appropriate for the stack mode of data logging (/o).

if an invalid memory card is inserted, then the data is unloaded from the memory card only. Any data in the internal memory cannot be unloaded until the invalid memory card is removed

However the source of data can be specified for the Unload command as the internal memory (UI) or an inserted memory card (UM).

If a memory card is inserted which has data from another dataTaker or from another program run on the same dataTaker, then the current data in internal memory can still be unloaded using the UI Unload command.

If the UM Unload command is entered when no memory card is inserted, then the 'E40-no data found' message is returned.

Unloading Data from a Specific Schedule

Normally data is unloaded by the Unload command from all of the Schedules in chronological order of the data block timestamps. Where more than one Schedule have data blocks with the same timestamp, then data for the timestamp is unloaded in the Schedule order RX, RA, RB, RC then RD.

However data can be unloaded for specific Schedules as follows

UX- unload data for the RX Schedule only
UA- unload data for the RA Schedule only
UB- unload data for the RB Schedule only
UC- unload data for the RC Schedule only
UD- unload data for the RD Schedule only

If a Repeat Scan Schedule is specified for which no data has been logged, then the 'E40-no data found' message is returned.

Unloading Data for a Specific Period

When data from Schedules is logged into data memory, the date and time that the Schedule ran is automatically recorded in the header of each block of data.

These timestamps allow data to be unloaded from the data memory for specific periods of time, even if Time and Date 'channels' were not included in the original Schedules.

The period for which data is to be unloaded from the data memory is defined as the data occurring between a start point and an end point. The start time and start date can be defined as follows

BEGIN      - data is unloaded from the first record in the memory, which is the oldest data
time          - data is unloaded from time, must be in the format defined by Parameter39
date          - data is unloaded from date, must be in the format defined by Parameter31
LAST         - data is unloaded from the end point of the last data unload. This allows data
                   logged since the last unload to be unloaded.
None        - data is unloaded from the first record in the data memory, which is the oldest data

The end time and end date can be defined as follows

END         - data is unloaded to the last record in memory, which is the newest data
time          - data is unloaded to time, which must be in the format defined by Parameter39
date          - data is unloaded to date, which must be in the format defined by Parameter31
LAST         - data is unloaded to the end point of the last data unload. This allows data unloaded
                 earlier to be unloaded again to the same end point.
None        - data is unloaded to the last record in the data memory, which is the newest data

Several considerations apply to the specification of the start point and the end point as follows

if a start time is specified but not a start date, then the current date is assumed

if a start date is specified but not a start time, then the first timestamp for the start date is assumed

if an end time is specified but not an end date, then the current date is assumed

if an end date is specified but not an end time, then the last timestamp for the start date is assumed

if only the start point is specified, then the end of data memory is assumed as the end point

an end point cannot be specified alone, a BEGIN or start point must also be specified

If a period is specified for which no data has been logged, or the end point is earlier than the start point, then the 'E40-no data found' message is returned.

Including Time and Date with Unloaded Data

When data from Schedules is logged into the data memory, the date and time that the Schedule ran is automatically recorded in the header of each block of data.

These timestamps allow data to be unloaded from the data memory with time stamps, even if Date and Time 'channels' were not included in the original Schedules.

Return of the date and time stamps is controlled by the Date Switch and the Time Switch as follows (See Section III ñ Format of Returned Data and Section III ñ Switch Commands)

/D            Enable return of date stamp with data
/d            Disable return of date stamp with data (Default)

/T            Enable return of time stamp with data
/t             Disable return of time stamp with data (Default)

Following initial power up, a hardware reset, or a RESET command, the Date Switch and Time Switch are disabled (/d/t).

The Date Switch and Time Switch can be changed at any time, even during and between unloads of the data memory.

Unloading Data Manually with DeTransfer

The following examples illustrate the use of the Unload command for returning data from the internal memory, or from an inserted memory card.

These commands are used directly with DeTransfer, and the unloaded data is returned into the upper Receive screen of the package and must be saved manually.

U
U(BEGIN)
U(BEGIN)(END)

unloads data from the internal data memory or memory card as appropriate for all Schedules, beginning at the oldest data and ending at the latest data.

UI
UI(BEGIN)(END)

unloads data from the internal data memory for all Schedules, beginning at the oldest data and ending at the latest data.

UMB
UMB(BEGIN)(END)

unloads data from a memory card for Schedule B only, beginning at the oldest data and ending at the latest data.

/D/T
UA(BEGIN)(12:00:00,29/05/92)

unloads data from the internal data memory or memory card for Schedule A, beginning at the oldest data and ending at the specified time and date. The unloaded data is timestamped.

UMA(9:00,28/05/1992)(17:00,29/05/92)

unloads data from a memory card for the Schedule A between the specified times and dates.

UIX(BEGIN)(18:45:00)

unloads data from the internal memory for Schedule X, beginning at the oldest data and ending at the specified time on the current date.

UC(LAST)(END)

unloads data from the internal data memory or memory card for Schedule C, beginning after the last data block unloaded by a previous Unload command and ending at the latest data. This allows unloading of data logged since the previous unload.

P31=0
P39=2
UC(15.75,123)(10.0,125)

the start time, start date, end time and end date are specified per the settings for Parameter31 and Parameter39.

Unloading Data with DeTransfer

DeTransfer has a semi-automated method for unloading logged data fro data loggers. DeTransfer creates the appropriate Unload commands and manages unloading of data.

Select Data Transfer : Unload on the main menu bar, to open the Unload dialog.

The Unload dialog has various panels for defining the parameters for unloading data from the data logger, including data source, schedules, start time and date, and end time and date.

There are also panels too select the timestamps, and to format the timestamps. There is also a panel to define the format for the unloaded data, and to include some details in the top of the data file.

Set the various panels as required, and click the Unload button to commence unloading data. DeTransfer creates the appropriate Unload command from the settings of the various panels, and sends this to the logger. The data is saved into a file, which you have the opportunity to name when the unload is completed.

 

 

Unloading Data with DeLogger

DeLogger also provides support for unloading data.

Select dataTaker:UnloadÖ from the main menu bar, or click on the Unload button on the main tool bar to open the Unload Options dialog.

 

 

The Unload Options dialog provides various panels to specify where to unload data from, which Schedules to unload data for, and the timestamp range for data to unload.

 

When you have set the panels as required, click on the next button to open the Unload to File dialog. If you wish to unload the data to a file, then check the Unload to File check box, and select the file format. CSV File is suitable to exporting to many applications including Microsoft Excel, however cannot be used in DeLogger. Replay File is intended for use in DeLogger. After selecting a file format, enter a name for the file and click the Next button.

 

 

The Unload to Database then opens (DeLogger Pro only), in which you can set up a database session into which to store the unloaded data.

 

 

Finally, click the Finish button to unload of data from the logger into the data storage in DeLogger.

Format of the Unloaded Data

Data is returned to the host computer by the Unload command in the currently defined data item format, and currently defined data block format.

The format of unloaded data can be configured in the same way as data returned in real time. The data format can be changed between successive unloads (See Section III ñ Format of Returned Data).

If you are using the automated facility in DeTransfer or DeLogger to unload data, then these tools will set the logger into Fixed Format mode (/H), and then re-construct the data into the required format within the computer.

Disabling of System Switches

During an Unload operation in Free Format mode (/h), several of the Switch commands are internally disabled to protect the integrity of the unloaded data as follows

the Return Data Switch is disabled (/r) to prevent any current real time scan data from being inserted into the unloaded data stream. However logging of any current scan data will continue during an Unload operation if enabled by LOGON.

the Command Echo Switch is disabled (/e) to prevent commands received during an Unload operation from being echoed into the unloaded data stream.

the Messages Switch is disabled (/m) to prevent any error messages which may be generated during the Unload operation from being inserted into the unloaded data stream.

When unloading is completed, or is Quit (see below), these system switches are returned to their settings prior to beginning the Unload operation. The switches cannot be changed during the unload operation.

If data is unloaded from memory in the Fixed Format mode (/H), then this mode automatically presets all of these switches.

Quitting Data Unloading 

When an Unload operation is in progress, the unload can be aborted by the Unload Quit command

Q

Using DeTransfer, an unload is quit by

Q

Using DeLogger, an unload is quit by selecting dataTaker:Quit Unload on the main menu bar, or by clicking on the Quit button on the main toolbar.

There may be a short delay in DeTransfer and DeLogger between sending the Quit command, and the return of stored data actually stopping.

This is because the output buffer of the dataTaker is generally full during an unload operation, and the contents have still to be returned to the host. Further, there may be buffered data in the computer application as well which has to be cleared.

The Quit command actually stops the copying of stored data into the output buffer of the logger. Any data upstream of this function is not stopped by the Quit command.

Labelling the End of Unloaded Data

A special character can be output from the dataTaker following the last data item of an unload. This character can be used by the host computer to identify the end of an unload operation, to close data files, etc.

The end of unload character is an ASCII character defined by the Parameter25 command. It can be any character in the range ASCII 0 ó 127. The default is ASCII 0 (NULL), for which no character is sent after the last data item.

For example the command

P25=42

defines the end of unload character as the asterisk (*) character (ASCII 42).

An example of the last block of unloaded data terminated by the end of stored data character declared by Parameter25=42 is as follows

Date 29/05/2003
Time  11:37:30
3V -12.15 mV
8C  2267 Counts
20TK  1759.8 Deg C
*

Clearing the Data Store

Unloading the data from the internal data memory or memory card does not clear the data memory. Consequently, data can be returned from the data memory as many times as required.

The internal data memory is cleared by the CLEAR command. This command does not clear the data area of an inserted memory card.

When there is data stored in the internal memory of the dataTaker, new programs or Schedules cannot be entered into the logger until the internal data memory has been cleared by a CLEAR command. This is because the internal channel table is required to interpret the data memory during Unload operations.

The CLEAR command sets the Data Logging command to LOGOFF, and must be set to LOGON again before data logging can recommence.

The data area of an inserted memory card is cleared by the CDATA command. This command does not clear the internal data memory.

Using DeLogger, the internal data memory and memory card are cleared by selecting dataTaker:ClearÖ from the main menu bar, or by clicking the Clear button on the main toolbar.

 

 

 

 

 

This opens the Clear Memory dialog. Check the clear option(s) required, and click the OK button.

Page Content


Home

Title and Waranty

Go to: Section 2 | Section 3

Section 1


Construction of the dataTaker 50

Construction of the dataTaker 500 600

Construction of the CEM

Getting Started

 

Section 2


Interfacing

Powering the dataTaker

Powering Sensors from the dataTaker

The Serial Interfaces

The RS232 COMMS Serial Interface

The NETWORK Interface

Analog Process

Connect Analog

Analog Chns

Measuring Low Level Voltages

Measuring High Level Voltages

Measuring Currents

Measuring 4-20mA Current Loops

Measuring Resistance

Measuring Frequency and Period

Measuring Analog Logic State

Measuring Temperature

Measuring Temperature with Thermocouples

Measuring Temperature with RTDs

Measuring Temperature with IC Temperature Sensors

Measuring Temperature with Thermistors

Measuring Bridges and Strain Gauges

Measuring Vibrating Wire Strain Gauges

The Digital Input Channels

Monitoring Digital State

The Low Speed Counters

The Phase Encoder Counter

The High Speed Counters

The Digital Output Channels

The Channel Expansion Module

Installing The Panel Mount Display

 

Section 3


Programming the dataTaker

Communication Protocols and Commands

Entering Commands and Programs

Format of Returned Data

Specifying Channels

The Analog Input Channels

The Digital Input Channels

The Counter Channels

The Digital Output Channels

The Real Time Clock

The Internal Channels

Channel Options

Schedules

Alarms

Scaling Data - Polynomials, Spans and Functions

CVs Calcs and Histogram

Logging Data to Memory

Programming from Memory Cards

STATUS RESET TEST

Switches and Parameters

Networking

Writing Programs

Keypad and Display

Error Mess Text

Appendix A - ASCII

Appendix B - ADC Timing