Driver for a DS28E18 slave on a 1-Wire bus. More...

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <assert.h>
#include "DS28E18.h"
#include "FreeRTOS.h"
#include "task.h"

Include dependency graph for DS28E18.c:

Go to the source code of this file.

Macros
#define	DELAY_MSEC(msec_) vTaskDelay(pdMS_TO_TICKS(msec_))

#define	PRINTF(...) {}

#define	APPEND_TO_PACKET(s_) { appendToSequencerPacket(s_, sizeof(s_)); }

#define	SPU_Delay_tOP_msec 1

Functions
int	DS28E18_Init ()

int	DS28E18_SetOnewireSpeed (one_wire_speeds spd)

void	DS28E18_SetRomCommand (DS28E18_one_wire_rom_commands_T rom_cmd)

DS28E18_one_wire_rom_commands_T	DS28E18_GetRomCommand ()
	Return the value of 'current_ROM_command'.

bool	DS28E18_WriteSequencer (unsigned short nineBitStartingAddress, const uint8_t *txData, int txDataSize)

bool	DS28E18_ReadSequencer (unsigned short nineBitStartingAddress, uint8_t *rxData, unsigned short readLength)

bool	DS28E18_RunSequencer (unsigned short nineBitStartingAddress, unsigned short runLength)

bool	DS28E18_WriteConfiguration (DS28E18_protocol_speed_T SPD, DS28E18_ignore_nack_T INACK, DS28E18_protocol_T PROT, DS28E18_spi_mode_T SPI_MODE)

bool	DS28E18_ReadConfiguration (uint8_t *rxData)

bool	DS28E18_WriteGpioConfiguration (DS28E18_target_configuration_register_T CFG_REG_TARGET, uint8_t GPIO_HI, uint8_t GPIO_LO)

bool	DS28E18_ReadGpioConfiguration (uint8_t CFG_REG_TARGET, uint8_t *rxData)

bool	DS28E18_DeviceStatus (uint8_t *rxData)

void	DS28E18_BuildPacket_ClearSequencerPacket ()
	Reset local command sequencer packet under construction.

uint8_t *	DS28E18_BuildPacket_GetSequencerPacket ()
	Get address of locally constructed command sequencer packet's data.

int	DS28E18_BuildPacket_GetSequencerPacketSize ()
	Get length of locally constructed command sequencer packet.

void	DS28E18_BuildPacket_Append (const uint8_t *sequencerCmds, size_t length)
	Append commands to locally constructed command sequencer packet.

bool	DS28E18_BuildPacket_WriteAndRun ()

unsigned short	DS28E18_GetLastSequenceLength ()
	Retrieve length of constructed sequence, for use in DS28E18_RerunLastSequence(length)

bool	DS28E18_RerunLastSequence (unsigned int length)

void	DS28E18_BuildPacket_I2C_Start ()

void	DS28E18_BuildPacket_I2C_Stop ()

void	DS28E18_BuildPacket_I2C_WriteData (const uint8_t *i2cData, uint8_t i2cDataSize)

unsigned short	DS28E18_BuildPacket_I2C_ReadData (int readBytes)

unsigned short	DS28E18_BuildPacket_I2C_ReadDataWithNackEnd (int readBytes)

unsigned short	DS28E18_BuildPacket_SPI_WriteReadByte (const uint8_t *spiWriteData, uint8_t spiWriteDataSize, int readBytes, bool fullDuplex)

unsigned short	DS28E18_BuildPacket_SPI_WriteReadBit (const uint8_t *spiWriteData, uint8_t spiWriteDataSize, int writeBits, int readBits)

void	DS28E18_BuildPacket_SPI_SlaveSelectHigh ()

void	DS28E18_BuildPacket_SPI_SlaveSelectLow ()

void	DS28E18_BuildPacket_Utility_Delay (DS28E18_utility_delay_T delayTimeInMsExponent)

void	DS28E18_BuildPacket_Utility_SensVddOn ()

void	DS28E18_BuildPacket_Utility_SensVddOff ()

void	DS28E18_BuildPacket_Utility_GpioBufferWrite (uint8_t GPIO_BUF)

unsigned short	DS28E18_BuildPacket_Utility_GpioBufferRead ()

void	DS28E18_BuildPacket_Utility_GpioControlWrite (uint8_t GPIO_CRTL_HI, uint8_t GPIO_CRTL_LO)

unsigned short	DS28E18_BuildPacket_Utility_GpioControlRead ()

Variables
OneWire_ROM_ID_T	current_DS28E18_ROM_ID
	DS28E18 device addressed for current operations (may be one of many on 1-Wire bus)

Detailed Description

Driver for a DS28E18 slave on a 1-Wire bus.

Update history - Cleanups by Dave Nadler

30-October-2023 Initial version.
13-March-2026 Added many missing error checks.

Todo:

Isolate DELAY_MSEC to make porting easier.

Use OneWire_ROM_ID_T for ROM ID in DS2485 code.

Add DS28E18 status register structure definition and interpretation.

Make a DS28E18 class to support multiple DS28E18 devices more easily.

Definition in file DS28E18.c.

Function Documentation

◆ DS28E18_BuildPacket_I2C_ReadData()

