1

/*

     2

This file is part of CanFestival, a library implementing CanOpen Stack. 

     3

     4

     5

Copyright (C): Jorge Berzosa

     6

     7

     8

See COPYING file for copyrights details.

     9

    10

    11

This library is free software; you can redistribute it and/or

    12

modify it under the terms of the GNU Lesser General Public

    13

License as published by the Free Software Foundation; either

    14

version 2.1 of the License, or (at your option) any later version.

    15

    16

    17

This library is distributed in the hope that it will be useful,

    18

but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    20

Lesser General Public License for more details.

    21

    22

    23

You should have received a copy of the GNU Lesser General Public

    24

License along with this library; if not, write to the Free Software

    25

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    26

*/

    27

    28

    29

/*!

    30

** @file   lss.c

    31

** @author Jorge Berzosa

    32

** @date   Mon Oct  22 05:44:32 2007

    33

**

    34

** @brief

    35

**

    36

**

    37

*/

    38

    39

    40

#include "data.h"

    41

#include "lss.h"

    42

#include "canfestival.h"

    43

#include "sysdep.h"

    44

    45

#ifdef CO_ENABLE_LSS

    46

    47

//#define LSS_TIMEOUT_MS	(TIMEVAL)1000  /* ms */

    48

//#define LSS_FS_TIMEOUT_MS	(TIMEVAL)100  /* ms */

    49

    50

/* Returns the LSS ident field from a Message struct */

    51

#define getLSSIdent(msg) (((UNS32)msg->data[4] << 24) | ((UNS32)msg->data[3] << 16) | (msg->data[2] << 8) | (msg->data[1]))

    52

    53

    54

/* Returns the LSS switch delay field from a Message struct */

    55

#define getLSSDelay(msg) ((msg->data[2] << 8) | (msg->data[1]))

    56

    57

/* Returns the LSS FastScan BitCheck field from a Message struct */

    58

#define getLSSBitCheck(msg) msg->data[5]

    59

    60

/* Returns the LSS FastScan LSSSub field from a Message struct */

    61

#define getLSSSub(msg) msg->data[6]

    62

    63

/* Returns the LSS FastScan LSSNext field from a Message struct */

    64

#define getLSSNext(msg) msg->data[7]

    65

    66

/* Prototypes for internals functions */

    67

UNS8 sendMasterLSSMessage(CO_Data* d, UNS8 command,void *dat1,void *dat2);

    68

void LssAlarmMSG(CO_Data* d, UNS32 id);

    69

void LssAlarmSDELAY(CO_Data* d, UNS32 id);

    70

    71

    72

#define StopLSS_MSG_TIMER(){\

    73

 MSG_WAR(0x3D01, "StopLSS_MSG_TIMER", 0);\

    74

 d->lss_transfer.timerMSG = DelAlarm(d->lss_transfer.timerMSG);}

    75

    76

#define StartLSS_MSG_TIMER(){\

    77

 MSG_WAR(0x3D02, "StartLSS_MSG_TIMER",0);\

    78

 d->lss_transfer.timerMSG = SetAlarm(d,0,&LssAlarmMSG,MS_TO_TIMEVAL(LSS_TIMEOUT_MS),0);}

    79

    80

#define StopLSS_SDELAY_TIMER(){\

    81

 MSG_WAR(0x3D03, "StopLSS_SDELAY_TIMER", 0);\

    82

 d->lss_transfer.timerSDELAY = DelAlarm(d->lss_transfer.timerSDELAY);}

    83

    84

#define StartLSS_SDELAY_TIMER(){\

    85

 MSG_WAR(0x3D04, "StartLSS_SDELAY_TIMER",0);\

    86

 d->lss_transfer.timerSDELAY= SetAlarm(d,0,&LssAlarmSDELAY,MS_TO_TIMEVAL(d->lss_transfer.switchDelay),MS_TO_TIMEVAL(d->lss_transfer.switchDelay));}

    87

    88

    89

#ifdef CO_ENABLE_LSS_FS

    90

/* Prototypes for internals functions */

    91

void LssAlarmFS(CO_Data* d, UNS32 id);

    92

    93

#define StopLSS_FS_TIMER(){\

    94

 MSG_WAR(0x3D05, "StopLSS_FS_TIMER", id);\

    95

 d->lss_transfer.timerFS = DelAlarm(d->lss_transfer.timerFS);}

    96

    97

