//----------------------------------------------------------------------
// Perform a overdrive MATCH command to select the 1-Wire device with
// the address in the ID data register.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number is provided to
// indicate the symbolic port number.
//
// Returns: TRUE: If the device is present on the 1-Wire Net and
// can do overdrive then the device is selected.
// FALSE: Device is not present or not capable of overdrive.
//
// *Note: This function could be converted to send DS2480
// commands in one packet.
//
BYTE owOverdriveAccess(BYTE portnum)
{
BYTE sendpacket[8];
BYTE i, bad_echo = FALSE;
owSetCurrentPort(portnum);
// make sure normal level
owLevel(owCurrentPortnum, MODE_NORMAL);
// force to normal communication speed
owSpeed(owCurrentPortnum, MODE_NORMAL);
// call the 1-Wire Net reset function
if(owTouchReset(owCurrentPortnum)) {
// send the match command 0x69
if(owWriteByte(owCurrentPortnum, 0x69)) {
// switch to overdrive communication speed
owSpeed(owCurrentPortnum, MODE_OVERDRIVE);
// create a buffer to use with block function
// Serial Number
for(i = 0; i < 8; i++) {
sendpacket[i] = owNetCurrent.SerialNum[i];
}
// send/recieve the transfer buffer
if(owBlock(owCurrentPortnum, FALSE, sendpacket,8)) {
// verify that the echo of the writes was correct
for(i = 0; i < 8; i++) {
if(sendpacket[i] != owNetCurrent.SerialNum[i]) {
bad_echo = TRUE;
}
}
// if echo ok then success
if(!bad_echo) {
return TRUE;
} else {
OWERROR(OWERROR_WRITE_VERIFY_FAILED);
}
} else {
OWERROR(OWERROR_BLOCK_FAILED);
}
} else {
OWERROR(OWERROR_WRITE_BYTE_FAILED);
}
} else {
OWERROR(OWERROR_NO_DEVICES_ON_NET);
}
// failure, force back to normal communication speed
owSpeed(owCurrentPortnum, MODE_NORMAL);
return FALSE;
}
//-------------------------------------------------------------------------
// Select the current device and attempt overdrive if possible. Usable
// for both DS1963S and DS1961S.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number is provided to
// indicate the symbolic port number.
//
// Return: TRUE - device selected
// FALSE - device not select
//
SMALLINT SelectSHA(int portnum)
{
int rt,cnt=0;
#ifdef __MC68K__
// Used in when overdrive isn't...Used owVerify for overdrive
rt = owAccess(portnum);
#else
//\\//\\//\\//\\//\\//\\//\\//\\//\\//
#ifdef DEBUG_DUMP
uchar ROM[8];
int i, mcnt;
char msg[255];
owSerialNum(portnum,ROM, TRUE);
mcnt = sprintf(msg,"\n Device select ");
for (i = 0; i < 8; i++)
mcnt += sprintf(msg + mcnt, "%02X",ROM[i]);
mcnt += sprintf(msg + mcnt,"\n");
printf("%s",msg);
#endif
//\\//\\//\\//\\//\\//\\//\\//\\//\\//
// loop to access the device and optionally do overdrive
do
{
rt = owVerify(portnum,FALSE);
// check not present
if (rt != 1)
{
// if in overdrive, drop back
if (in_overdrive[portnum&0x0FF])
{
// set to normal speed
if(MODE_NORMAL == owSpeed(portnum,MODE_NORMAL))
in_overdrive[portnum&0x0FF] = FALSE;
}
}
// present but not in overdrive
else if (!in_overdrive[portnum&0x0FF])
{
// put all devices in overdrive
if (owTouchReset(portnum))
{
if (owWriteByte(portnum,0x3C))
{
// set to overdrive speed
if(MODE_OVERDRIVE == owSpeed(portnum,MODE_OVERDRIVE))
in_overdrive[portnum&0x0FF] = TRUE;
}
}
rt = 0;
}
else
break;
}
while ((rt != 1) && (cnt++ < 3));
#endif
return rt;
}
//---------------------------------------------------------------------
// Finds new SHA iButtons on the given port. Uses 'triple-buffer'
// technique to insure it only finds 'new' buttons.
//
// 'portnum' - number 0 to MAX_PORTNUM-1. This number is provided to
// indicate the symbolic port number.
// 'devAN' - pointer to buffer for device address
// 'resetList' - if TRUE, final buffer is cleared.
//
// Returns: TRUE, found a new SHA iButton.
// FALSE, no new buttons are present.
//
SMALLINT FindNewSHA(int portnum, uchar* devAN, SMALLINT resetList)
{
uchar ROM[8];
uchar tempList[MAX_SHA_IBUTTONS] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
int tempIndex = 0, i;
SMALLINT hasDevices = TRUE, completeList = FALSE;
// force back to standard speed
if(MODE_NORMAL != owSpeed(portnum,MODE_NORMAL))
{
OWERROR(OWERROR_LEVEL_FAILED);
return FALSE;
}
in_overdrive[portnum&0x0FF] = FALSE;
// get first device in list with the specified family
if(needsFirst || resetList)
{
hasDevices = owFirst(portnum, TRUE, FALSE);
completeList = TRUE;
if(resetList)
listIndex = 0;
}
else
{
hasDevices = owNext(portnum, TRUE, FALSE);
}
if(hasDevices)
{
do
{
// verify correct device type
owSerialNum(portnum, ROM, TRUE);
tempList[tempIndex++] = ROM[7];
// compare crc to complete list of ROMs
for(i=0; i<listIndex; i++)
{
if(ROM[7] == ListOfKnownSHA[portnum&0x0FF][i])
break;
}
// found no match;
if(i==listIndex)
{
// check if correct type and not copr_rom
if ((SHA_FAMILY_CODE == (ROM[0] & 0x7F)) ||
(SHA33_FAMILY_CODE == (ROM[0] & 0x7F)))
{
// save the ROM to the return buffer
owSerialNum(portnum,devAN,TRUE);
ListOfKnownSHA[portnum&0x0FF][listIndex++] = devAN[7];
return TRUE;
}
}
}
while(owNext(portnum, TRUE, FALSE));
}
// depleted the list, start over from beginning next time
needsFirst = TRUE;
if(completeList)
{
// known list is triple-buffered, listBuffer is intermediate
// buffer. tempList is the immediate buffer, while
// ListOfKnownSHA is the final buffer.
if( (memcmp(tempList, listBuffer[portnum&0x0FF], MAX_SHA_IBUTTONS)==0) &&
tempIndex == indexBuffer )
{
memcpy(ListOfKnownSHA[portnum&0x0FF], tempList, MAX_SHA_IBUTTONS);
listIndex = tempIndex;
}
else
{
memcpy(listBuffer[portnum&0x0FF], tempList, MAX_SHA_IBUTTONS);
indexBuffer = tempIndex;
}
}
return FALSE;
}
//----------------------------------------------------------------------
// Main Test
//
int main() //short argc, char **argv)
{
int PortNum=1,rslt,i,j,testcnt=0,length;
uchar TempSerialNum[8];
uchar tran_buffer[2000], filename[10];
char return_msg[128];
int portnum=0;
// check for required port name
if (argc != 2)
{
printf("1-Wire Net name required on command line!\n"
" (example: \"COM1\" (Win32 DS2480),\"/dev/cua0\" "
"(Linux DS2480),\"1\" (Win32 TMEX)\n");
exit(1);
}
// attempt to acquire the 1-Wire Net
if (!owAcquire(portnum, argv[1], return_msg))
{
printf("%s",return_msg);
exit(1);
}
// success
printf("%s",return_msg);
//----------------------------------------
// Introduction
printf("\n/---------------------------------------------\n");
printf(" The following is a test excersize of the\n"
" 1-Wire Net public domain library Version 2.00.\n\n"
" This test was run using with 2 DS1920's (DS1820),\n"
" 1 DS1971 (DS2430), and 1 DS1996.\n\n");
//----------------------------------------
// First the devices on the 1-Wire Net
printf("\n/---------------------------------------------\n");
printf("TEST%d: Searching for devices on 1-Wire Net\n",testcnt++);
// find the first device (all devices not just alarming)
rslt = owFirst(portnum,TRUE, FALSE);
while (rslt)
{
// print the Serial Number of the device just found
PrintSerialNum(portnum);
// find the next device
rslt = owNext(portnum,TRUE, FALSE);
}
//----------------------------------------
// now search for the part with a 0x0C family code (DS1996)
printf("\n/---------------------------------------------\n");
printf("TEST%d: Set to find first device with 0x0C family code\n",testcnt++);
owFamilySearchSetup(portnum,0x0C);
// find the first 0x0c device
TempSerialNum[0]=0;
while (TempSerialNum[0]!=0x0c && owNext(portnum,TRUE,FALSE)) {
owSerialNum(portnum,TempSerialNum,TRUE);
}
printf("search result %d\n",TempSerialNum[0]==0x0c);
// print the Serial Number of the device just found
PrintSerialNum(portnum);
//----------------------------------------
// Access a device and read ram
printf("\n/---------------------------------------------\n");
printf("TEST%d: Access the current device and read ram\n",testcnt++);
printf("owAccess %d\n",owAccess(portnum));
printf("Read Ram 0xF0: %02X\n",owTouchByte(portnum,0xF0));
printf("Address0 0x00: %02X\n",owTouchByte(portnum,0x00));
printf("Address1 0x00: %02X\n",owTouchByte(portnum,0x00));
printf("Page 0: ");
for (i = 0; i < 32; i++)
printf("%02X ",owTouchByte(portnum,0xFF));
printf("\n");
//----------------------------------------
// Read ram with owBlock
printf("\n/---------------------------------------------\n");
printf("TEST%d: Read ram with owBlock\n",testcnt++);
for (i = 0; i < 32; i++)
tran_buffer[i] = 0xFF;
printf("owBlock %d\n",owBlock(portnum,FALSE,tran_buffer,32));
printf("Page 1: ");
for (i = 0; i < 32; i++)
printf("%02X ",tran_buffer[i]);
printf("\n");
//----------------------------------------
// Write a packet in each page of DS1996
printf("\n/---------------------------------------------\n");
printf("TEST%d: Place the DS1996 into overdrive\n",testcnt++);
printf("owOverdriveAccess %d\n",owOverdriveAccess(portnum));
//----------------------------------------
// Write 4 packets with owWritePacketStd
printf("\n/---------------------------------------------\n");
printf("TEST%d: Write 4 packets with owWritePacketStd\n",testcnt++);
for (j = 0; j < 4; j++)
{
for (i = 0; i < 29; i++)
tran_buffer[i] = (uchar)i + j;
printf("Write page %d: %d\n",j,owWritePacketStd(portnum,j,tran_buffer,29,FALSE,FALSE));
for (i = 0; i < 29; i++)
tran_buffer[i] = 0;
length = owReadPacketStd(portnum,TRUE,j,tran_buffer);
printf("Read page %d: %d\n",j,length);
for (i = 0; i < length; i++)
printf("%02X",tran_buffer[i]);
printf("\n");
}
//----------------------------------------
// Write a file to DS1996
printf("\n/---------------------------------------------\n");
printf("TEST%d: Format and write a file (in overdrive)\n",testcnt++);
sprintf(filename,"DEMO");
// set the data to write
for (i = 0; i < 2000; i++)
tran_buffer[i] = i % 255;
printf("Format and write file DEMO.000 %d\n",
owFormatWriteFile(portnum,filename,2000,tran_buffer));
// clear the buffer
for (i = 0; i < 2000; i++)
tran_buffer[i] = 0x55;
printf("Read file DEMO.000 %d\n",owReadFile(portnum,filename,tran_buffer));
// print the data result
for (i = 0; i < 2000; i++)
{
if ((i % 0x20) == 0)
printf("\n%03X ",i);
printf("%02X",tran_buffer[i]);
}
printf("\n");
//----------------------------------------
// Turn off overdrive
printf("\n/---------------------------------------------\n");
printf("TEST%d: Turn off overdrive\n",testcnt++);
printf("Set 1-Wire Net speed to normal %d\n",owSpeed(portnum,MODE_NORMAL));
//----------------------------------------
// Verify a device
printf("\n/---------------------------------------------\n");
printf("TEST%d: Verify the current device\n",testcnt++);
printf("owVerify (normal) %d\n",owVerify(portnum,FALSE));
printf("owVerify (alarm) %d\n",owVerify(portnum,TRUE));
//----------------------------------------
// Skip the first family code found
printf("\n/---------------------------------------------\n");
printf("TEST%d: Skip the first family code found\n",testcnt++);
// find the next device
printf("search result of owFirst %d\n",owFirst(portnum,TRUE, FALSE));
// print the Serial Number of the device just found
PrintSerialNum(portnum);
// skip the first family type found
owSkipFamily(portnum);
printf("owSkipFamily called\n");
// find the next device
printf("search result of owNext %d\n",owNext(portnum,TRUE, FALSE));
// print the Serial Number of the device just found
PrintSerialNum(portnum);
//----------------------------------------
// Find first family code (DS1920) and read temperature
printf("\n/---------------------------------------------\n");
printf("TEST%d: Find first family code (DS1920) and read temperature\n",testcnt++);
// find the next device
printf("search result of owFirst %d\n",owFirst(portnum,TRUE, FALSE));
// print the Serial Number of the device just found
PrintSerialNum(portnum);
// send the convert temperature command
printf("Convert temperature command %02X\n",owTouchByte(portnum,0x44));
// set the 1-Wire Net to strong pull-up
printf("Set power delivery %d\n",owLevel(portnum,MODE_STRONG5));
// sleep for 1 second
msDelay(1000);
// turn off the 1-Wire Net strong pull-up
printf("Disable power delivery %d\n",owLevel(portnum,MODE_NORMAL));
// read the DS1920 temperature value
printf("Access the DS1920 %d\n",owAccess(portnum));
tran_buffer[0] = 0xBE;
tran_buffer[1] = 0xFF;
tran_buffer[2] = 0xFF;
printf("Block to read temperature %d\n",owBlock(portnum,FALSE,tran_buffer,3));
// interpret the result
printf("result: DS1920 temperature read: %d C\n", (tran_buffer[1] |
((int)tran_buffer[2] << 8)) / 2);
//----------------------------------------
// Verify the current device, could also be alarming
printf("\n/---------------------------------------------\n");
printf("TEST%d: Verify the current device, could also be alarming\n",testcnt++);
printf("owVerify (normal) %d\n",owVerify(portnum,FALSE));
printf("owVerify (alarm) %d\n",owVerify(portnum,TRUE));
//----------------------------------------
// Test setting the Serial Number with owSerialNum
printf("\n/---------------------------------------------\n");
printf("TEST%d: Test setting the Serial Number with owSerialNum\n",testcnt++);
// set the Serial Num to 0 to 7
for (i = 0; i < 8; i++)
TempSerialNum[i] = (uchar)i;
owSerialNum(portnum,TempSerialNum,FALSE);
// read back the Serial Number
PrintSerialNum(portnum);
//----------------------------------------
// Verify the current device (should fail, no such device)
printf("\n/---------------------------------------------\n");
printf("TEST%d: Verify the current device (should fail, no such device)\n",testcnt++);
printf("owVerify (normal) %d\n",owVerify(portnum,FALSE));
printf("owVerify (alarm) %d\n",owVerify(portnum,TRUE));
// release the 1-Wire Net
owRelease(portnum,return_msg);
printf("%s",return_msg);
exit(0);
return 0;
}