unsigned short DS28E18_BuildPacket_I2C_ReadData ( int readBytes )

Sequencer Command: Read Data (D4h).

Append an I2C Read Data command to the locally constructed command sequencer packet.

Parameters

readBytes Number of bytes to read from the I2C bus

Returns: readArrayFFhStartingAddress - Address where I2C slave response will reside

Definition at line 795 of file DS28E18.c.

 {
     unsigned short readArrayFFhStartingAddress = localPacket.sequenceIdx + 2;
     uint8_t i2c_read_data[2 + readBytes];
 
     i2c_read_data[0] = I2C_READ_DATA;
     if (readBytes == 256)
     {
         i2c_read_data[1] = 0;
     }
     else
     {
         i2c_read_data[1] = readBytes;
     }
     memset(&i2c_read_data[2], 0xFF, readBytes); // Note: This set read bytes to 0xFF in sequencer memory prior to actual read
     APPEND_TO_PACKET(i2c_read_data);
     return readArrayFFhStartingAddress;
 }

◆ DS28E18_BuildPacket_I2C_ReadDataWithNackEnd()

unsigned short DS28E18_BuildPacket_I2C_ReadDataWithNackEnd ( int readBytes )

Sequencer Command: Read Data w/NACK end (D3h).

Append an I2C Read Data w/NACK end command to the locally constructed command sequencer packet.

Parameters

readBytes Number of bytes to read from the I2C bus

Returns: readArrayFFhStartingAddress - Address where I2C slave response will reside

Definition at line 822 of file DS28E18.c.

 {
     unsigned short readArrayFFhStartingAddress = localPacket.sequenceIdx + 2;
     uint8_t i2c_read_data_with_nack_end[2 + readBytes];
     i2c_read_data_with_nack_end[0] = I2C_READ_DATA_W_NACK_END;
     if (readBytes == 256)
     {
         i2c_read_data_with_nack_end[1] = 0;
     }
     else
     {
         i2c_read_data_with_nack_end[1] = readBytes;
     }
     memset(&i2c_read_data_with_nack_end[2], 0xFF, readBytes); // Note: This set read bytes to 0xFF in sequencer memory prior to actual read
     APPEND_TO_PACKET(i2c_read_data_with_nack_end);
     return readArrayFFhStartingAddress;
 }

◆ DS28E18_BuildPacket_I2C_Start()

void DS28E18_BuildPacket_I2C_Start ( void )

Sequencer Command: Start (02h).

Append an I2C Start command to the locally constructed command sequencer packet.

Definition at line 755 of file DS28E18.c.

 {
     static const uint8_t i2c_start[1] = { I2C_START };
     APPEND_TO_PACKET(i2c_start);
 }

◆ DS28E18_BuildPacket_I2C_Stop()

void DS28E18_BuildPacket_I2C_Stop ( void )

Sequencer Command: Stop (03h).

Append an I2C Stop command to the locally constructed command sequencer packet.

Definition at line 765 of file DS28E18.c.

 {
     static const uint8_t i2c_stop[1] = { I2C_STOP };
     APPEND_TO_PACKET(i2c_stop);
 }

◆ DS28E18_BuildPacket_I2C_WriteData()

void DS28E18_BuildPacket_I2C_WriteData	(	const uint8_t *	i2cData,
		uint8_t	i2cDataSize
	)

Sequencer Command: Write Data (E3h).

Append an I2C Write Data command to the locally constructed command sequencer packet.

Parameters

i2cData	Array with data to be transmitted over the I2C bus
i2cDataSize	Number of elements found in i2cData array

Definition at line 778 of file DS28E18.c.

 {
     uint8_t i2c_write_data[2 + i2cDataSize];
     i2c_write_data[0] = I2C_WRITE_DATA;
     i2c_write_data[1] = i2cDataSize;
     memcpy(&i2c_write_data[2], i2cData, i2cDataSize);
     APPEND_TO_PACKET(i2c_write_data);
 }

◆ DS28E18_BuildPacket_SPI_SlaveSelectHigh()

void DS28E18_BuildPacket_SPI_SlaveSelectHigh ( void )

Sequencer Command: SPI SS_High (01h).

Append an SPI SS_High command to the locally constructed command sequencer packet.

Definition at line 1078 of file DS28E18.c.

 {
     static const uint8_t spi_slave_select_high[1] = { SPI_SS_HIGH };
     APPEND_TO_PACKET(spi_slave_select_high);
 }

◆ DS28E18_BuildPacket_SPI_SlaveSelectLow()

void DS28E18_BuildPacket_SPI_SlaveSelectLow ( void )

Sequencer Command: SPI SS_Low (80h).

Append an SPI SS_Low command to the locally constructed command sequencer packet.

Definition at line 1088 of file DS28E18.c.

 {
     static const uint8_t spi_slave_select_low[1] = { SPI_SS_LOW };
     APPEND_TO_PACKET(spi_slave_select_low);
 }

◆ DS28E18_BuildPacket_SPI_WriteReadBit()

unsigned short DS28E18_BuildPacket_SPI_WriteReadBit	(	const uint8_t *	spiWriteData,
		uint8_t	spiWriteDataSize,
		int	writeBits,
		int	readBits
	)

Sequencer Command: SPI Write/Read Bit (B0h).