#define StartLSS_FS_TIMER(){\

    98

 MSG_WAR(0x3D06, "StartLSS_FS_TIMER",0);\

    99

 d->lss_transfer.timerFS = SetAlarm(d,0,&LssAlarmFS,MS_TO_TIMEVAL(LSS_FS_TIMEOUT_MS),0);}

   100

#endif

   101

   102

   103

void LssAlarmMSG(CO_Data* d, UNS32 id)

   104

{	

   105

 	StopLSS_MSG_TIMER();

   106

#ifdef CO_ENABLE_LSS_FS

   107

	if(d->lss_transfer.command==LSS_IDENT_FASTSCAN){

   108

		if(d->lss_transfer.FastScan_SM==LSS_FS_RESET){

   109

   			/* if at least one node had answered before the timer expired, start the FastScan protocol*/

   110

   			if(d->lss_transfer.LSSanswer!=0){

   111

   				UNS32 Mask=0xFFFFFFFF;

   112

   				d->lss_transfer.LSSanswer=0;

   113

   				d->lss_transfer.BitChecked=d->lss_transfer.lss_fs_transfer.FS_BitChecked[0];

   114

   				Mask=(UNS32)((UNS64)Mask<<(d->lss_transfer.BitChecked+1));

   115

   				d->lss_transfer.IDNumber=d->lss_transfer.lss_fs_transfer.FS_LSS_ID[0] & Mask;

   116

   				d->lss_transfer.FastScan_SM=LSS_FS_PROCESSING;

   117

   				//printf("BitChecked=%d, IDNumber=%x MASK=%x\n",d->lss_transfer.BitChecked,d->lss_transfer.IDNumber,Mask);

   118

   				StartLSS_FS_TIMER();

   119

   				sendMasterLSSMessage(d,LSS_IDENT_FASTSCAN,0,0);

   120

   				return;

   121

   			}

   122

   			else{ 

   123

   124

    			d->lss_transfer.state = LSS_FINISHED;

   125

    			/* Inform the application that there aren't not configured nodes in the net  */

   126

    			d->lss_transfer.dat1=1;

   127

   			}

   128

   		}

   129

   		else{

   130

			/* This should not happen, an error ocurred*/

   131

			MSG_ERR(0x1D07, "LSS FastScan timeout. FastScan_SM inconsisten state.", d->lss_transfer.FastScan_SM);

   132

			d->lss_transfer.state = LSS_ABORTED_INTERNAL;

   133

			d->lss_transfer.FastScan_SM=LSS_FS_RESET;

   134

   		}

   135

	}

   136

	else

   137

#endif

   138

	if(d->lss_transfer.command==LSS_IDENT_REMOTE_NON_CONF){

   139

			MSG_WAR(0x2D08, "LSS timeout. There are not no-configured slaves in the net", 0);

   140

			d->lss_transfer.state = LSS_FINISHED;

   141

			d->lss_transfer.dat1=1;

   142

	}

   143

	else{

   144

		MSG_ERR(0x1D09, "LSS timeout. LSS response not received.", 0);

   145

    	MSG_WAR(0x2D0A, "LSS timeout command specifier : ", d->lss_transfer.command);

   146

    	/* Set aborted state */

   147

    	d->lss_transfer.state = LSS_ABORTED_INTERNAL;

   148

#ifdef CO_ENABLE_LSS_FS

   149

    	d->lss_transfer.FastScan_SM = LSS_FS_RESET;

   150

#endif

   151

    }

   152

   153

    /* Call the user function to inform of the problem.*/

   154

    if(d->lss_transfer.Callback){

   155

	   	/*If there is a callback, it is responsible of the error*/

   156

    	(*d->lss_transfer.Callback)(d,d->lss_transfer.command);

   157

    }

   158

}

   159

   160

   161

/*!                                                                                                

   162

**                                                                                                 

   163

**                                                                                                 

   164

** @param d                                                                                        

   165

** @param id                                                                                       

   166

**/   

   167

void LssAlarmSDELAY(CO_Data* d, UNS32 id)

   168