Append an SPI Write/Read Bit command to the locally constructed command sequencer packet.

Parameters

spiWriteData	Array with data to be transmitted over the SPI bus. Data not important if only reading.
spiWriteDataSize	Number of elements found in spiWriteData array. Set to 0 if only reading.
writeBits	Number of bits to write to SPI bus. Set to 0 if only reading.
readBits	Number of bits to read from SPI bus. Set to 0 if only writting.

Returns: readArrayFFhStartingAddress - If reading, address where SPI slave response will reside.

Definition at line 955 of file DS28E18.c.

 {
     uint8_t readBitsInBytes = 0;
     unsigned short readArrayFFhStartingAddress = 0;
     uint8_t spi_write_read_data_bit[255];
     int idx = 0;
 
     if (readBits > 0 && readBits < 9)
     {
         readBitsInBytes = 1;
     }
     else if (readBits >= 9 && readBits < 17)
     {
         readBitsInBytes = 2;
     }
     else if (readBits >= 17 && readBits < 25)
     {
         readBitsInBytes = 3;
     }
     else if (readBits >= 25 && readBits < 33)
     {
         readBitsInBytes = 4;
     }
     else if (readBits >= 33 && readBits < 41)
     {
         readBitsInBytes = 5;
     }
     else if (readBits >= 41 && readBits < 49)
     {
         readBitsInBytes = 6;
     }
     else if (readBits >= 49 && readBits < 57)
     {
         readBitsInBytes = 7;
     }
     else if (readBits >= 57 && readBits < 65)
     {
         readBitsInBytes = 8;
     }
 
     //command
     spi_write_read_data_bit[idx++] = SPI_WRITE_READ_BIT;
 
     if (writeBits != 0 && readBits != 0)
     {
         //Write Length
         spi_write_read_data_bit[idx++] = writeBits;
 
         //Read Length
         spi_write_read_data_bit[idx++] = readBits;
 
         //Write Array
         for (int i = 0; i < spiWriteDataSize; i++)
         {
             spi_write_read_data_bit[idx++] = spiWriteData[i];
         }
 
         //Read Array
         readArrayFFhStartingAddress = idx;
         memset(&spi_write_read_data_bit[idx], 0xFF, readBitsInBytes);
         idx += readBitsInBytes;
     }
 
     else if(writeBits != 0 && readBits == 0)
     {
         //Write Length
         spi_write_read_data_bit[idx++] = writeBits;
 
         //Read Length
         spi_write_read_data_bit[idx++] = 0;
 
         //Write Array
         for (int i = 0; i < spiWriteDataSize; i++)
         {
             spi_write_read_data_bit[idx++] = spiWriteData[i];
         }
 
         //Read Array
         //omitted
     }
 
     else if(writeBits == 0 && readBits != 0)
     {
         //Write Length
         spi_write_read_data_bit[idx++] = 0;
 
         //Read Length
         spi_write_read_data_bit[idx++] = readBits;
 
         //Write Array
         //omitted
 
         //Read Array
         readArrayFFhStartingAddress = idx;
         memset(&spi_write_read_data_bit[idx], 0xFF, readBitsInBytes);
         idx += readBitsInBytes;
     }
 
     else
     {
         //Write Length
         spi_write_read_data_bit[idx++] = 0;
 
         //Read Length
         spi_write_read_data_bit[idx++] = 0;
 
         //Write Array
         //omitted
 
         //Read Array
         //omitted
     }
 
     readArrayFFhStartingAddress += localPacket.sequenceIdx;
     appendToSequencerPacket(spi_write_read_data_bit,idx);
 
     return readArrayFFhStartingAddress;
 }

◆ DS28E18_BuildPacket_SPI_WriteReadByte()

unsigned short DS28E18_BuildPacket_SPI_WriteReadByte	(	const uint8_t *	spiWriteData,
		uint8_t	spiWriteDataSize,
		int	readBytes,
		bool	fullDuplex
	)

Sequencer Command: SPI Write/Read Byte (C0h).

Append an SPI Write/Read Byte command to the locally constructed command sequencer packet.

Parameters

spiWriteData	Array with data to be transmitted over the SPI bus. Data not important if only reading.
spiWriteDataSize	Number of elements found in spiWriteData array. Set to 0 if only reading.
readBytes	Number of bytes to read from SPI bus. Set to 0 if only writting.
fullDuplex	Set 'true' when interfacing with a full duplex SPI slave. Otherwise, set 'false'

Returns: readArrayFFhStartingAddress - If reading, address where SPI slave response will reside.