{	

   169

   170

	/* The first switch_delay period expired. Store the node state, change it 

   171

 	 * so no CAN messages will be sent or received, call the ChangeBaudRate function*/

   172

   	if(d->lss_transfer.switchDelayState==SDELAY_FIRST){

   173

   		MSG_WAR(0x3D0B, "LSS switch delay first period expired",0);

   174

    	d->lss_transfer.switchDelayState=SDELAY_SECOND;

   175

    	//(*d->lss_ChangeBaudRate)(d,d->lss_transfer.baudRate);

   176

    	canChangeBaudRate(d->lss_transfer.canHandle_t, d->lss_transfer.baudRate);

   177

    }

   178

    else{ /* d->lss_transfer.switchDelayState==SDELAY_SECOND */

   179

    	MSG_WAR(0x3D0C, "LSS switch delay second period expired",0);

   180

    	d->lss_transfer.switchDelayState=SDELAY_OFF;

   181

    	StopLSS_SDELAY_TIMER();

   182

   183

    	if (*(d->iam_a_slave))

   184

    		d->canHandle=d->lss_transfer.canHandle_t;

   185

    	else{

   186

    		d->lss_transfer.dat1=0;

   187

    		d->lss_transfer.state=LSS_FINISHED;

   188

    		/* Call the user function */

   189

    		if(d->lss_transfer.Callback){

   190

	    		(*d->lss_transfer.Callback)(d,d->lss_transfer.command);

   191

    		}

   192

    	}

   193

    }

   194

} 

   195

   196

#ifdef CO_ENABLE_LSS_FS

   197

/*!                                                                                                

   198

**                                                                                                 

   199

**                                                                                                 

   200

** @param d                                                                                        

   201

** @param id                                                                                       

   202

**/   

   203

void LssAlarmFS(CO_Data* d, UNS32 id)

   204

{	

   205

	StopLSS_FS_TIMER();

   206

   207

	switch(d->lss_transfer.FastScan_SM){

   208

   	case LSS_FS_RESET:

   209

   	{

   210

   	   	/* This should not happen, an error ocurred*/

   211

		MSG_ERR(0x1D0D, "LSS FastScan timeout. FastScan_SM inconsisten state.", d->lss_transfer.FastScan_SM);

   212

   	}

   213

   	break;

   214

	case LSS_FS_PROCESSING:

   215

	{

   216

		/* If there isn't any answer, set the bit */

   217

		if(d->lss_transfer.LSSanswer==0){

   218

			UNS32 Mask=0x1;

   219

			Mask<<=d->lss_transfer.BitChecked;

   220

			d->lss_transfer.IDNumber|=Mask;

   221

		}

   222

   223

		if(d->lss_transfer.BitChecked==0){

   224

			/* We finished with the current LSS-ID[sub], confirm it */

   225

			d->lss_transfer.FastScan_SM=LSS_FS_CONFIRMATION;

   226

			if(d->lss_transfer.LSSNext<3)d->lss_transfer.LSSNext++;

   227

		}

   228

		else{

   229

			d->lss_transfer.BitChecked--;

   230

		}

   231

		//printf("BitChecked=%d, IDNumber=%x\n",d->lss_transfer.BitChecked,d->lss_transfer.IDNumber);

   232

   		d->lss_transfer.LSSanswer=0;

   233

  		StartLSS_FS_TIMER();

   234

   		sendMasterLSSMessage(d,LSS_IDENT_FASTSCAN,0,0);

   235

   		return;

   236

   	}

   237

	break;

   238

	case LSS_FS_CONFIRMATION:

   239

	{

   240

		if(d->lss_transfer.LSSanswer!=0){

   241

			d->lss_transfer.LSSanswer=0;

   242

   243

			if(d->lss_transfer.LSSSub==3){

   244

				/* The LSS FastScan protocol finished correctly. Restore the parameters */

   245

				d->lss_transfer.BitChecked=128;

   246

				d->lss_transfer.FastScan_SM=LSS_FS_RESET;

   247

				d->lss_transfer.LSSSub=0;

   248

				d->lss_transfer.LSSNext=0;

   249

   				d->lss_transfer.IDNumber=0;

   250

   251

				/* Inform the application that the FastScan finished correctly */

   252

				d->lss_transfer.state = LSS_FINISHED;

   253

				d->lss_transfer.dat1=0;

   254

			}

   255

			else{

   256

				UNS32 Mask=0xFFFFFFFF;

   257

				/* Start with the next LSS-ID[sub] */

   258

				d->lss_transfer.LSSSub++;

   259

				d->lss_transfer.BitChecked=d->lss_transfer.lss_fs_transfer.FS_BitChecked[d->lss_transfer.LSSSub];

   260

				Mask=(UNS32)((UNS64)Mask<<(d->lss_transfer.BitChecked+1));

   261

   				d->lss_transfer.IDNumber=d->lss_transfer.lss_fs_transfer.FS_LSS_ID[d->lss_transfer.LSSSub] & Mask;

   262

   				d->lss_transfer.FastScan_SM=LSS_FS_PROCESSING;

   263

   				//printf("BitChecked=%d, IDNumber=%x MASK=%x\n",d->lss_transfer.BitChecked,d->lss_transfer.IDNumber,Mask);

   264

   				StartLSS_FS_TIMER();

   265

   				sendMasterLSSMessage(d,LSS_IDENT_FASTSCAN,0,0);

   266

   				return;

   267

			}

   268

		}

   269

		else{

   270

			/* This should not happen, an error ocurred*/

   271

			MSG_ERR(0x1D0E, "LSS FastScan timeout. FastScan response not received.", 0);

   272

			MSG_ERR(0x1D0E, "There is not any node with LSS_ID# =>", d->lss_transfer.LSSSub);

   273

			MSG_ERR(0x1D0E, "with the value =>", d->lss_transfer.IDNumber);

   274

			/* Set aborted state */

   275

    		d->lss_transfer.state = LSS_ABORTED_INTERNAL;

   276

    		d->lss_transfer.FastScan_SM = LSS_FS_RESET;

   277

		}

   278

	}

   279

	break;

   280

	}

   281

   282

   	/* Call the user function to inform of the problem.*/

   283

   	if(d->lss_transfer.Callback){

   284

    	/*If there is a callback, it is responsible of the error*/

   285

   		(*d->lss_transfer.Callback)(d,d->lss_transfer.command);

   286

   	}

   287

}

   288