Definition at line 851 of file DS28E18.c.

 {
     unsigned short readArrayFFhStartingAddress = 0;
     uint8_t spi_write_read_data_byte[255];
     int idx = 0;
 
     //command
     spi_write_read_data_byte[idx++] = SPI_WRITE_READ_BYTE;
 
     if (spiWriteDataSize != 0 && readBytes != 0)
     {
         //Write Length
         spi_write_read_data_byte[idx++] = spiWriteDataSize;
 
         //Read Length
         spi_write_read_data_byte[idx] = readBytes;
         if (!fullDuplex)
         {
             spi_write_read_data_byte[idx] += spiWriteDataSize;
         }
         idx++;
 
         //Write Array
         for (int i = 0; i < spiWriteDataSize; i++)
         {
             spi_write_read_data_byte[idx++] = spiWriteData[i];
         }
 
         //Read Array
         if (!fullDuplex)
         {
             memset(&spi_write_read_data_byte[idx], 0xFF, spiWriteDataSize);
             idx += spiWriteDataSize;
         }
         readArrayFFhStartingAddress = idx;
         memset(&spi_write_read_data_byte[idx], 0xFF, readBytes);
         idx += readBytes;
     }
 
     else if(spiWriteDataSize != 0 && readBytes == 0)
     {
         //Write Length
         spi_write_read_data_byte[idx++] = spiWriteDataSize;
 
         //Read Length
         spi_write_read_data_byte[idx++] = 0;
 
         //Write Array
         for (int i = 0; i < spiWriteDataSize; i++)
         {
             spi_write_read_data_byte[idx++] = spiWriteData[i];
         }
 
         //Read Array
         //omitted
     }
 
     else if(spiWriteDataSize == 0 && readBytes != 0)
     {
         //Write Length
         spi_write_read_data_byte[idx++] = 0;
 
         //Read Length
         spi_write_read_data_byte[idx++] = readBytes;
 
         //Write Array
         //omitted
 
         //Read Array
         readArrayFFhStartingAddress = idx;
         memset(&spi_write_read_data_byte[idx], 0xFF, readBytes);
         idx += readBytes;
     }
 
     else
     {
         //Write Length
         spi_write_read_data_byte[idx++] = 0;
 
         //Read Length
         spi_write_read_data_byte[idx++] = 0;
 
         //Write Array
         //omitted
 
         //Read Array
         //omitted
     }
     readArrayFFhStartingAddress += localPacket.sequenceIdx;
     appendToSequencerPacket(spi_write_read_data_byte, idx);
     return readArrayFFhStartingAddress;
 }

◆ DS28E18_BuildPacket_Utility_Delay()

void DS28E18_BuildPacket_Utility_Delay ( DS28E18_utility_delay_T delayTimeInMsExponent )

Sequencer Command: Delay (DDh).

Append a Delay command to the locally constructed command sequencer packet.

Definition at line 1098 of file DS28E18.c.

 {
     uint16_t delayTimeInMs = 1U << (uint16_t)delayTimeInMsExponent;
     localPacket.totalSequencerDelayTime += delayTimeInMs;
     uint8_t utility_delay_sequence[2] = { UTILITY_DELAY, delayTimeInMsExponent };
     APPEND_TO_PACKET(utility_delay_sequence);
 }

◆ DS28E18_BuildPacket_Utility_GpioBufferRead()

unsigned short DS28E18_BuildPacket_Utility_GpioBufferRead ( void )

Sequencer Command: GPIO_BUF Read (1Dh).

Append a GPIO_BUF Read command to the locally constructed command sequencer packet.

Returns: readArrayFFhStartingAddress - Starting address where configuration data will reside.

Definition at line 1144 of file DS28E18.c.

 {
     unsigned short readArrayFFhStartingAddress = localPacket.sequenceIdx + 1;
     static const uint8_t utility_gpio_buff_read[2] = { UTILITY_GPIO_BUF_READ, 0xFF };
     APPEND_TO_PACKET(utility_gpio_buff_read);
     return readArrayFFhStartingAddress;
 }

◆ DS28E18_BuildPacket_Utility_GpioBufferWrite()

void DS28E18_BuildPacket_Utility_GpioBufferWrite ( uint8_t GPIO_BUF )

Sequencer Command: GPIO_BUF Write (D1h).

Append a GPIO_BUF Write command to the locally constructed command sequencer packet.

Parameters

GPIO_BUF Buffer register high byte.

Definition at line 1132 of file DS28E18.c.

 {
     uint8_t utility_gpio_buff_write[2] = { UTILITY_GPIO_BUF_WRITE, GPIO_BUF };
     APPEND_TO_PACKET(utility_gpio_buff_write);
 }

◆ DS28E18_BuildPacket_Utility_GpioControlRead()

unsigned short DS28E18_BuildPacket_Utility_GpioControlRead ( void )

Sequencer Command: GPIO_CNTL Read (2Eh).

Append a GPIO_CNTL Read command to the locally constructed command sequencer packet.

Returns: readArrayFFhStartingAddress - Starting address where configuration data will reside.

Definition at line 1171 of file DS28E18.c.

 {
     unsigned short readArrayFFhStartingAddress = localPacket.sequenceIdx + 1;
     static const uint8_t utility_gpio_cntl_read[3] = { UTILITY_GPIO_CNTL_READ, 0xFF, 0xFF };
     APPEND_TO_PACKET(utility_gpio_cntl_read);
     return readArrayFFhStartingAddress;
 }

◆ DS28E18_BuildPacket_Utility_GpioControlWrite()

void DS28E18_BuildPacket_Utility_GpioControlWrite	(	uint8_t	GPIO_CRTL_HI,
		uint8_t	GPIO_CRTL_LO
	)

Sequencer Command: GPIO_CNTL Write (E2h).

Append a GPIO_CNTL Write command to the locally constructed command sequencer packet.

Parameters