#endif

   289

   290

   291

/*!                                                                                                

   292

**                                                                                                 

   293

**                                                                                                 

   294

** @param d                                                                                        

   295

**/ 

   296

void startLSS(CO_Data* d)

   297

{

   298

	/*MSG_WAR(0x3D09, "LSS services started",0);*/

   299

}

   300

   301

/*!                                                                                                

   302

**                                                                                                 

   303

**                                                                                                 

   304

** @param d                                                                                        

   305

**/   

   306

void stopLSS(CO_Data* d)

   307

{

   308

	/*MSG_WAR(0x3D09, "LSS services stopped",0);*/

   309

}

   310

   311

/*!                                                                                                

   312

**                                                                                                 

   313

**                                                                                                 

   314

** @param d                                                                                        

   315

** @param cob_id                                                                                   

   316

**                                                                                                 

   317

** @return                                                                                         

   318

**/  

   319

UNS8 sendSlaveLSSMessage(CO_Data* d, UNS8 command,void *dat1,void *dat2)

   320

{

   321

  Message m;

   322

  UNS8 i;

   323

   324

  if (!d->CurrentCommunicationState.csLSS){

   325

  	MSG_WAR(0x2D17, "unable to send the LSS message, not in the proper state =>", d->nodeState);

   326

  	return 0xFF;

   327

  }

   328

   329

  for(i=1;i<8;i++)m.data[i]=0;

   330

  m.len = 8;

   331

  m.rtr = NOT_A_REQUEST;

   332

  m.data[0]=command;

   333

  m.cob_id=UNS16_LE(SLSS_ADRESS);

   334

   335

  /* Tha data sent with the msg depends on the command */

   336

  switch(command){

   337

  case LSS_INQ_NODE_ID: /* Inquire Node-ID */

   338

  	m.data[1]=*(UNS8 *)dat1;

   339

  	break;

   340

  case LSS_CONF_NODE_ID: /* Configure Node-ID */

   341

  case LSS_CONF_BIT_TIMING: /* Configure Bit Timing Parameters */

   342

  case LSS_CONF_STORE: /* Store Configured Parameters */

   343

  	m.data[1]=*(UNS8 *)dat1;

   344

  	m.data[2]=*(UNS8 *)dat2;

   345

  	break; 

   346

  case LSS_INQ_VENDOR_ID: /* Inquire Identity Vendor-ID */

   347

  case LSS_INQ_PRODUCT_CODE: /* Inquire Identity Product-Code */

   348

  case LSS_INQ_REV_NUMBER: /* Inquire Identity Revision-Number */

   349

  case LSS_INQ_SERIAL_NUMBER: /* Inquire Identity Serial-Number */

   350

	m.data[1]=(UNS8)(*(UNS32*)dat1 & 0xFF);

   351

	m.data[2]=(UNS8)(*(UNS32*)dat1>>8 & 0xFF);

   352

	m.data[3]=(UNS8)(*(UNS32*)dat1>>16 & 0xFF);

   353

	m.data[4]=(UNS8)(*(UNS32*)dat1>>24 & 0xFF);

   354

	break;

   355

  case LSS_SM_SELECTIVE_RESP: /* Switch Mode Selective response*/

   356

  case LSS_IDENT_SLAVE: /* LSS Identify Slave */

   357

  case LSS_IDENT_NON_CONF_SLAVE: /* LSS identify non-configured remote slave */

   358

  	break;

   359

  default:

   360

  	MSG_ERR(0x1D18, "send Slave LSS command not implemented", command);

   361

  	return 0xFF;

   362

  }

   363

   364

  return canSend(d->canHandle,&m);

   365

}

   366

   367