GPIO_CRTL_HI	Control register high byte.
GPIO_CRTL_LO	Control register low byte.

Definition at line 1159 of file DS28E18.c.

 {
     uint8_t utility_gpio_cntl_write[3] = { UTILITY_GPIO_CNTL_WRITE, GPIO_CRTL_HI, GPIO_CRTL_LO };
     APPEND_TO_PACKET(utility_gpio_cntl_write);
 }

◆ DS28E18_BuildPacket_Utility_SensVddOff()

void DS28E18_BuildPacket_Utility_SensVddOff ( void )

Sequencer Command: SENS_VDD Off (BBh).

Append a 'SENS_VDD Off' command to the locally constructed command sequencer packet.

Definition at line 1120 of file DS28E18.c.

 {
     static const uint8_t utility_sens_vdd_off[1] = { UTILITY_SENS_VDD_OFF };
     APPEND_TO_PACKET(utility_sens_vdd_off);
 }

◆ DS28E18_BuildPacket_Utility_SensVddOn()

void DS28E18_BuildPacket_Utility_SensVddOn ( void )

Sequencer Command: SENS_VDD On (CCh).

Append a 'SENS_VDD On' command to the locally constructed command sequencer packet.

Definition at line 1110 of file DS28E18.c.

 {
     static const uint8_t utility_sens_vdd_on[1] = { UTILITY_SENS_VDD_ON };
     APPEND_TO_PACKET(utility_sens_vdd_on);
 }

◆ DS28E18_BuildPacket_WriteAndRun()

bool DS28E18_BuildPacket_WriteAndRun ( void )

Write locally constructed command sequencer packet into DS28E18's sequence memory over 1wire, run it, and wait long enough for completion. Does NOT fetch any response; use DS28E18_ReadSequencer for that.

Definition at line 730 of file DS28E18.c.

References DS28E18_RunSequencer(), and DS28E18_WriteSequencer().

 {
     //printf("\n\n-- Load packet sequence into DS28E18's sequence memory --");
     bool success = DS28E18_WriteSequencer(0x000, localPacket.sequenceData, localPacket.sequenceIdx);
     //printf("\n\n-- Run packet sequence --");
     if(success) success = DS28E18_RunSequencer(0x000, localPacket.sequenceIdx);
     return success;
 }

◆ DS28E18_DeviceStatus()

bool DS28E18_DeviceStatus ( uint8_t * rxData )

Device Function Command: Device Status (7Ah)

Parameters

[out] rxData Array of 4 bytes to receive DS28E18's status information

Returns: true - command successful
false - command failed

Definition at line 685 of file DS28E18.c.

 {
     uint8_t parameters[0]; //no parameters
     const int response_length = 5;
     uint8_t response[response_length];
 
     if (!run_command(DEVICE_STATUS, parameters, 0, SPU_Delay_tOP_msec, response))
     {
         return false;
     }
 
     memcpy(rxData, &response[1], response_length - 1);
     return returnDeviceResponseResult(response[0]);
 }

◆ DS28E18_Init()

int DS28E18_Init ( void )

Initialize all DS28E18 on the 1-Wire bus.

Returns: number of DS28E18 found on the bus.

Definition at line 122 of file DS28E18.c.

 {
     int devicesFound = 0;
     int error = 0;
 
     PRINTF("-- Populate unique ROM ID of **ALL** devices on 1-Wire line   --\n");
     PRINTF("-- .. using Write GPIO Configuration command (ignore result)  --\n");
     error = DS28E18_SetOnewireSpeed(STANDARD);  // Set DS2485 master 1-Wire speed, must be standard during search
     if (error)
     {
         return 0; // no devices found because of error...
     }
     DS28E18_SetRomCommand(SKIP_ROM); // Skip trying to match a particular ROM ID
     DS28E18_WriteGpioConfiguration(CONTROL, 0xA5, 0x0F); // populate all DS28E18 ROMID etc. Write is not addressed to a specific DS28E18 (now in SKIP_ROM mode)
     DS28E18_SetRomCommand(MATCH_ROM); // for all subsequent operations...
 
     PRINTF("-- Search and initialize every device found on the 1-Wire line --\n");
     // Temporary ID tracks last DS28E18 found, may be clobbered if there's a DS2485 error...
     OneWire_ROM_ID_T temp_rom_id = { .ID = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
     bool last_device_found = false;
     while ( !last_device_found )
     {
         // Look for the next DS28E18
         bool startNewSearch = (devicesFound==0);
         int searchError = OneWire_Search(&temp_rom_id, startNewSearch, &last_device_found);
         if(searchError) break;
         devicesFound++;
 
         PRINTF("Found ROM ID: x");
         #ifdef DS28E18_ENABLE_PRINTF_DEBUGGING
             for(uint8_t i = 0; i < sizeof(temp_rom_id.ID); i++)
             {
                 printf("%02X", temp_rom_id.ID[i]);
             }
             printf("\n");
         #endif
 
         // ToDo 1-Wire: DS28E18_Init() assumes any 1-Wire device found on the bus is a DS28E18
         current_DS28E18_ROM_ID = temp_rom_id; // Set active DS28E18 to device just found
 
         PRINTF("-- Write GPIO Configuration so the voltage on GPIO ports is known --\n");
         if(!DS28E18_WriteGpioConfiguration(CONTROL, 0xA5, 0x0F))
         {
             return false;
         }
 
         PRINTF("-- Read Device Status information (clears POR status bit) --\n");
         uint8_t status[4] = {0xFF, 0xFF, 0xFF, 0xFF};
         if(!DS28E18_DeviceStatus(status))
         {
             return false;
         }
         else
         {
             PRINTF("-- Status: ");
             #ifdef DS28E18_ENABLE_PRINTF_DEBUGGING
                 for(uint8_t i = 0; i < sizeof(status); i++)
                 {
                     printf("%02X.", status[i]);
                 }
                 printf("\n");
             #endif
         }
     };
 
     DS28E18_BuildPacket_ClearSequencerPacket(); // general initialization (sequencer is not used during Init() above).
 
     return devicesFound>0;
 }

◆ DS28E18_ReadConfiguration()

bool DS28E18_ReadConfiguration ( uint8_t * rxData )

Device Function Command: Read Configuration (6Ah)

Parameters

[out] rxData Array of 2 bytes to be updated with devices' configuration information

Returns: true - command successful
false - command failed

Definition at line 608 of file DS28E18.c.

 {
     uint8_t parameters[0]; //no parameters
     int response_length = 2;
     uint8_t response[response_length];
 
     if (!run_command(READ_CONFIGURATION, parameters, 0, SPU_Delay_tOP_msec, response))
     {
         return false;
     }
 
     memcpy(rxData, &response[1], response_length - 1);
 
     return returnDeviceResponseResult(response[0]);
 }

◆ DS28E18_ReadGpioConfiguration()

bool DS28E18_ReadGpioConfiguration	(	uint8_t	CFG_REG_TARGET,
		uint8_t *	rxData
	)

Device Function Command: Read GPIO Configuration (7Ch)

Parameters

	CFG_REG_TARGET	Desired GPIO Configuration Register from macros to read from
[out]	rxData	Array of 2 bytes to be updated with device current GPIO configuration for GPIO_HI and GPIO_LO

Returns: true - command successful
false - command failed

Definition at line 660 of file DS28E18.c.

 {
     uint8_t parameters[2];
     const int response_length = 3;
     uint8_t response[response_length];
 
     parameters[0] = CFG_REG_TARGET;
     parameters[1] = 0x03;
 
     if (!run_command(READ_GPIO_CONFIGURATION, parameters, sizeof(parameters), SPU_Delay_tOP_msec, response))
     {
         return false;
     }
 
     memcpy(rxData, &response[1], response_length - 1);
     return returnDeviceResponseResult(response[0]);
 }

◆ DS28E18_ReadSequencer()

bool DS28E18_ReadSequencer	(	unsigned short	nineBitStartingAddress,
		uint8_t *	rxData,
		unsigned short	readLength
	)

Device Function Command: Read Sequencer (22h)

Parameters

	nineBitStartingAddress	Target read address
	readLength	Number of data bytes to be read from the sequencer memory starting from the target read address
[out]	rxData	Array of data returned from specified memory address

Returns: true - command successful
false - command failed

Definition at line 449 of file DS28E18.c.

 {
     uint8_t parameters[2];
     int response_length = 1 + readLength;
     uint8_t response[response_length];
     uint8_t addressLow;
     uint8_t addressHigh;
 
     if (readLength == 128)
     {
         readLength = 0;
     }
 
     addressLow = nineBitStartingAddress & 0xFF;
     addressHigh = (nineBitStartingAddress >> 8) & 0x01;
 
     parameters[0] = addressLow;
     parameters[1] = (readLength << 1) | addressHigh;
 
     if (!run_command(READ_SEQUENCER, parameters, sizeof(parameters), SPU_Delay_tOP_msec, response))
     {
         return false;
     }
 
     memcpy(rxData, &response[1], response_length - 1);
 
     // Parse result byte.
     switch (response[0]) {
     case SUCCESS:
         // Success response.
         break;
 
     case INVALID_PARAMETER:
         PRINTF("Error: Invalid input or parameter\n");
         return false;
 
     default:
         PRINTF("Error: 1-Wire Communication Error\n");
         return false;
     }
 
     return true;
 }

◆ DS28E18_RerunLastSequence()

bool DS28E18_RerunLastSequence ( unsigned int length )

Run last locally constructed and loaded command sequencer packet in DS28E18's sequence memory and wait long enough for completion. Presumes start at 0x000. DRN addition. Does NOT fetch any response; use DS28E18_ReadSequencer for that.

Definition at line 745 of file DS28E18.c.

References DS28E18_RunSequencer().

                                                     {
     // As above, but skip: bool success = DS28E18_WriteSequencer(0x000, localPacket.sequenceData, localPacket.sequenceIdx);
     //printf("\n\n-- Run packet sequence --");
     bool success = DS28E18_RunSequencer(0x000, length);
     return success;
 }

◆ DS28E18_RunSequencer()

bool DS28E18_RunSequencer	(	unsigned short	nineBitStartingAddress,
		unsigned short	runLength
	)

Device Function Command: Run Sequencer (33h) - Command DS28E18 over 1wire to run a command sequence already placed in DS28E18 sequence memory

Parameters

nineBitStartingAddress	Target run address
runLength	Number of data bytes to run from the sequencer memory starting from the target run address

Returns: true - command successful
false - command failed

Definition at line 501 of file DS28E18.c.

Referenced by DS28E18_BuildPacket_WriteAndRun(), and DS28E18_RerunLastSequence().

 {
     uint8_t parameters[3];
     int response_length = 3;
     uint8_t response[response_length];
     uint8_t addressLow;
     uint8_t addressHigh;
     uint8_t sequencerLengthLow;
     uint8_t sequencerLengthHigh;
     int totalSequencerCommunicationTime = 0;
     int snackLo;
     int snackHi;
     unsigned short nackOffset;
 
     if (runLength == 512)
     {
         runLength = 0;
     }
 
     addressLow = nineBitStartingAddress & 0xFF;
     addressHigh = (nineBitStartingAddress >> 8) & 0x01;
     sequencerLengthLow = ((runLength & 0x7F) << 1);
     sequencerLengthHigh = ((runLength >> 7) & 0x03);
 
     parameters[0] = addressLow;
     parameters[1] = sequencerLengthLow | addressHigh;
     parameters[2] = sequencerLengthHigh;
 
     #if 0 // Replace stunningly INSANE looping and floating-point coding
         for (float i = 0; i < (runLength / 10); i++)  //add 1ms to Run Sequencer delay for every 10 sequencer commands
         {
             totalSequencerCommunicationTime += 1;
         }
         localPacket.totalSequencerDelayTime += localPacket.totalSequencerDelayTime * 0.05; // Add ~5% to delay option time for assurance
     #else
         totalSequencerCommunicationTime += (runLength / 10); // add 1ms to Run Sequencer delay for every 10 sequencer commands
         localPacket.totalSequencerDelayTime += localPacket.totalSequencerDelayTime / 20; // Add ~5% to delay option time for assurance
     #endif
 
     int run_sequencer_delay_msec = SPU_Delay_tOP_msec + localPacket.totalSequencerDelayTime + totalSequencerCommunicationTime;
 
     if (!run_command(RUN_SEQUENCER, parameters, sizeof(parameters), run_sequencer_delay_msec, response))
     {
         return false;
     }
 
     // Parse result byte.
     switch (response[0]) {
 
     case POR_OCCURRED:
         PRINTF("Error: POR occurred resulting in the command sequencer memory being set to zero\n");
         return false;
 
     case EXECUTION_ERROR:
         PRINTF("Error: Execution Error (Sequencer Command packet or packets incorrectly formed)\n");
         return false;
 
     case NACK_OCCURED:
         snackLo = response[1];
         snackHi = response[2];
         nackOffset = snackLo + (snackHi << 8);
         if (nackOffset == 0)
         {
             nackOffset = 512;
         }
         PRINTF("Error: RunSequencer NACK occurred at sequencer byte index: %d\n", nackOffset);
         return false;
 
     default:
         break;
     }
 
     return returnDeviceResponseResult(response[0]);
 }

◆ DS28E18_SetOnewireSpeed()

int DS28E18_SetOnewireSpeed ( one_wire_speeds spd )

Set desired 1-Wire speed between Standard and Overdrive for both, 1-Wire master and slave.

Returns: 0 - At least one device is detected after a 1-Wire reset is performed on new speed. 1 - Failure.

Definition at line 197 of file DS28E18.c.

 {
     int error = 1;
     switch (spd)
     {
         case STANDARD:
             PRINTF("STANDARD*\n");
             //Set host speed to Standard
             error = OneWire_Set_OneWireMasterSpeed(STANDARD);
             if (error) break;
             // do a 1-Wire reset in Standard and catch presence result
             error = OneWire_ResetPulse();
             break;
         case OVERDRIVE:
             PRINTF("OVERDRIVE*\n");
             //From Standard speed, do a 1-wire reset + Overdrive Skip ROM to set every device on the line to Overdrive
             error = OneWire_ResetPulse();
             if (error) break;
             error = OneWire_WriteByte(OVERDRIVE_SKIP);
             if (error) break;
             DELAY_MSEC(40);
             //Set host speed to Overdrive
             error = OneWire_Set_OneWireMasterSpeed(OVERDRIVE);
             if (error) break;
             // do a 1-Wire reset in Overdrive and catch presence result
             error = OneWire_ResetPulse();
             break;
         default:
             break;
     }
     return error;
 }

◆ DS28E18_SetRomCommand()

void DS28E18_SetRomCommand ( DS28E18_one_wire_rom_commands_T rom_cmd )

Set 1-Wire 'current_ROM_command' (normally MATCH_ROM, SKIP_ROM during device search). Does not send anything to lower-level code; just sets the operating mode for this DS28E18 layer.

Definition at line 232 of file DS28E18.c.

References MATCH_ROM, and SKIP_ROM.

 {
     assert(rom_cmd==MATCH_ROM || rom_cmd==SKIP_ROM);
     current_ROM_command = rom_cmd;
 }

◆ DS28E18_WriteConfiguration()

bool DS28E18_WriteConfiguration	(	DS28E18_protocol_speed_T	SPD,
		DS28E18_ignore_nack_T	INACK,
		DS28E18_protocol_T	PROT,
		DS28E18_spi_mode_T	SPI_MODE
	)

Device Function Command: Write Configuration (55h)

Parameters

SPD	Desired protocol speed from macros
INACK	Desired INACK configuration from macros
PROT	Desired protocol from macros
SPI_MODE	Desired SPI Mode from macros

Returns: true - command successful
false - command failed

Definition at line 586 of file DS28E18.c.

 {
     uint8_t parameters[1];
     uint8_t response[1];
 
     parameters[0] = (SPI_MODE << 4) | (PROT << 3) | (INACK << 2) | SPD;
 
     if (!run_command(WRITE_CONFIGURATION, parameters, sizeof(parameters), SPU_Delay_tOP_msec, response))
     {
         return false;
     }
 
     return returnDeviceResponseResult(response[0]);
 }

◆ DS28E18_WriteGpioConfiguration()

bool DS28E18_WriteGpioConfiguration	(	DS28E18_target_configuration_register_T	CFG_REG_TARGET,
		uint8_t	GPIO_HI,
		uint8_t	GPIO_LO
	)

Device Function Command: Write GPIO Configuration (83h)

Parameters

CFG_REG_TARGET	Desired GPIO Configuration Register to write to
GPIO_HI	Control/Buffer register high byte
GPIO_LO	Control/Buffer register low byte

Returns: true - command successful
false - command failed

Note: Use GPIO Configuration functions to help build GPIO_HI/GPIO_LO parameter.

Definition at line 635 of file DS28E18.c.

 {
     uint8_t parameters[4];
     uint8_t response[1];
 
     parameters[0] = CFG_REG_TARGET; // 0Bh: GPIO control register, 0Ch: GPIO buffer register
     parameters[1] = 0x03;
     parameters[2] = GPIO_HI;
     parameters[3] = GPIO_LO;
 
     if (!run_command(WRITE_GPIO_CONFIGURATION, parameters, sizeof(parameters), SPU_Delay_tOP_msec, response))
     {
         return false;
     }
     return returnDeviceResponseResult(response[0]);
 }

◆ DS28E18_WriteSequencer()

bool DS28E18_WriteSequencer	(	unsigned short	nineBitStartingAddress,
		const uint8_t *	txData,
		int	txDataSize
	)

Device Function Command: Write Sequencer (11h) - Write command sequence into DS28E28 sequencer memory over 1Wire

Parameters

nineBitStartingAddress	Target write address
txData	Array of data to be written into the sequencer memory starting from the target write address
txDataSize	Number of elements found in txData array

Returns: true - command successful
false - command failed

Note: Use Sequencer Commands functions to help build txData array.

Definition at line 423 of file DS28E18.c.

Referenced by DS28E18_BuildPacket_WriteAndRun().

 {
     uint8_t parameters[2 + txDataSize];
     uint8_t response[1];
     uint8_t addressLow = nineBitStartingAddress & 0xFF;
     uint8_t addressHigh = (nineBitStartingAddress >> 8) & 0x01;
     parameters[0] = addressLow;
     parameters[1] = addressHigh;
     memcpy(&parameters[2], &txData[0], txDataSize);
 
     if (!run_command(WRITE_SEQUENCER, parameters, sizeof(parameters), SPU_Delay_tOP_msec, response))
     {
         return false;
     }
     return returnDeviceResponseResult(response[0]);
 }

Macros

Functions

Variables

Detailed Description

Function Documentation

◆ DS28E18_BuildPacket_I2C_ReadData()

◆ DS28E18_BuildPacket_I2C_ReadDataWithNackEnd()

◆ DS28E18_BuildPacket_I2C_Start()

◆ DS28E18_BuildPacket_I2C_Stop()

◆ DS28E18_BuildPacket_I2C_WriteData()

◆ DS28E18_BuildPacket_SPI_SlaveSelectHigh()

◆ DS28E18_BuildPacket_SPI_SlaveSelectLow()

◆ DS28E18_BuildPacket_SPI_WriteReadBit()

◆ DS28E18_BuildPacket_SPI_WriteReadByte()

◆ DS28E18_BuildPacket_Utility_Delay()

◆ DS28E18_BuildPacket_Utility_GpioBufferRead()

◆ DS28E18_BuildPacket_Utility_GpioBufferWrite()

◆ DS28E18_BuildPacket_Utility_GpioControlRead()

◆ DS28E18_BuildPacket_Utility_GpioControlWrite()

◆ DS28E18_BuildPacket_Utility_SensVddOff()

◆ DS28E18_BuildPacket_Utility_SensVddOn()

◆ DS28E18_BuildPacket_WriteAndRun()

◆ DS28E18_DeviceStatus()

◆ DS28E18_Init()

◆ DS28E18_ReadConfiguration()

◆ DS28E18_ReadGpioConfiguration()

◆ DS28E18_ReadSequencer()

◆ DS28E18_RerunLastSequence()

◆ DS28E18_RunSequencer()

◆ DS28E18_SetOnewireSpeed()

◆ DS28E18_SetRomCommand()

◆ DS28E18_WriteConfiguration()

◆ DS28E18_WriteGpioConfiguration()

◆ DS28E18_WriteSequencer()