/* If a baud rate is not supported just comment the line. */

   368

static UNS8 CO_TranslateBaudRate(char* optarg){

   369

	if(!strcmp( optarg, "1M")) return 0x00;

   370

	if(!strcmp( optarg, "800K")) return 0x01;

   371

	if(!strcmp( optarg, "500K")) return 0x02;

   372

	if(!strcmp( optarg, "250K")) return 0x03;

   373

	if(!strcmp( optarg, "125K")) return 0x04;

   374

	if(!strcmp( optarg, "100K")) return 0x05;

   375

	if(!strcmp( optarg, "50K")) return 0x06;

   376

	if(!strcmp( optarg, "20K")) return 0x07;

   377

	if(!strcmp( optarg, "10K")) return 0x08;

   378

	return 0xFF;

   379

}

   380

   381

/*!                                                                                                

   382

**                                                                                                 

   383

**                                                                                                 

   384

** @param d                                                                                        

   385

** @param cob_id                                                                                   

   386

**                                                                                                 

   387

** @return                                                                                         

   388

**/  

   389

UNS8 sendMasterLSSMessage(CO_Data* d, UNS8 command,void *dat1,void *dat2)

   390

{

   391

  Message m;

   392

  UNS8 i;

   393

  UNS8 res;

   394

  UNS8 hasResponse=0;

   395

   396

  for(i=1;i<8;i++)m.data[i]=0;

   397

  m.len = 8;

   398

  m.rtr = NOT_A_REQUEST;

   399

  m.data[0]=command;

   400

  m.cob_id=UNS16_LE(MLSS_ADRESS);

   401

   402

  /* Tha data sent with the msg depends on the command */	

   403

  switch(command){

   404

  case LSS_CONF_NODE_ID: /* Configure Node-ID */

   405

  	hasResponse=1;

   406

  case LSS_SM_GLOBAL: /* Switch Mode Global */

   407

  	m.data[1]=*(UNS8 *)dat1;

   408

  	break;

   409

  case LSS_CONF_BIT_TIMING: /* Configure Bit Timing Parameters */

   410

   411

  	m.data[1]=*(UNS8 *)dat1;

   412

  	d->lss_transfer.baudRate=*(char **)dat2;

   413

   414

  	if((m.data[2]=CO_TranslateBaudRate(d->lss_transfer.baudRate))!=0xFF){

   415

  		hasResponse=1;

   416

		break;	 

   417

  	}

   418

   419

	MSG_ERR(0x1D19, "Master-> Baud rate not supported",0);

   420

	d->lss_transfer.dat1=0xFF;

   421

   422

	/* if bit timing is not supported comment the previous code and uncomment the following one*/

   423

	/*{

   424

		MSG_ERR(0x1D1A, "Master-> Bit timing not supported",0);

   425

		d->lss_transfer.dat1=0x01;

   426

	}*/

   427

   428

	d->lss_transfer.dat2=0;

   429

 	/* If there is a callback, it is responsible of the error */

   430

	if(d->lss_transfer.Callback)

   431

	   	(*d->lss_transfer.Callback)(d,d->lss_transfer.command);

   432

	return 0xFF;

   433

  	//break;

   434

  case LSS_CONF_ACT_BIT_TIMING: /* Activate Bit Timing Parameters */

   435

	m.data[1]=(UNS8)(*(UNS32*)dat1 & 0xFF);

   436

	m.data[2]=(UNS8)(*(UNS32*)dat1>>8 & 0xFF);

   437

	if(d->lss_transfer.baudRate!="none"){

   438

		d->lss_transfer.switchDelay=(UNS16)(*(UNS32*)dat1 & 0xFFFF);

   439

		d->lss_transfer.switchDelayState=SDELAY_FIRST;

   440

		d->lss_transfer.canHandle_t=d->canHandle;

   441

		res=canSend(d->canHandle,&m);

   442

  		if(res==0){

   443

  			StartLSS_SDELAY_TIMER();

   444

  			d->lss_transfer.state=LSS_TRANS_IN_PROGRESS;

   445

  		}

   446

  		return res;	

   447

	}

   448

	else{

   449

		MSG_ERR(0x1D1B, "Master-> Baud rate not specified",0);

   450

		d->lss_transfer.dat1=1;

   451

    	/* If there is a callback, it is responsible of the error */

   452

    	if(d->lss_transfer.Callback){

   453

	    	(*d->lss_transfer.Callback)(d,d->lss_transfer.command);

   454

    	}

   455

		return 0xFF;

   456

	}

   457

  	//break;

   458

  case LSS_SM_SELECTIVE_SERIAL:

   459

  case LSS_IDENT_REMOTE_SERIAL_HIGH:

   460

  	hasResponse=1;

   461

  case LSS_SM_SELECTIVE_VENDOR: /* Switch Mode Selective */

   462

  case LSS_SM_SELECTIVE_PRODUCT:

   463

  case LSS_SM_SELECTIVE_REVISION:

   464

  case LSS_IDENT_REMOTE_VENDOR: /* LSS Identify Remote Slaves */

   465

  case LSS_IDENT_REMOTE_PRODUCT:

   466

  case LSS_IDENT_REMOTE_REV_LOW:

   467

  case LSS_IDENT_REMOTE_REV_HIGH:

   468

  case LSS_IDENT_REMOTE_SERIAL_LOW:

   469

	m.data[1]=(UNS8)(*(UNS32*)dat1 & 0xFF);

   470

	m.data[2]=(UNS8)(*(UNS32*)dat1>>8 & 0xFF);

   471

	m.data[3]=(UNS8)(*(UNS32*)dat1>>16 & 0xFF);

   472

	m.data[4]=(UNS8)(*(UNS32*)dat1>>24 & 0xFF);

   473

	break;

   474

   475

  case LSS_CONF_STORE: /* Store Configured Parameters */

   476

  case LSS_IDENT_REMOTE_NON_CONF: /* LSS identify non-configured remote slave */

   477

  case LSS_INQ_VENDOR_ID: /* Inquire Identity Vendor-ID */

   478

  case LSS_INQ_PRODUCT_CODE: /* Inquire Identity Product-Code */

   479

  case LSS_INQ_REV_NUMBER: /* Inquire Identity Revision-Number */

   480

  case LSS_INQ_SERIAL_NUMBER: /* Inquire Identity Serial-Number */

   481

  case LSS_INQ_NODE_ID: /* Inquire Node-ID */

   482

	 hasResponse=1;

   483

  	break;

   484

#ifdef CO_ENABLE_LSS_FS

   485

  case LSS_IDENT_FASTSCAN:

   486

	  	if(d->lss_transfer.FastScan_SM==LSS_FS_RESET){

   487

	  		UNS8 i;

   488

	  		 /* Initialize the lss_fs_transfer FastScan parameters */

   489

	  		for(i=0;i<4;i++){

   490

	  			d->lss_transfer.lss_fs_transfer.FS_LSS_ID[i]=(*(lss_fs_transfer_t*)dat1).FS_LSS_ID[i];

   491

	  			d->lss_transfer.lss_fs_transfer.FS_BitChecked[i]=(*(lss_fs_transfer_t*)dat1).FS_BitChecked[i];

   492

	  			/* Adjust BitChecked from 32-1 to 31-0 */

   493

	  			if(d->lss_transfer.lss_fs_transfer.FS_BitChecked[i]>0)d->lss_transfer.lss_fs_transfer.FS_BitChecked[i]--;

   494

	  		}

   495

   496

	  		d->lss_transfer.IDNumber=0;

   497

	  		d->lss_transfer.BitChecked=128;

   498

	  		d->lss_transfer.LSSSub=0;

   499

	  		d->lss_transfer.LSSNext=0;

   500

   501

	  		/* it will generate a response only if it is the start of the FastScan protocol*/

   502

	  		hasResponse=1;