x10 tester - · pdf filex10_tester.can page 3 of 128. 151 byte hastosendwritecolumnconfig = 0;...

1variables

2{

3//Vers. 9.4

4message DTOOL_to_USM msgTesterToEcu;

5message USM_to_DTOOL msgEcuToTester;

678

//////////////////////////////////////////////////////////////////////////////////

9//////////////////////////////////////////////////////////////////////

////////////

10const long VARS_SIZE = 300; // Maximum number of variables

11const long MAX_VAR_LENGTH = 100; // Maximum length of a

variable name

12const long MAX_VAR_SIZE = 100; // Maximum number of

varibles read with an identifier

13const BYTE SEP = ';'; // Separator used in

config files (0x3B)

14151617

// EMC32

18const long NCycles= 500;

19const long NCyclesCalib=50;

20const long NSTEPS =8;

21long arrayError[VARS_SIZE][2]; //Capture flag up or down.

22long eflag[VARS_SIZE];

23long errorCounter=0;

24long startaux=0;

25long indexDelay=0;

26long indexStop=0;

27long CANSTATEflag[2];

28long NewStep[VARS_SIZE];

29long senueloA=0;

30long senueloB=0;

31long senueloC=0;

32int controlSimulador=0;

33WORD DID_LIST_ID[VARS_SIZE][100]; // List of ID readed with the

identifier

343536

//mstimer tEMC32;

37message m mEMC;

38mstimer DelayCalibration;

39mstimer DelayCycling;

40mstimer DelayStop;

41mstimer tflagA, tflagB, tflagC;

42mstimer FailureCAN;

4344

struct ErrorImmClass

45{

46double maxVal;

47double minVal;

48double Value;

49double Frequenz;

50double ImmunityField;

51double Threshold;

X10_Tester.can

of 128

52long State;

53long Ciclat;

54long Varid;

55int Error;

56char Names[MAX_VAR_LENGTH];

575859

};

60struct ErrorImmClass ErrorImm[NCycles][NSTEPS][VARS_SIZE];

61struct ErrorImmClass ErrorCalib[NCyclesCalib][NSTEPS][VARS_SIZE];

6263

// Read from configuration file

64WORD VARID[VARS_SIZE]; // Identifier of each variable (

relation out/diag)

65WORD TYPES[VARS_SIZE]; // 0: DI, 1: AI, 2: DO, 3: PO, 4: AD,

5: DD, 6: ROUT

66WORD INVERT[VARS_SIZE]; // 1: Variable is inverted (only for

1 bit variables)

67char NAMES[VARS_SIZE][MAX_VAR_LENGTH]; // Name of the variable

68WORD DID[VARS_SIZE]; // DID for read/write the variable

69WORD NBYTES[VARS_SIZE]; // Number of bytes of data in CAN MSG

70WORD OFFSET[VARS_SIZE]; // Offset in CAN MSG

71WORD NBITS[VARS_SIZE]; // Number of bits of the variable in

CAN MSG

72BYTE VARIANT_L0[VARS_SIZE]; // 0: Yes, 1: No, 2: Mounted

7374

// Internally used

75long VALUES[VARS_SIZE]; // Value of the variable

76WORD tmp[VARS_SIZE]; // Used to detect changes

in output variables

77WORD CHANGE[VARS_SIZE]; // Programmed change of an output, 1:

active

78long NVARS = 0; // Number of variables

7980

// Generated from the configuration

81WORD DID_LIST[VARS_SIZE]; // List of different DIDs

82BYTE DID_LIST_NUM_INPUTS[VARS_SIZE]; // Number of input vars for

this DID

83BYTE DID_LIST_NUM_OUTPUTS[VARS_SIZE]; // Number of output vars for

this DID

84BYTE DID_LIST_NUM_DIAGS[VARS_SIZE]; // Number of diag vars for this

DID

85BYTE DID_LIST_NUM[VARS_SIZE]; // Number of vars for this DID

86WORD DID_LIST_NUMBER[VARS_SIZE][100]; // List of variables readed

with the identifier

87long NDID = 0; // Number of differente DIDs

88//////////////////////////////////////////////////////////////////////

////////////

89//////////////////////////////////////////////////////////////////////

////////////

9091

// All the times in milliseconds

92const int USER_SCAN_RATE=50;

93const int DELAY_SESSION=100;

94const int DELAY_SECURITY_ACCESS=500;

95const int DELAY_INPUT_READING=200;

96const int PERIOD_WATCHDOG=1000;

X10_Tester.can

of 128

97const int PERIOD_TESTER_PRESENT=2500;

98const int PERIOD_SCHEDULER=1;

99100

char ActiveSessionStr[4][100] = {"No Session", "Default Session", "Extended Session", "Extended Session (Secured)"};

101BYTE ActiveSession = 0;

102103

// Used for Tx/Rx data

104const int BUFFER_SIZE=4098;

105byte gRxDataBuffer[BUFFER_SIZE];

106byte gTxDataBuffer[BUFFER_SIZE];

107byte Aux_DataBuffer[BUFFER_SIZE];

108char txArraySize;

109char variant[4];

110111

// Used for Security Access

112BYTE ALG_eese_data[3];

113114

mstimer UserScan;

115mstimer StartDefaultSession;

116mstimer StartExtendedSession;

117mstimer Scheduler;

118mstimer Watchdog;

119mstimer ControlOutputs;

120mstimer GetLINTestResults;

121122

long sendCounter = 0; // Max: NDID

123long sendCounterAdd = 0; // To periodically read other

variables

124long writeIndex = 0; // Max: NVARS

125BYTE controlOutputsActive = 0; // In order to avoid timer

overlap

126127

DWORD timeStart = 0;

128DWORD timeStop = 0;

129BYTE schedulerStarted = 0;

130BYTE state = 0;

131132

// PROGRAMMED MESSAGE SENDINGS

133BYTE hasToSendGetVariant = 0;

134BYTE hasToSendGetSoftwareVersionS12Lear = 0;

135BYTE hasToSendGetSoftwareVersionS12Jlr = 0;

136BYTE hasToSendGetSoftwareVersionAtmel = 0;

137BYTE hasToSendSetVariant = 0;

138BYTE hasToSendReadStartLogicControl = 0;

139BYTE hasToDisableProtections = 0;

140BYTE hasToEnableProtections = 0;

141BYTE hasToSendGetPowerMode = 0;

142BYTE hasToSendChangePowerMode = 0;

143BYTE hasToChangeWatchdogState = 0;

144BYTE hasToSendFastGoToSleep = 0;

145BYTE hasToSendLINTestStart = 0;

146BYTE hasToSendLINTestGetResults = 0;

147BYTE hasToSendWakeupTestStart = 0;

148BYTE hasToSendWakeupTestGetResults = 0;

149BYTE hasToSendGetSerialNumber = 0;

150BYTE hasToSendReadColumnConfig = 0;

X10_Tester.can

of 128

151BYTE hasToSendWriteColumnConfig = 0;

152BYTE hasToSendWriteColumnDefault = 0;

153154

BYTE StartLogicControl[6];

155BYTE PowerMode = 0;

156BYTE StopWatchdog = 0;

157BYTE ColumnState = 0;

158DWORD ColumnParamVal[16];

159BYTE ColumnParamId[16];

160BYTE ColumnCycleState;

161162

BYTE SvpasPwm = 0;

163164

// AUTO TESTING

165mstimer AT_Delay;

166const long AT_MAX_STEPS = 300;

167const long AT_MAX_LINE_CHARS = 1024;

168WORD AT_TYPES[VARS_SIZE];

169char AT_NAMES[VARS_SIZE][MAX_VAR_LENGTH];

170WORD AT_TOLERANCE[VARS_SIZE];

171WORD AT_VALUES[VARS_SIZE][AT_MAX_STEPS];

172WORD AT_MEASURED_VALUES[VARS_SIZE][AT_MAX_STEPS];

173WORD AT_VALIDATION_RESULTS[VARS_SIZE][AT_MAX_STEPS]; // 0: Not

Tested, 1: Not Applicable, 2: OK, 3: NOK

174175

BYTE AT_State; // 0: Write Outputs, 1: Wait Stabilisation, 2:Read Inputs & Diags

176BYTE AT_Mode; // 0: Playing, 1: Recording

177BYTE AT_IncMode; // 0: Decreasing Steps, 1: Increasing Steps

178BYTE AT_OneStep;

179long AT_SeqIndex; // Sequential output index

180BYTE AT_SeqState; // 0: Activation, 1: Deactivation

181long AT_OUT_INDEX[VARS_SIZE];

182long AT_NUM_OUTPUTS;

183184

//DTC's variables

185int DTRL_DTC=0;

186int x;

187188

//Variables de rutines

189mstimer Routine_T;

190byte RoutineDataBuffer[BUFFER_SIZE];

191char RoutineArraySize;

192193

// Char

194char buffer[64];

195char DiagInfoASCII_[3];

196int Asciifound=0;

197char inhibit;

198char Auto_Test=0;

199200

//BSS Test

201int sec,min,hour;

202int increase;

203float Voltage;

204char aux[6];

205mstimer TimerCount;

X10_Tester.can

of 128

206Timer VoltageScheduler;

207dword glbHandle = 0;

208209

//Syst.Ident.

210int SwNum1,SwNum2;

211int EdNum1,EdNum2;

212char fileUsed[32];

213byte CheckingSwNum, CheckingEditNum;

214215

//AC Valve test

216Timer Test_Time;

217msTimer timeT;

218msTimer ReadT;

219msTimer StopRT;

220int AC_Valve_DC;

221int TestingTime;

222int t=0,s=0,m=0,ms=0;

223int up,ACV_T=0;

224int Offset;

225226

int LINErrors_Inicial;

227228

//Control_Lighting_Test

229mstimer t_ControlLighting;

230int CL_x=0;

231int SPI_Check=0;

232mstimer t_ReadFeedbacks;

233234

//Iocab DO_0 pulse generator

235mstimer t_PulseGenerator;

236int T_On,T_Off,iter;

237int ciclesCount;

238239

byte HW_Testing=0;

240}

241242

on start

243{

244OSEKTL_SetTxId(msgTesterToEcu.id);

245OSEKTL_SetRxId(msgEcuToTester.id);

246247

LoadConfigFromFile();

248LoadSystemIdent();

249ProcessDIDs();

250251

//PrintConfig();

252//PrintDIDs();

253//LoadCyclingFromFile();

254//PrintCycling();

255//

LoadDTCsFromFi

256257

CopyNameToDataBase();

258InitializeValues();

259putValue(VAR_DiagSession, ActiveSessionStr[ActiveSession]);

X10_Tester.can

of 128

260settimer(UserScan, USER_SCAN_RATE);

261putValue(AT_Continous,0);

262putValue(EBCM_WakeUpSleepCommand_,3);

263setTimer(DelayCalibration,1000);

264265

}

266267

LoadConfigFromFile ()

268{

269dword readHandle = 0;

270char readBuffer[255];

271char dataBuffer[255];

272long i = 0;

273long j = 0;

274long k = 0;

275long index = 0;

276277

write("Opening Config File");

278readHandle = openFileRead ("X10_Signals.csv", 0);

279//if(readHandle != 0) fileRewind(readHandle);

280if (readHandle != 0 && fileGetString(readBuffer, elcount(readBuffer),

readHandle) != 0)

281{

282while(fileGetString(readBuffer, elcount(readBuffer), readHandle) !=

0 )

283{

284// Read VARID

285j = 0; i = 0;

286while (readBuffer[i] != SEP && readBuffer[i] != 0 && i<=elcount(

readBuffer))

287{

288dataBuffer[j] = readBuffer[i];

289j++; i++;

290};

291dataBuffer[j] = 0;

292VARID[index] = atol(dataBuffer);

293294

//if(readBuffer[i] != SEP) write("Reading Error");

295296

// Read TYPE

297j = 0; i++;


readBuffer))

299{


301j++; i++;

302};


304if(strncmp(dataBuffer, "DI", strlen(dataBuffer))==0)

305TYPES[index] = 0;

306else if(strncmp(dataBuffer, "AI", strlen(dataBuffer))==0)


308else if(strncmp(dataBuffer, "DO", strlen(dataBuffer))==0)


310else if(strncmp(dataBuffer, "PO", strlen(dataBuffer))==0)


312else if(strncmp(dataBuffer, "AD", strlen(dataBuffer))==0)

X10_Tester.can

of 128


314else if(strncmp(dataBuffer, "DD", strlen(dataBuffer))==0)


316else if(strncmp(dataBuffer, "ROUT", strlen(dataBuffer))==0)


318//if(readBuffer[i] != SEP) write("Reading Error");

319320

// Read NAME

321j = 0; i++;


readBuffer))

323{


325j++; i++;

326};


328for(k=0; k<=j & k<MAX_VAR_LENGTH; k++)

329NAMES[index][k]=dataBuffer[k];


331332

// Read INVERT

333j = 0; i++;


readBuffer))

335{


337j++; i++;

338};


340INVERT[index] = atol(dataBuffer);


342343344

//write("=%s,varid=%d, index =%d",NAMES[index],VARID[index],index);

345346

// Read DID

347j = 2; i++;


readBuffer))

349{


351j++; i++;

352};


354dataBuffer[0] = '0';

355dataBuffer[1] = 'x';

356DID[index] = atol(dataBuffer);


358359

// Read NBYTES

360j = 0; i++;


readBuffer))

362{


364j++; i++;

X10_Tester.can

of 128

365};


367NBYTES[index] = atol(dataBuffer);


369370

// Read OFFSET

371j = 0; i++;


readBuffer))

373{


375j++; i++;

376};


378OFFSET[index] = atol(dataBuffer);


380381

// Read NBITS

382j = 0; i++;


readBuffer))

384{


386j++; i++;

387};


389NBITS[index] = atol(dataBuffer);


391392

// Read L0 Population

393j = 0; i++;


readBuffer))

395{


397j++; i++;

398};


400if(strncmp(dataBuffer, "Y", strlen(dataBuffer))==0)

401VARIANT_L0[index] = 0;

402else if(strncmp(dataBuffer, "N", strlen(dataBuffer))==0)

403VARIANT_L0[index] = 1;


405406

index++;

407};

408NVARS = index;

409write("Readed %d variables", NVARS);

410write("Closing Config File");

411fileClose(readHandle);

412}

413else

414{

415write("Config file cannot be opened");

416}

417418

}

X10_Tester.can

of 128

419420

ProcessDIDs ()

421{

422long i, j;

423int found;

424425

NDID = 0;

426for(i=0; i<NVARS; i++)

427{

428found = 0;

429for(j=0; j<NDID; j++)

430{

431if(DID[i] == DID_LIST[j])

432{

433DID_LIST_NUMBER[j][DID_LIST_NUM[j]] = i;//VARID[i];

434DID_LIST_ID[j][DID_LIST_NUM[j]] = VARID[i];//VARID[i];

435436

//write("\nDID_LIST_NUMBER[j][DID_LIST_NUM[j]]=%d ,DID_LIST_NUMBER= %d, ID=%d VAR=%d",DID_LIST_NUMBER[j][DID_LIST_NUM[j]],DID_LIST_NUM[j],j,i);

437//write("DID_LIST_ID[j][DID_LIST_NUM[j]]=%d ,

DID_LIST_NUMBER= %d, j=%d i=%d",DID_LIST_ID[j][DID_LIST_NUM[j]],DID_LIST_NUM[j],j,VARID[i]);

438//write("%s",NAMES[i]);

439440441

DID_LIST_NUM[j]++;

442if(TYPES[i] == 0) DID_LIST_NUM_INPUTS[j]++;

443else if(TYPES[i] == 1) DID_LIST_NUM_INPUTS[j]++;

444else if(TYPES[i] == 2) DID_LIST_NUM_OUTPUTS[j]++;


446else if(TYPES[i] == 4) DID_LIST_NUM_DIAGS[j]++;


448449

found = 1;

450break;

451}

452}

453if(found == 0)

454{

455DID_LIST_NUMBER[NDID][DID_LIST_NUM[NDID]] = i;//VARID[i];

456DID_LIST_ID[NDID][DID_LIST_NUM[NDID]] = VARID[i];//VARID[i];

457458

//write("DID_LIST_NUMBER=%d ,DID_LIST_NUMBER= %d, NDID=%d VAR=%d",DID_LIST_NUMBER[NDID][DID_LIST_NUM[NDID]],DID_LIST_NUM[NDID],NDID,i);

459//write("DID_LIST_NUMBER[NDID][DID_LIST_NUM[NDID]]=%s", NAMES[

DID_LIST_NUMBER[NDID][DID_LIST_NUM[NDID]]]);

460461

DID_LIST_NUM[NDID]++;

462if(TYPES[i] == 0) DID_LIST_NUM_INPUTS[j]++;

463else if(TYPES[i] == 1) DID_LIST_NUM_INPUTS[j]++;





468

X10_Tester.can

of 128

469DID_LIST[NDID] = DID[i];

470NDID++;

471}

472}

473write("Number of DIDs: %d", NDID);

474}

475476

PrintConfig ()

477{

478long i;

479for(i=0; i<NVARS; ++i)

480{

481write("index: %d, i VARID: %d, TYPE: %d, INVERT: %d, NAME: %s, DID:

0x%x, NBYTES: %d, OFFSET: %d, NBITS: %d",i, VARID[i], TYPES[i], INVERT[i], NAMES[i], DID[i], NBYTES[i], OFFSET[i], NBITS[i]);

482}

483}

484485

OSEKTL_DataCon (long txLength)

486{

487}

488489

OSEKTL_DataInd (long rxLength)

490{

491int count;

492493

OSEKTL_GetRxData(gRxDataBuffer,rxLength);

494495

count=rxLength;

496497

if((gRxDataBuffer[0]!=0x7F)&&(HW_Testing==1))

498{

499// EXTENDED SESSION ESTABLISHED

500if((gRxDataBuffer[0]==0x50)&&(gRxDataBuffer[1]==0x86))

501{

502ActiveSession = 2;

503putValue(VAR_DiagSession, ActiveSessionStr[ActiveSession]);

504write("Extended Session Established");

505506

// Start Input Reading

507putvalue(VAR_RefreshInputs, 1);

508putvalue(VAR_RefreshOutputs, 0);

509putvalue(VAR_RefreshDiags, 1);

510sendCounter = 0;

511sendCounterAdd = 0;

512writeIndex = NVARS;

513schedulerStarted = 1;

514hasToSendGetSerialNumber = 1;

515setTimer(Scheduler,DELAY_INPUT_READING);

516settimer(Watchdog, PERIOD_WATCHDOG);

517write("Starting Scheduler");

518write("Starting Watchdog");

519}

520// WRITE RESPONSE

521if((gRxDataBuffer[0]==0x7B)&&(gRxDataBuffer[1]==0x06))

522{

523if(inhibit==1)

X10_Tester.can

of 128

524{

525putValue(Status_Inhibit_DTCs,1);

526}

527else if(inhibit==0)

528{

529putValue(Status_Enabled_DTCs,1);

530}

531putValue(VAR_RefreshInputs,1);

532putValue(VAR_RefreshDiags,1);

533}

534// RESET RECOVERY

535if((gRxDataBuffer[0]==0x51)&&(gRxDataBuffer[1]==0x01))

536{



539}

540// TESTER PRESENT

541if(gRxDataBuffer[0]==0x7E)

542{

543UpdateTimer();

544}

545// INPUTS READING

546if(gRxDataBuffer[0]==0x61)

547{


549{

550for(x=0;x<21;x++)

551{

552Aux_DataBuffer[x]=gRxDataBuffer[x+2];

553}

554WriteCfgParam();

555}

556else if(gRxDataBuffer[1]==0x91)

557{

558putValue(Param_A, gRxDataBuffer[2]);

559putValue(Param_B1, gRxDataBuffer[3]);

560putValue(Param_B2, gRxDataBuffer[4]);

561putValue(Param_C, gRxDataBuffer[5]);

562}


564{

565putValue(BattDiscon_CNT,((gRxDataBuffer[2]*256)

+gRxDataBuffer[3]));

566567

putValue(VAR_RefreshInputs,1);


569}


571{

572putValue(B_First_GND_1,(gRxDataBuffer[2]>>7)&0x01);

573putValue(B_First_GND_2,(gRxDataBuffer[2]>>6)&0x01);

574}

575else if(gRxDataBuffer[1]==0x80) //System Ident.

576{

577interpreteAscii(gRxDataBuffer[2]);

578putValue(PartNumberLow_1_R,DiagInfoASCII_);


X10_Tester.can

of 128








587588

putValue(CodeIdDiag_R,gRxDataBuffer[7]);

589590

interpreteAscii(gRxDataBuffer[8]);

591putValue(CodeITG_1_R,DiagInfoASCII_);





596597

interpreteAscii(gRxDataBuffer[11]);

598putValue(HardwareNumber_1_R,DiagInfoASCII_);









607608

putValue(ID_Sw1_R,gRxDataBuffer[16]);

609putValue(ID_Sw2_R,gRxDataBuffer[17]);

610611

putValue(ID_Release1_R,gRxDataBuffer[18]);

612putValue(ID_Release2_R,gRxDataBuffer[19]);

613614

putValue(ID_Calib1_R,gRxDataBuffer[20]);

615putValue(ID_Calib2_R,gRxDataBuffer[21]);

616617

putValue(PartNumberBasic_R,gRxDataBuffer[22]);

618619

putValue(HwNumberBasicPart_R,gRxDataBuffer[23]);

620621

putValue(ApprovalNumberBasicPart_R,gRxDataBuffer[24]);

622623

putValue(idManufacture_R,gRxDataBuffer[25]);

624625

if(Auto_Test==1){Auto_Test=0;Check_Traceability();}

626627



629}

630else{OnReadResponse();}

631}

632// OUTPUTS WRITING ACK


634{

635OnIOCtlResponse();

636}

X10_Tester.can

of 128

637/*********************/

638if((gRxDataBuffer[0]==0x7B)&&(gRxDataBuffer[1]==0x98))

639{

640putValue(BattDiscon_CNT,0);

641}

642643

if((gRxDataBuffer[0]==0x7B)&&(gRxDataBuffer[1]==0x91))

644{

645putValue(WriteResult,1);

646}

647/************************/

648//SPI Test

649if((gRxDataBuffer[0]==0x7B)&&(gRxDataBuffer[1]==0x9F)&&(

SPI_Check==1))

650{

651//putValue(VAR_RefreshDiags,1);

652CL_x=5;

653settimer(t_ControlLighting,2900);

654}

655/************************/

656//DTC's Routine

657if (gRxDataBuffer[0]==0x54)

658{

659putValue(DTC_Cleared,1);

660putValue(DTRL_Dtc_Status,0);

661ClearDTCs ();



664}

665666

if (gRxDataBuffer[0]==0x59)

667{

668putValue(DTC_Cleared,0);

669if (gRxDataBuffer[1]==0x02)

670{

671if(count>4)

672{

673if(DTRL_DTC==0)

674{

675ReportDTC(gRxDataBuffer,count);

676}

677}

678}



681}

682}

683else

684{

685// ERROR


687{

688//PrintErrorCode(gRxDataBuffer[2]);

689UpdateTimer();

690}


692{

X10_Tester.can

of 128


694OnIOCtlResponse();

695}

696else if((gRxDataBuffer[1]==0x3B)&&(gRxDataBuffer[2]==0x12))

697{

698//SPI test: 3s counter begins

699CL_x=4;


701}

702else

703{


705UpdateTimer();

706}

707}

708}

709710

OSEKTL_ErrorInd (int error)

711{

712}

713714

OSEKTL_FirstFrameIndication (long source,long target,long length)

715{

716}

717718

PrintDIDs ()

719{

720long i,j;

721char list[500];

722char number[10];

723724

for(j=0; j<NDID; j++)

725{

726list[0] = 0;

727for(i=0; i<DID_LIST_NUM[j]; ++i)

728{

729ltoa(DID_LIST_NUMBER[j][i], number, 10);

730strncat(list, number, 500);

731strncat(list, " ", 500);

732}

733write("DID: %x, I:%d, O:%d, D:%d, T:%d, %s", DID_LIST[j],

DID_LIST_NUM_INPUTS[j], DID_LIST_NUM_OUTPUTS[j], DID_LIST_NUM_DIAGS[j],DID_LIST_NUM[j], list);

734735

}

736}

737738

on timer UserScan

739{

740long var;

741742

CopyValueFromDataBase();

743744

for(var=0; var<NVARS; ++var)

745{

746if((TYPES[var] == 2 || TYPES[var] == 3) && tmp[var] != VALUES[var])

747{

X10_Tester.can

of 128

748write("Change requested in %s, old: %d, new: %d", NAMES[var]

, VALUES[var], tmp[var]);

749VALUES[var] = tmp[var];

750CHANGE[var] = 1;

751writeIndex = var;

752}

753}

754755

if(getvalue(VAR_RefreshInputs) == 0 && getvalue(VAR_RefreshOutputs)== 0 && getvalue(VAR_RefreshDiags) == 0)

756UpdateTimer();

757758759

settimer(UserScan, USER_SCAN_RATE);

760}

761762

on envVar VAR_Start

763{

764if(getValue(this))

765{

766putValue(this,0);

767HW_Testing=1;

768setTimer(StartExtendedSession,DELAY_SESSION);

769}

770}

771772

on envVar VAR_Stop

773{


775{

776777

if(getValue(CALIBRATION_MODE))

778{

779putValue(Ciclat, 0);

780putValue(STATE, 0);

781putValue(AT_Step,0);

782}

783784

putValue(this,0);

785HW_Testing=0;

786write("Stopping...");

787putvalue(VAR_RefreshInputs, 0);

788putvalue(VAR_RefreshOutputs, 0);

789putvalue(VAR_RefreshDiags, 0);

790schedulerStarted = 0;

791792

canceltimer(Watchdog);

793canceltimer(Scheduler);

794}

795}

796797

on timer StartExtendedSession

798{

799long i;

800for (i=0; i<BUFFER_SIZE; i++) gTxDataBuffer[i]=0;

801802

gTxDataBuffer[0]=0x10;

X10_Tester.can

of 128

803gTxDataBuffer[1]=0x86;

804txArraySize=2;

805OSEKTL_DataReq(gTxDataBuffer, txArraySize);

806}

807808

UpdateTimer ()

809{

810if(schedulerStarted == 1)

811{

812/*if(hasToSendGetVariant == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

813else if(hasToSendSetVariant == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

814else if(hasToSendGetSoftwareVersionS12Lear == 1) settimer(

SendMessages, PERIOD_SCHEDULER);

815else if(hasToSendGetSoftwareVersionS12Jlr == 1) settimer(


816else if(hasToSendGetSoftwareVersionAtmel == 1) settimer(


817else if(hasToSendReadStartLogicControl == 1) settimer(


818else if(hasToDisableProtections == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

819else if(hasToEnableProtections == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

820else if(hasToSendGetPowerMode == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

821else if(hasToSendChangePowerMode == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

822else if(hasToChangeWatchdogState == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

823else if(hasToSendFastGoToSleep == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

824else if(hasToSendLINTestStart == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

825else if(hasToSendLINTestGetResults == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

826else if(hasToSendWakeupTestStart == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

827else if(hasToSendWakeupTestGetResults == 1) settimer(


828else if(hasToSendGetSerialNumber == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

829else if(hasToSendReadColumnConfig == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

830else if(hasToSendWriteColumnConfig == 1) settimer(SendMessages,

PERIOD_SCHEDULER);

831else if(hasToSendWriteColumnDefault == 1) settimer(SendMessages

, PERIOD_SCHEDULER);*/

832833

if(writeIndex == NVARS) // No signal to write

834{

835if(getvalue(VAR_RefreshInputs) != 0 || getvalue(

VAR_RefreshOutputs) != 0 || getvalue(VAR_RefreshDiags) != 0)

836{

837settimer(Scheduler, PERIOD_SCHEDULER);

838}

X10_Tester.can

of 128

839}

840841

else if(controlOutputsActive == 0)

842{

843controlOutputsActive = 1;

844settimer(ControlOutputs, PERIOD_SCHEDULER);

845}

846}

847}

848849

OnReadResponse ()

850{

851long identifier;

852long index,i,var;

853BYTE found;

854855

identifier=gRxDataBuffer[1];

856857

found = 0;

858for(index=0; index<NDID; index++)

859{

860if(DID_LIST[index]==identifier)

861{

862found = 1;

863break;

864}

865}

866867

if(found)

868{

869for(i=0; i<DID_LIST_NUM[index]; i++)

870{

871var = (long)(DID_LIST_NUMBER[index][i]);

872873

if((TYPES[var] != 2) && (TYPES[var] != 3))

874{

875VALUES[var] = MsgGetValue(OFFSET[var], NBITS[var])

;

876877

if(INVERT[var]==1)

878{

879if(VALUES[var]==0) VALUES[var]=1;

880else VALUES[var]=0;

881}

882}

883}

884}

885else

886OnNotFoundDID(identifier);

887888

if(ACV_T==0){UpdateTimer();}

889else if(ACV_T==1){ReportAC(m,s,ms,AC_Valve_DC,VALUES[76]);}

890}

891892

OnIOCtlResponse ()

893{

894long i;

X10_Tester.can

of 128

895896

controlOutputsActive = 0;

897898

for(i=0; i<NVARS; ++i)

899//for(i=NVARS; i>0; --i)

900{

901if(CHANGE[i]==1)

902{

903CHANGE[i]=0;

904writeIndex = i;

905break;

906}

907}

908909

//for(i=writeIndex; i<NVARS; ++i)

910/*for(i=writeIndex; i>0; --i)

911{

912if(CHANGE[i]==1)

913{

914writeIndex = i;

915break;

916}

917}*/

918919

if(i==NVARS) writeIndex=NVARS;

920//if(i==0) writeIndex=NVARS;

921922

UpdateTimer();

923}

924925

PrintErrorCode (BYTE errorID)

926{

927switch(errorID)

928{

929case 0x11:

930{

931write("Service Not Supported");

932break;

933}

934case 0x12:

935{

936write("Subfunction Not Supported / Invalid Format");

937break;

938}

939case 0x13:

940{

941write("Incorrect Message Length or Invalid Format");

942break;

943}

944case 0x21:

945case 0x78:

946{

947write("Busy Repeat Request");

948break;

949}

950case 0x22:

951{

X10_Tester.can

of 128

952write("Conditions Not Correct");

953break;

954}

955case 0x23:

956{

957write("Routine Not Complete");

958break;

959}

960case 0x31:

961{

962write("Request Out of Range");

963break;

964}

965case 0x33:

966{

967write("Security Access Denied");

968break;

969}

970case 0x35:

971{

972write("Invalid Key");

973break;

974}

975case 0x72:

976{

977write("General Programming Failure");

978break;

979}

980case 0x7E:

981{

982write("Subfunction Not Supported in Active Session");

983break;

984}

985case 0x7F:

986{

987write("Service Not Supported in Active Session");

988break;

989}

990default:

991{

992write("Unknown Error Code (%x)", errorID);

993break;

994}

995}

996}

997998

on timer StartDefaultSession

999{

1000long i;


10021003



1005txArraySize=2;


1007}

1008

X10_Tester.can

of 128

1009on timer Watchdog

1010{

1011DWORD timeWD;

10121013

timeWD = timeNow();

1014if( (timeWD-timeStart)/100 > PERIOD_TESTER_PRESENT )

1015{

1016putvalue(VAR_RefreshRate, (timeWD-timeStart)/100); // UPDATE

REFRESH RATE COUNTER

1017timeStart = timeWD;

1018sendCounter = 0;

1019sendCounterAdd = 0;

1020controlOutputsActive = 0;

1021SendTesterPresent();

1022}

10231024

settimer(Watchdog, PERIOD_WATCHDOG);

1025}

10261027

on timer Scheduler

1028{

1029switch(state)

1030{

1031case 0:

1032{

1033// READ INPUT, OUTPUT, DIAGS

1034SendReadDataById(DID_LIST[sendCounter]);

1035IncSendCounter();

1036if(sendCounter==0) state=1;

1037break;

1038}

1039case 1:

1040{

1041// SEND TESTER PRESENT


10431044

// UPDATE REFRESH RATE COUNTER

1045timeStop = timeNow();

1046if(timeStart != 0) putvalue(VAR_RefreshRate, (timeStop-timeStart)/

100);

1047timeStart = timeNow();

10481049

// UPDATE PANELS

1050CopyInputsAndDiagsToDataBase();

10511052

// UPDATE BATTERY VOLTAGE

1053//putValue(VAR_BatteryVoltage, ((double)VALUES[249])/100);

10541055

state=0;

1056break;

1057}

1058case 2:

1059{

1060// AUTO-TEST MODE

1061AT_Scheduler();

1062break;

1063}

X10_Tester.can

of 128

1064}

1065}

10661067

SendTesterPresent ()

1068{

1069gTxDataBuffer[0]=0x3E;


1071txArraySize=2;


1073}

10741075

SendReadDataById(int value)

1076{

1077long i;


10791080


1081gTxDataBuffer[1]=value;

1082txArraySize=2;

10831084

OSEKTL_DataReq(gTxDataBuffer, txArraySize);

1085}

10861087

IncSendCounter ()

1088{

1089sendCounter++;

10901091

if(sendCounter==NDID)

1092sendCounter=0;

1093else

1094{

1095// Skip Inputs if necessary

1096if(getvalue(VAR_RefreshInputs) == 0)

1097{

1098while(DID_LIST_NUM_INPUTS[sendCounter] != 0 &&

DID_LIST_NUM_OUTPUTS[sendCounter] == 0 && DID_LIST_NUM_DIAGS[sendCounter] == 0)

1099{

1100sendCounter++;

1101if(sendCounter==NDID) sendCounter=0;

1102}

1103}

11041105

// Skip Outputs if necessary

1106if(getvalue(VAR_RefreshOutputs) == 0)

1107{

1108while(DID_LIST_NUM_INPUTS[sendCounter] == 0 &&

DID_LIST_NUM_OUTPUTS[sendCounter] != 0 && DID_LIST_NUM_DIAGS[sendCounter] == 0)

1109{

1110sendCounter++;


1112}

1113}

11141115

// Skip Diags if necessary

1116if(getvalue(VAR_RefreshDiags) == 0)

X10_Tester.can

of 128

1117{

1118while(DID_LIST_NUM_INPUTS[sendCounter] == 0 &&

DID_LIST_NUM_OUTPUTS[sendCounter] == 0 && DID_LIST_NUM_DIAGS[sendCounter] != 0)

1119{

1120sendCounter++;


1122}

1123}

1124}

1125}

11261127

on timer ControlOutputs

1128{

1129SendIOControlById(DID[writeIndex]);

1130}

11311132

void SendIOControlById (int identifier)

1133{

1134long i;

11351136

for (i=0; i<BUFFER_SIZE; i++) gTxDataBuffer[i]=0;

11371138


1139gTxDataBuffer[1]=identifier;

1140gTxDataBuffer[3]=0xFF;

11411142

txArraySize = 2 + MsgIOControl(identifier);

114311441145


1146}

11471148

BYTE MsgIOControl (WORD identifier)

1149//MsgIOControl (WORD identifier)

1150{

11511152

long index, i,var;

1153WORD value;

11541155

for(index=0; index<NDID; ++index)

1156if(DID_LIST[index]==identifier) break;

11571158

for(i=0; i<DID_LIST_NUM[index]; ++i)

1159{

1160var = DID_LIST_NUMBER[index][i];

1161ErrorImm[0][0][var].Varid= DID_LIST_ID[index][i];

11621163

value = VALUES[var];

1164//write("%s, varid=%d, DID=%x",AT_NAMES[var], ErrorImm[0][0][var

].Varid, DID[var]);

11651166

if(INVERT[var]==1)

1167{

1168if(value==0) value=1;

1169else value=0;

1170}

X10_Tester.can

of 128

1171if((TYPES[var]==2)||(TYPES[var]==3))

1172{

1173if((var==138)&&(value==1)&&(getValue(AT_Play)==1)) //LimpHome

aprofitant el EXTERNAL_WATCHDOG

1174{

1175putValue(Env_SBCForceSafeActiveLow,1);

1176}

1177MsgSetValue(OFFSET[var], NBITS[var], value);

1178//return NBYTES[var];

11791180

}

1181CHANGE[var]=0;

1182}

118311841185118611871188

////write("=%s,AT_VARID=%d",AT_NAMES[i],AT_VARID[i]);

118911901191

//write("%x %x",NBYTES[var],var);

1192return NBYTES[var];

1193}

11941195

WORD MsgSetMask (WORD identifier)

1196{

1197long index, var;

1198WORD i, dataLength, addedBytes;

1199WORD maskOn;

1200//write("Mask %x", identifier);

1201maskOn = 1;

1202addedBytes = 0;

12031204

if(maskOn)

1205{

1206for(index=0; index<NDID; ++index)

1207if(DID_LIST[index]==identifier) break;

12081209

var = DID_LIST_NUMBER[index][0];

1210dataLength = NBYTES[var];

12111212

//write("DataLength %d", dataLength);

1213if(NBYTES[var]*8 != NBITS[var])

1214{

1215for(i=0; i<dataLength; ++i)

1216gTxDataBuffer[4+dataLength+i] = 0xFF;

1217addedBytes = dataLength;

1218}

1219}

1220return addedBytes;

1221}

12221223

MsgSetValue (BYTE offset, BYTE size, int value)

1224{

1225if(size<8)

1226{

X10_Tester.can

of 128

1227if(value>0)

1228{

1229gTxDataBuffer[2] = 0xFB;

1230}

1231else if(value==0)

1232{

1233gTxDataBuffer[2] = 0xFC;

1234}

1235}

1236else if (size==8)

1237{

1238if(value>0)

1239{

1240gTxDataBuffer[2] = 0xFB;

1241gTxDataBuffer[4] = value;

1242}

1243else if(value==0)

1244{

1245gTxDataBuffer[2] = 0xFC;

1246gTxDataBuffer[4] = value;

1247}

1248}

1249else

1250value = -1;

1251}

12521253

word MsgGetValue (DWORD offset, DWORD size)

1254{

1255word value;

12561257

if(size<8)

1258{

1259value = (gRxDataBuffer[(offset/8)+2]>>(7-(offset%8)-size+1))&(

0xFF>>(8-size));

1260}


1262{

1263value = (gRxDataBuffer[(offset/8)+2])&0xFF;

1264}


1266{

1267value = (gRxDataBuffer[(offset/8)+2])*256+gRxDataBuffer[(offset/

8)+3];

1268}

1269else

1270value = -1;

12711272

return value;

1273}

12741275

void OnNotFoundDID (long did)

1276{

1277long index;

1278float value;

1279int aux;

1280char SoftwareVersionS12Lear[25];

1281char SoftwareVersionS12Jlr[17];

X10_Tester.can

of 128

1282char SoftwareVersionAtmel[100];

1283char SerialNumber[17];

12841285

switch(did)

1286{

1287/*case 0xF1F5: // Variant

1288{

1289putValue(VAR_Variant, gRxDataBuffer[3]);

1290break;

1291}

1292case 0xFD98: // Software Version S12 Lear

1293{

1294for(index=0; index<24; ++index)

1295SoftwareVersionS12Lear[index] = gRxDataBuffer[3+index];

1296SoftwareVersionS12Lear[24] = 0;

1297putvalue(VAR_SoftwareVersionS12Lear, SoftwareVersionS12Lear);

1298break;

1299}

1300case 0xF188: // Software Version S12 JLR

1301{


1303SoftwareVersionS12Jlr[index] = gRxDataBuffer[3+index];

1304SoftwareVersionS12Jlr[16] = 0;

1305putvalue(VAR_SoftwareVersionS12JLR, SoftwareVersionS12Jlr);

1306break;

1307}

1308case 0xF1F0: // Software Version Atmel

1309{

1310snprintf(SoftwareVersionAtmel, elcount(SoftwareVersionAtmel)

, "%x %x %x %x %x %x %x %x %x", gRxDataBuffer[3], gRxDataBuffer[4],gRxDataBuffer[5], gRxDataBuffer[6], gRxDataBuffer[7], gRxDataBuffer[8],gRxDataBuffer[9], gRxDataBuffer[10], gRxDataBuffer[11]);

1311putvalue(VAR_SoftwareVersionAtmel, SoftwareVersionAtmel);

1312break;

1313}

1314case 0xFEE7: // Start Logic Control

1315{


1317StartLogicControl[index] = gRxDataBuffer[3+index];

1318putValue(VAR_PowerMode, StartLogicControl[3]);

1319break;

1320}

1321case 0xF18C: // Serial Number

1322{


1324SerialNumber[index] = gRxDataBuffer[3+index];

1325SerialNumber[16] = 0;

1326putvalue(VAR_SerialNumber, SerialNumber);

1327break;

1328}*/

1329default:

1330{

1331write("Received unknown DID 0x%4x", did);

1332break;

1333}

1334}

1335}

X10_Tester.can

of 128

13361337

CopyInputsAndDiagsToDataBase ()

1338{

1339if(TYPES[0] == 0 || TYPES[0] == 1 || TYPES[0] == 4 || TYPES[0] == 5

) putValue(VAR000, VALUES[0]);



















1349if(TYPES[10] == 0 || TYPES[10] == 1 || TYPES[10] == 4 || TYPES[10]

== 5) putValue(VAR010, VALUES[10]);

































X10_Tester.can

of 128


























































X10_Tester.can

of 128

































1439if(TYPES[100] == 0 || TYPES[100] == 1 || TYPES[100] == 4 || TYPES[

100] == 5) putValue(VAR100, VALUES[100]);
























X10_Tester.can

of 128


























































X10_Tester.can

of 128


































1639}

16401641

CopyValueFromDataBase ()

1642{

1643if(TYPES[0] == 2 || TYPES[0] == 3) tmp[0] = getValue(VAR000);




















X10_Tester.can

of 128


























































X10_Tester.can

of 128





















































1943}

19441945

CopyNameToDataBase ()

1946{

1947putValue(STR000, NAMES[0]);

X10_Tester.can

of 128


























































X10_Tester.can

of 128















2247}

22482249

InitializeValues ()

2250{

2251long i;

22522253

putValue(Threshold,5);

2254putValue(CALIBRATION_MODE, 1);

2255putValue(CYCLING_MODE, 0);

225622572258

//fileNameAT=("ImmunityCycle.xml");

2259//strncpy(fileNameAT,"ImmunityCycle.xml%d",1,MAX_VAR_LENGTH);

22602261226222632264

for(i=0; i<VARS_SIZE; ++i)

2265{

2266VALUES[i] = 0;

2267tmp[i] = 0;

2268arrayError[i][0]=0;


2270NewStep[i]= AT_VALUES[i][0];

227122722273

}

227422752276

}

22772278

WORD MsgSetMaskT5MY10 (WORD identifier)

2279{

2280WORD i, dataLength, addedBytes;

22812282

switch(identifier)

2283{

2284case 0xFD01:

2285{

2286dataLength = 9;

2287addedBytes = 9;

2288break;

2289}

X10_Tester.can

of 128

2290case 0xFD04:

2291{

2292dataLength = 14;

2293addedBytes = 2;

2294break;

2295}

2296case 0xFD08:

2297{

2298dataLength = 3;

2299addedBytes = 2;

2300break;

2301}

2302case 0xFD09:

2303{

2304dataLength = 1;

2305addedBytes = 1;

2306break;

2307}

2308}

23092310

for(i=0; i<addedBytes; ++i)

2311gTxDataBuffer[4+dataLength+i] = 0xFF;

23122313

return addedBytes;

2314}

23152316

/*on timer SendMessages

2317{

2318// GET VARIANT

2319if(hasToSendGetVariant == 1)

2320{

2321hasToSendGetVariant = 0;

23222323


2324gTxDataBuffer[1]=0xF1;


2326txArraySize=3;


2328}

2329// GET SOFTWARE VERSION S12 LEAR

2330else if(hasToSendGetSoftwareVersionS12Lear == 1)

2331{

2332hasToSendGetSoftwareVersionS12Lear = 0;


2334gTxDataBuffer[1]=0xFD;


2336txArraySize=3;


2338}

2339// GET SOFTWARE VERSION S12 JLR

2340else if(hasToSendGetSoftwareVersionS12Jlr == 1)

2341{

2342hasToSendGetSoftwareVersionS12Jlr = 0;




2346txArraySize=3;

X10_Tester.can

of 128


2348}

2349// GET SOFTWARE VERSION ATMEL

2350else if(hasToSendGetSoftwareVersionAtmel == 1)

2351{

2352hasToSendGetSoftwareVersionAtmel = 0;




2356txArraySize=3;


2358}

2359// SET VARIANT

2360else if(hasToSendSetVariant == 1)

2361{

2362hasToSendSetVariant = 0;

2363gTxDataBuffer[0] = 0x2E;

2364gTxDataBuffer[1] = 0xF1;


2366gTxDataBuffer[3] = getValue(VAR_Variant);

23672368

txArraySize = 4;


2370}

2371// READ START LOGIC CONTROL

2372else if(hasToSendReadStartLogicControl == 1)

2373{

2374hasToSendReadStartLogicControl = 0;

2375gTxDataBuffer[0] = 0x22;

2376gTxDataBuffer[1] = 0xFE;

2377gTxDataBuffer[2] = 0xE7;

23782379

txArraySize = 3;


2381}

2382// DISABLE PROTECTIONS

2383else if(hasToDisableProtections == 1)

2384{

2385hasToDisableProtections = 0;


2387gTxDataBuffer[1] = 0xFD;











23982399

txArraySize = 12;


2401}

2402// ENABLE PROTECTIONS

2403else if(hasToEnableProtections == 1)

X10_Tester.can

of 128

2404{

2405hasToEnableProtections = 0;




2409gTxDataBuffer[3] = 0xFF;









24182419

txArraySize = 12;


2421}

2422// GET POWER MODE

2423else if(hasToSendGetPowerMode == 1)

2424{

2425hasToSendGetPowerMode = 0;




24292430

txArraySize = 3;


2432}

2433// CHANGE POWER MODE

2434else if(hasToSendChangePowerMode == 1)

2435{

2436hasToSendChangePowerMode = 0;





2441gTxDataBuffer[4] = StartLogicControl[0];



2444gTxDataBuffer[7] = PowerMode;


2446if(PowerMode == 0x06)

2447gTxDataBuffer[9] = StartLogicControl[5] | 0x04;

2448else if(PowerMode == 0x04)

2449gTxDataBuffer[9] = StartLogicControl[5] & 0xFB;

24502451

txArraySize = 10;


2453}

2454// CHANGE WATCHDOG STATE

2455else if(hasToChangeWatchdogState == 1)

2456{

2457hasToChangeWatchdogState = 0;




X10_Tester.can

of 128


2462gTxDataBuffer[4] = StopWatchdog; // Disabled: 0x01

24632464

txArraySize = 5;


2466}

2467// FAST GO TO SLEEP

2468else if(hasToSendFastGoToSleep == 1)

2469{

2470hasToSendFastGoToSleep = 0;





2475gTxDataBuffer[4] = 0x01; // Fast Go To Sleep

24762477

txArraySize = 5;


2479}

2480// LIN TEST START

2481else if(hasToSendLINTestStart == 1)

2482{

2483hasToSendLINTestStart = 0;





24882489

txArraySize = 4;


2491}

2492// LIN TEST GET RESULTS

2493else if(hasToSendLINTestGetResults == 1)

2494{

2495hasToSendLINTestGetResults = 0;





25002501

txArraySize = 4;


2503}

2504// WAKE-UP TEST START

2505else if(hasToSendWakeupTestStart == 1)

2506{

2507hasToSendWakeupTestStart = 0;





25122513

txArraySize = 4;


2515}

2516// WAKE-UP TEST GET RESULTS

2517else if(hasToSendWakeupTestGetResults == 1)

X10_Tester.can

of 128

2518{

2519hasToSendWakeupTestGetResults = 0;





25242525

txArraySize = 4;


2527}

2528// GET SERIAL NUMBER

2529else if(hasToSendGetSerialNumber == 1)

2530{

2531hasToSendGetSerialNumber = 0;



2534gTxDataBuffer[2] = 0x8C;

25352536

txArraySize = 3;


2538}

2539// READ COLUMN EEPROM CONFIG PARAMETERS

2540else if(hasToSendReadColumnConfig == 1)

2541{

2542ColumnConfigRead();

2543}

2544// WRITE COLUMN EEPROM CONFIG PARAMETERS

2545else if(hasToSendWriteColumnConfig == 1)

2546{

2547ColumnConfigWrite();

2548}

2549// WRITE COLUMN DEFAULT CONFIG

2550else if(hasToSendWriteColumnDefault == 1)

2551{

2552hasToSendWriteColumnDefault = 0;





2557gTxDataBuffer[4] = 0x0F;

25582559

txArraySize = 5;


2561}

2562}*/

25632564

on envVar VAR_ALL_OFF

2565{


2567{

2568SetStateOFF();

2569}

2570}

25712572

on envVar VAR_ALL_ON

2573{


X10_Tester.can

of 128

2575{

2576SetStateON();

2577}

2578}

25792580

SetStateOFF ()

2581{

2582long i;

25832584


2585{

2586if( i==124 || i==164 )

2587{

2588CHANGE[i]=0; // SVPAS OUTPUTS ARE NOT DEACTIVATED (T5

SPECIFIC)

2589}

2590else

2591{

2592if(TYPES[i]==2 || TYPES[i]==3)

2593{

2594VALUES[i]=0;

2595CHANGE[i]=1;

2596writeIndex=i;

2597}

2598}

2599}

2600CopyOutputsToDataBase();

2601}

26022603

SetStateON()

2604{

2605long i;

26062607


2608{

2609if(TYPES[i]==2 || TYPES[i]==3)

2610{

2611if( i==143 || i==144 || i==145 || i==146 || i==147 || i

==148 )

2612VALUES[i]=0; // COLUMN OUTPUTS ARE NOT ACTIVATED (T5

SPECIFIC)

2613else

2614{

2615if(NBITS[i]==1)

2616VALUES[i]=0x01;

2617else if(NBITS[i]==8)

2618VALUES[i]=0xFF;

2619else if(NBITS[i]==16)

2620VALUES[i]=0xFFFF;

2621}

2622CHANGE[i]=1;

2623if(writeIndex == NVARS) writeIndex = i;

2624}

2625}


2627}

2628

X10_Tester.can

of 128

2629CopyOutputsToDataBase()

2630{

2631if(TYPES[0] == 2 || TYPES[0] == 3) putValue(VAR000, VALUES[0]);























































X10_Tester.can

of 128


























































X10_Tester.can

of 128


















2931}

29322933

on timer GetLINTestResults

2934{

2935hasToSendLINTestGetResults=1;

2936}

29372938

AT_LoadConfig ()

2939{

2940dword readHandle;

2941char readBuffer[1024];

2942char dataBuffer[255];

2943long i;

2944long j;

2945long k;

2946long index;

2947char fileNameAT[255];

2948BYTE headerOK;

2949long AT_STEPS_tmp;

29502951

readHandle = 0;

2952i = 0;

2953j = 0;

2954k = 0;

2955index = 0;

2956putValue(AT_NVARS, 0);

2957putValue(AT_STEPS, 0);

2958getValue(AT_File, fileNameAT);

2959AT_STEPS_tmp = 0;

29602961

write("Opening AT File");

2962readHandle = openFileRead (fileNameAT, 0);

2963//if(readHandle != 0) fileRewind(readHandle);

2964if (readHandle != 0 && fileGetString(readBuffer, elcount(readBuffer),

readHandle) != 0)

2965{

2966// READ HEADER

2967headerOK = 1;

2968{

2969

X10_Tester.can

of 128

2970// Read TYPE

2971j = 0; i = 0;


readBuffer))

2973{


2975j++; i++;

2976}


2978if(strncmp(dataBuffer, "TYPE", strlen(dataBuffer))!=0) headerOK =

0;

2979if(readBuffer[i] != SEP) headerOK = 0;

29802981

// Read NAME

2982j = 0; i++;


readBuffer))

2984{


2986j++; i++;

2987}


2989if(strncmp(dataBuffer, "NAME", strlen(dataBuffer))!=0) headerOK =

0;


29912992

// Read TOLERANCE

2993j = 0; i++;


readBuffer))

2995{


2997j++; i++;

2998}


3000if(strncmp(dataBuffer, "TOL", strlen(dataBuffer))!=0) headerOK = 0;


30023003

// Read Number of Steps

3004do

3005{

3006j = 0; i++;

3007while (readBuffer[i] != SEP && readBuffer[i] != 0 && i<

=elcount(readBuffer))

3008{


3010j++; i++;

3011}

3012AT_STEPS_tmp++;

3013} while(readBuffer[i] == SEP);

3014putValue(AT_STEPS, AT_STEPS_tmp);

3015if(readBuffer[i-1] != 0x0A) headerOK = 0;

3016if(readBuffer[i] != 0x00) headerOK = 0;

3017}

3018if(headerOK == 0) write("Header Incorrect");

30193020

// READ ROWS

X10_Tester.can

of 128

3021while(fileGetString(readBuffer, elcount(readBuffer), readHandle) !=

0 & headerOK)

3022{

3023// Read TYPE

3024j = 0; i = 0;


readBuffer))

3026{


3028j++; i++;

3029}


3031if(strncmp(dataBuffer, "DI", strlen(dataBuffer))==0)

3032AT_TYPES[index] = 0;

3033else if(strncmp(dataBuffer, "AI", strlen(dataBuffer))==0)


3035else if(strncmp(dataBuffer, "DO", strlen(dataBuffer))==0)


3037else if(strncmp(dataBuffer, "PO", strlen(dataBuffer))==0)


3039else if(strncmp(dataBuffer, "AD", strlen(dataBuffer))==0)


3041else if(strncmp(dataBuffer, "DD", strlen(dataBuffer))==0)



30443045

// Read NAME

3046j = 0; i++;


readBuffer))

3048{


3050j++; i++;

3051}


3053for(k=0; k<=j & k<MAX_VAR_LENGTH; k++)

3054AT_NAMES[index][k]=dataBuffer[k];


30563057

// Read TOLERANCE

3058j = 0; i++;


readBuffer))

3060{


3062j++; i++;

3063};


3065AT_TOLERANCE[index] = (WORD)atol(dataBuffer);


30673068

// Read Step Values

3069for(k=0; k<getValue(AT_STEPS); k++)

3070{

3071j = 0; i++;

3072while (readBuffer[i] != SEP && readBuffer[i] != 0 &&

readBuffer[i] != 0x0A && i<=elcount(readBuffer))

X10_Tester.can

of 128

3073{


3075j++; i++;

3076};


3078AT_VALUES[index][k] = atol(dataBuffer);

3079//write("k=%d =%s value=%d",k, AT_NAMES[index],

AT_VALUES[index][k]);

3080//if(readBuffer[i] != SEP & readBuffer[i] != 0x0A) write

("Reading Error");

3081}

30823083

if(k==getValue(AT_STEPS))

3084{

3085AT_VALUES[index][k] = AT_VALUES[index][0];

3086//write("k=%d =%s value=%d",k, AT_NAMES[index],

AT_VALUES[index][k]);

3087}

30883089309030913092

index++;

3093};

3094putValue(AT_NVARS, index);

3095write("Readed %d variables", getValue(AT_NVARS));

3096write("Closing AT File");

3097fileClose(readHandle);

3098}

3099else

3100{

3101write("AT file cannot be opened");

3102}

3103}

31043105

AT_PrintConfig ()

3106{

3107long i;

3108for(i=0; i<getValue(AT_NVARS); ++i)

3109{

3110write("TYPE: %d, NAME: %s, TOL: %d, S0: %d, S1: %d, S2: %d",

AT_TYPES[i], AT_NAMES[i], AT_TOLERANCE[i], AT_VALUES[i][0], AT_VALUES[i][1], AT_VALUES[i][2]);

3111}

3112write("Variables: %d", AT_NVARS);

3113write("Steps %d", AT_STEPS);

3114}

31153116

on envVar AT_Load

3117{


3119{


3121AT_LoadConfig();

3122//AT_PrintConfig();

31233124

state = 0; // Normal Mode

X10_Tester.can

of 128

3125AT_State = 0; // Write Outputs

3126AT_Mode = 0; // Playing

3127AT_IncMode = 1; // Increasing

3128AT_SeqIndex = 0;

3129AT_SeqState = 0;

3130AT_OneStep = 0;

3131putValue(AT_Step, 0);

3132}

3133}

31343135

AT_SaveConfig ()

3136{

3137dword writeHandle;

3138char writeBuffer[AT_MAX_LINE_CHARS];

3139char tmp[255];

3140char EOL[2];

3141char sep_str[2];

3142long i;

3143long j;

3144long k;

3145long index;

3146char fileNameAT[255];

3147BYTE headerOK;

31483149

writeHandle = 0;

3150i = 0;

3151j = 0;

3152k = 0;

3153index = 0;

3154EOL[0] = 0x0A; EOL[1] = 0x00;

3155sep_str[0] = SEP; sep_str[1] = 0x00;

3156getValue(AT_File, fileNameAT);

31573158

write("Opening AT File");

3159writeHandle = openFileWrite (fileNameAT, 0);

3160if (writeHandle != 0 )

3161{

3162// HEADER

3163snprintf(writeBuffer, elcount(writeBuffer), "%s", "TYPE");

3164strncat(writeBuffer, sep_str, AT_MAX_LINE_CHARS);

3165strncat(writeBuffer, "NAME", AT_MAX_LINE_CHARS);


3167strncat(writeBuffer, "TOL", AT_MAX_LINE_CHARS);


3169for(i=0; i< getValue(AT_STEPS); ++i)

3170{

3171snprintf(tmp, elcount(tmp), "%d", i+1);

3172strncat(writeBuffer, tmp, AT_MAX_LINE_CHARS);

3173if(i != getValue(AT_STEPS)-1) strncat(writeBuffer, sep_str,

AT_MAX_LINE_CHARS);

3174}

3175strncat(writeBuffer, EOL, AT_MAX_LINE_CHARS);

3176filePutString(writeBuffer, strlen(writeBuffer), writeHandle);

31773178

// VARIABLES

3179for(index=0; index<getValue(AT_NVARS); ++index)

3180{

X10_Tester.can

of 128

3181switch(AT_TYPES[index])

3182{

3183case 0:

3184{

3185snprintf(writeBuffer, elcount(writeBuffer), "%s", "

DI");

3186break;

3187}

3188case 1:

3189{


AI");

3191break;

3192}

3193case 2:

3194{


DO");

3196break;

3197}

3198case 3:

3199{


PO");

3201break;

3202}

3203case 4:

3204{


AD");

3206break;

3207}

3208case 5:

3209{


DD");

3211break;

3212}

3213}


3215strncat(writeBuffer, AT_NAMES[index], AT_MAX_LINE_CHARS);


3217snprintf(tmp, elcount(tmp), "%d", AT_TOLERANCE[index]);




3221{

3222snprintf(tmp, elcount(tmp), "%d", AT_VALUES[index][i]);


3224if(i != getValue(AT_STEPS)-1) strncat(writeBuffer,

sep_str, AT_MAX_LINE_CHARS);

3225}



3228}

32293230

write("Closing AT File");

X10_Tester.can

of 128

3231fileClose(writeHandle);

3232}

3233else

3234{

3235write("AT file cannot be opened");

3236}

3237}

32383239

on envVar AT_Save

3240{


3242{

3243AT_SaveConfig();

3244}

3245}

32463247

on envVar AT_Reset

3248{


3250{

3251AT_ResetConfig();

3252}

3253}

32543255

on envVar AT_Record

3256{


3258{

3259AT_RecordState();

3260}

3261}

32623263

AT_RecordState ()

3264{

3265long i;

32663267

putValue(AT_NVARS ,NVARS);


3269{

3270AT_TYPES[i] = TYPES[i];

3271strncpy(AT_NAMES[i], NAMES[i], strlen(NAMES[i])+1);

3272if(AT_TYPES[i] == 0) AT_TOLERANCE[i] = 0;

3273else if(AT_TYPES[i] == 1) AT_TOLERANCE[i] = 10;





3278AT_VALUES[i][getValue(AT_STEPS)] = VALUES[i];

3279}

3280putValue(AT_STEPS, getValue(AT_STEPS)+1);

3281}

32823283

on envVar AT_Play

3284{


3286{

3287writeClear(1); // Clear Write window (1=>CAPL)

X10_Tester.can

of 128

3288Auto_Test = 1;

3289//putValue(SystId,1);

32903291

putValue(BSS_Read,1);

32923293

//LINErrors_Inicial=getValue(VAR_ErrCountLIN);

32943295

state = 2; // AT MODE






3301AT_OneStep = 0;

3302Auto_Test = 1;


3304}

3305else

3306{

3307state = 0; // NORMAL MODE

3308}

3309}

33103311

AT_SetOutputState (WORD AT_Step)

3312{

3313long i;

33143315

for(i=0; i<getValue(AT_NVARS); ++i)

3316{

3317331833193320332133223323

if(TYPES[i]==2 || TYPES[i]==3)

3324{

3325VALUES[i]=AT_VALUES[i][AT_Step];

3326CHANGE[i]=1;

3327writeIndex=i;

3328}

3329}


3331//msgBeep(4);

3332}

33333334

on timer AT_Delay

3335{


3337AT_State=2;

3338}

33393340

AT_Scheduler ()

3341{

3342long i;

33433344

// UPDATE REFRESH RATE COUNTER

X10_Tester.can

of 128

3345timeStop = timeNow();

3346if(timeStart != 0) putvalue(VAR_RefreshRate, (timeStop-timeStart)/100);

3347timeStart = timeNow();

33483349

switch(AT_State)

3350{

3351case 0:

3352{

3353// AUTO-TEST: WRITE OUTPUTS

3354//DbgMsg("AT WRITE");

3355//write("1-%lf",(timenow()/100000.0));

3356if(AT_Mode==0) AT_SetOutputState(getValue(AT_Step)); //

Playing

3357else if(AT_Mode==1) AT_SeqActivation(); //

Recording

3358UpdateTimer();

3359AT_State=1;

3360break;

3361}

3362case 1:

3363{

3364// AUTO-TEST: WAIT FOR DIAGNOSTICS STABILISATION

3365//DbgMsg("AT WAIT");

3366/*if((getValue(AT_Step)%2)==0)

3367{

3368settimer(AT_Delay, getValue(AT_Interval));

3369}

3370else

3371{


3373}*/

3374//write("2-%lf",(timeNow()/100000.0));


3376sendCounter = 0;

3377//AT_State=2;

3378// If it is playing and no read and check is requested

3379if(getValue(AT_ReadAndCheck) == 0 & AT_Mode == 0)

3380{

3381AT_State=0;

3382AT_UpdateStep();

3383if(AT_OneStep == 1) // FOR STEP FW & STEP BW

3384{

3385state = 0;

3386AT_OneStep = 0;

3387}

3388}

3389break;

3390}

3391case 2:

3392{

3393// AUTO-TEST: READ INPUTS & DIAGNOSTICS

3394//if(sendCounter == 0) DbgMsg("AT READ");

3395//write("3-%lf",(timeNow()/100000.0));

3396SendReadDataById(DID_LIST[sendCounter]);

3397IncSendCounter();

3398if(sendCounter==0) // LAST SIGNAL WAS READ

3399{

X10_Tester.can

of 128

3400AT_State=0;

3401if(AT_Mode == 0) // PLAYING

3402{

34033404

//BUS CAN connecting back

3405/*if((arrayError[144][1] < arrayError[144][0])&&

getValue(Ciclat)>1)

3406{

3407write("recuperem la comunicació en AT_scheduler");

3408setTimer(FailureCAN,250);

3409}*/

341034113412

CopyInputsAndDiagsToDataBase();

34133414

if (getValue(StateCycle) && startaux)

3415{

3416AT_CheckValues(getValue(AT_Step));

3417}

34183419

if (getValue(CALIBRATION_MODE))

3420{

3421AT_CheckValues(getValue(AT_Step));

3422}

34233424

}

3425else if(AT_Mode == 1) // RECORDING

3426{

3427if(AT_SeqState == 1) // After Output Activation

3428{


3430AT_VALUES[i][getValue(AT_STEPS)] = VALUES[i];

3431putValue(AT_STEPS, getValue(AT_STEPS)+1);

3432}

34333434

if(AT_SeqIndex == AT_NUM_OUTPUTS)

3435{

3436putValue(AT_Auto, 0); // Finish Recording

3437}

3438}

3439// UPDATE AT_Step

3440if(AT_Mode == 0) // PLAYING

3441{


3443if(AT_OneStep == 1) // FOR STEP FW & STEP BW

3444{

3445state = 0;

3446AT_OneStep = 0;

3447}

3448}

3449else // RECORDING

3450{

3451putValue(AT_Step, AT_STEPS);

3452}

3453}

3454break;

3455}

X10_Tester.can

of 128

3456}

3457}

34583459

DbgMsg (char msg[])

3460{

3461long timeArray[9];

3462char str[1024];

3463getLocalTime(timeArray);

3464snprintf(str, elcount(str), "%d:%d:%d %s", timeArray[2], timeArray[1

], timeArray[0], msg);

3465write(str);

3466}

34673468

AT_CheckValues (WORD AT_Step)

3469{

3470int contaux;

34713472

long i;

3473WORD minVal, maxVal;

3474BYTE hasErrors;

3475char msgString[AT_MAX_LINE_CHARS];

3476char tmpString[AT_MAX_LINE_CHARS];

3477long timeArray[9];

3478char EOL[2];

3479EOL[0] = 0x0A; EOL[1] = 0x00;

3480contaux=0;

34813482

hasErrors = 0;


348434853486

//snprintf(msgString, elcount(msgString), "%d:%d:%d STEP NUMBER %d", timeArray[2], timeArray[1], timeArray[0], AT_Step);

3487//strncat(msgString, EOL, AT_MAX_LINE_CHARS);

34883489

for(i=0; i<getValue(AT_NVARS); ++i)

3490{

34913492

AT_VALIDATION_RESULTS[i][AT_Step] = 1; // NotApplicable

34933494

if( AT_CheckVariant(i) )

3495{

3496AT_VALIDATION_RESULTS[i][AT_Step] = 2; // OK

3497eflag[i]=0;

34983499

// Calculate MIN and MAX values

3500if(AT_VALUES[i][AT_Step] < AT_TOLERANCE[i])

minVal = 0;

3501else minVal = AT_VALUES[i][AT_Step] -

AT_TOLERANCE[i];

3502maxVal = AT_VALUES[i][AT_Step] + AT_TOLERANCE[i];

35033504

//write("estem dintre del checkvalue");

35053506

// Check intervals

3507if(VALUES[i] < minVal | VALUES[i] > maxVal)

X10_Tester.can

of 128

3508{

35093510

eflag[i]=1;

35113512

hasErrors = 1;

3513contaux++;

35143515

/*snprintf(tmpString, elcount(tmpString), "-ERROR! VAR: %s / MIN: %d / MAX: %d / VAL: %d", AT_NAMES[i], minVal,maxVal, VALUES[i]);

3516strncat(msgString, tmpString, AT_MAX_LINE_CHARS);

3517strncat(msgString, EOL, AT_MAX_LINE_CHARS);*/

3518AT_VALIDATION_RESULTS[i][AT_Step] = 3; // NOK

3519}

35203521

}

352235233524

// AD and DD just are displayed, Immunity cycle routine start onCycle 1 in order to have a known state

35253526

if(getValue(CYCLING_MODE))

3527{

3528if (TYPES[i]==4 || TYPES[i]==5)

3529{

3530if(getValue(Ciclat)>1) ImmunityCycle(i,AT_Step);

3531}

3532}

3533if (getValue(CALIBRATION_MODE))

3534{

35353536

Calibration(i,AT_Step);

35373538

}

35393540

AT_MEASURED_VALUES[i][AT_Step] = VALUES[i];

35413542

}

3543putValue(Env_ErrorCounter,contaux);

3544//write("contadoraux %d",contaux);

3545//write("ErrorCounter %d",errorCounter);

3546contaux=0;

354735483549

//BSS Value

3550AT_MEASURED_VALUES[i+1][AT_Step] = getValue(EAlternatorLoadD);

3551//LIN Communication

3552AT_MEASURED_VALUES[i+2][AT_Step] = getValue(LIN_Status);

3553AT_MEASURED_VALUES[i+3][AT_Step] = getValue(VAR_ErrCountLIN);

35543555

if(hasErrors) write(msgString);

35563557

if((getValue(VAR_ErrCountLIN)-LINErrors_Inicial)>0)

3558{

3559snprintf(tmpString, elcount(tmpString), "- LIN ERRORS! NUM: %d"

, (getValue(VAR_ErrCountLIN)-LINErrors_Inicial));

3560write(tmpString);

X10_Tester.can

of 128

3561}

35623563

if(getValue(LIN_Status)!=0)

3564{

3565snprintf(tmpString, elcount(tmpString), "- NOT LIN COMMUNICATION

");

3566write(tmpString);

3567}

35683569

LINErrors_Inicial=getValue(VAR_ErrCountLIN);

3570}

35713572

on envVar AT_Auto

3573{


3575{

3576AT_GenOutputList();

3577AT_DefaultConfig();

3578state = 2; // AT MODE


3580AT_Mode = 1; // Recording




3584AT_OneStep = 0;


3586}

3587else

3588{

3589state = 0; // NORMAL MODE

3590}

3591}

35923593

AT_SeqActivation ()

3594{

3595long index;

35963597

switch(AT_SeqState)

3598{

3599// ACTIVATION

3600case 0:

3601{

3602index = AT_OUT_INDEX[AT_SeqIndex];

36033604

// Only if the output is inactive

3605if(VALUES[index] == 0)

3606{

3607// Activate output

3608if(NBITS[index]==1)

3609VALUES[index]=0x01;

3610else if(NBITS[index]==8)

3611VALUES[index]=0xFF;

3612else if(NBITS[index]==16)

3613VALUES[index]=0xFFFF;

36143615

CHANGE[index] = 1;

3616writeIndex = index;

X10_Tester.can

of 128


3618//msgBeep(4);

36193620

AT_SeqState = 1;

36213622

putValue(AT_Message, NAMES[index]);

3623}

3624else

3625{

3626// Go to next output

3627AT_SeqIndex++;

3628//if(AT_SeqIndex==AT_NUM_OUTPUTS) AT_SeqIndex=0;

3629}

3630break;

3631}

3632// DEACTIVATION

3633case 1:

3634{

3635index = AT_OUT_INDEX[AT_SeqIndex];

36363637

// Deactivate output

3638VALUES[index]=0;

3639CHANGE[index] = 1;

3640writeIndex = index;


36423643

// Go to next output

3644AT_SeqIndex++;

3645//if(AT_SeqIndex==AT_NUM_OUTPUTS) AT_SeqIndex=0;

36463647

AT_SeqState = 0;

3648break;

3649}

3650}

3651}

36523653

AT_GenOutputList ()

3654{

3655long i;

36563657

AT_NUM_OUTPUTS = 0;


3659{

3660if(TYPES[i] == 2 | TYPES[i] == 3)

3661{

3662AT_OUT_INDEX[AT_NUM_OUTPUTS] = i;

3663AT_NUM_OUTPUTS++;

3664}

3665}


3667write("Number of Outputs used: %d", AT_NUM_OUTPUTS);

3668}

36693670

AT_ResetConfig ()

3671{

3672long i, j;

3673

X10_Tester.can

of 128

3674for(i=0; i<VARS_SIZE; ++i)

3675{

3676AT_TYPES[i] = 0;

3677for(j=0; j<MAX_VAR_LENGTH; ++j)

3678AT_NAMES[i][j] = 0;

3679AT_TOLERANCE[i] = 0;

3680for(j=0; j<AT_MAX_STEPS; ++j)

3681{

3682AT_VALUES[i][j] = 0;

3683AT_MEASURED_VALUES[i][j] = 0;

3684AT_VALIDATION_RESULTS[i][j] = 0;

3685}

3686}

3687putValue(AT_NVARS, 0);



3690}

36913692

AT_DefaultConfig ()

3693{

3694long i,j;

36953696

putValue(AT_NVARS, NVARS);


3698{

3699AT_TYPES[i] = TYPES[i];

3700strncpy(AT_NAMES[i], NAMES[i], strlen(NAMES[i])+1);

3701if(AT_TYPES[i] == 0) AT_TOLERANCE[i] = 0;






3707for(j=0; j<AT_MAX_STEPS; ++j)

3708AT_VALUES[i][j] = 0;

3709}


3711}

37123713

on envVar AT_FW

3714{


3716{

3717if(AT_IncMode == 0)

3718{




3722}






3728AT_OneStep = 1;

3729}

3730}

X10_Tester.can

of 128

37313732

on envVar AT_BW

3733{


3735{

3736if(AT_IncMode == 1)

3737{

3738AT_IncMode = 0; // Decreasing



3741}






3747AT_OneStep = 1;

3748}

3749}

37503751

AT_UpdateStep ()

3752{

3753if(AT_IncMode == 1) // Increasing

3754{

375537563757

if ((errorCounter<=0 && startaux && getValue(StateCycle)))

3758{

3759putValue(AT_Step, getValue(AT_Step)+1);

3760putValue(STATE, getValue(STATE)+1);

3761}

37623763

if (getValue(CALIBRATION_MODE))

3764{

3765putValue(AT_Step, getValue(AT_Step)+1);

3766putValue(STATE, getValue(STATE)+1);

37673768

if(getValue(AT_Step) == getValue(AT_STEPS)) // Last Step

3769{


3771putValue(StateCycle,0);

3772putValue(STATE,0);

3773putValue(Ciclat,getValue(Ciclat)+1);

37743775

if(getValue(Ciclat)>=4)

3776{

3777CreateXMLCalibration();

3778write("genero el report de calibratge");

3779putValue(Ciclat,0);

3780}

3781}

3782378337843785

}

37863787

//// Immunity Cycle.

X10_Tester.can

of 128

3788if(getValue(AT_Step) > getValue(AT_STEPS)) // Last Step

3789{


3791putValue(StateCycle,0);


3793putValue(Ciclat,getValue(Ciclat)+1);

3794if(getValue(AT_Continous) == 0) putValue(AT_Play, 0);

3795}

379637973798

}

3799else // Decreasing

3800{

3801if(getValue(AT_Step) == 0) // Last Step

3802{

3803putValue(AT_Step,getValue(AT_STEPS)-1);

3804putValue(STATE, getValue(STATE)-1);

3805if(getValue(AT_Continous) == 0) putValue(AT_Play, 0);

3806}

3807else

3808{

3809putValue(AT_Step, getValue(AT_Step)-1);

3810putValue(STATE, getValue(STATE)-1);

3811}

3812}

3813}

38143815

AT_UpdateInpAndDiag ()

3816{

3817// Update Inputs and Diagnostics from Validation Results

38183819

long i, s;

3820for(s=0; s<getValue(AT_STEPS); ++s)

3821{


3823{

3824if( AT_TYPES[i] == 0 | AT_TYPES[i] == 1 | AT_TYPES[i] == 4

| AT_TYPES[i] == 5)

3825{

3826AT_VALUES[i][s] = AT_MEASURED_VALUES[i][s];

3827}

3828}

3829}

3830}

38313832

on envVar AT_Update

3833{


3835{

3836AT_UpdateInpAndDiag();

3837}

3838}

38393840

AT_SaveValidationReport ()

3841{

3842dword writeHandle;

3843char writeBuffer[AT_MAX_LINE_CHARS];

X10_Tester.can

of 128

3844char tmp[255];

3845char EOL[2];

3846char sep_str[2];

3847long i, j, k;

3848long index;

3849char fileNameReport[255];

38503851

long timeArray[9];

3852char timeStr[1024];

38533854

BYTE globalResult;

3855BYTE stepResult[AT_MAX_STEPS];

38563857

writeHandle = 0;

3858i = 0;

3859j = 0;

3860k = 0;

3861index = 0;

3862EOL[0] = 0x0A; EOL[1] = 0x00;

3863sep_str[0] = SEP; sep_str[1] = 0x00;

38643865

// INITIALIZE GLOBAL RESULT AND STEP RESULT

3866globalResult = 2; // OK


3868{

3869stepResult[i] = 2; // OK

3870}


3872{


3874{

3875if( AT_TYPES[index] == 0 | AT_TYPES[index] == 1 | AT_TYPES[

index] == 4 | AT_TYPES[index] == 5)

3876{

3877if(AT_VALIDATION_RESULTS[index][i] == 3) stepResult[i]

= 3;

3878if(AT_VALIDATION_RESULTS[index][i] == 0 & stepResult[i]

!= 3) stepResult[i] = 0;

38793880

if(AT_VALIDATION_RESULTS[index][i] == 3) globalResult =3;

3881if(AT_VALIDATION_RESULTS[index][i] == 0 & globalResult !

= 3) globalResult = 0;

3882}

3883}

3884}

38853886

// FILE NAME

3887getValue(VAR_SerialNumber, fileNameReport);


3889switch(getValue(VAR_Variant))

3890{

3891case 0:

3892snprintf(timeStr, elcount(timeStr), "%s", "L0");

3893break;

3894}

3895

X10_Tester.can

of 128

3896if(globalResult==0)

3897{

3898snprintf(tmp, elcount(tmp), "_%d-%d-%d_%d.%d_NT.csv", timeArray[

5]+1900, timeArray[4]+1, timeArray[3], timeArray[2], timeArray[1]);

3899}

3900else if(globalResult==2)

3901{

3902snprintf(tmp, elcount(tmp), "_%d-%d-%d_%d.%d_OK.csv", timeArray[

5]+1900, timeArray[4]+1, timeArray[3], timeArray[2], timeArray[1]);

3903}

3904else if(globalResult==3)

3905{

3906snprintf(tmp, elcount(tmp), "_%d-%d-%d_%d.%d_NOK.csv", timeArray

[5]+1900, timeArray[4]+1, timeArray[3], timeArray[2], timeArray[1]);

3907}

3908strncat(timeStr, tmp, 255);

3909strncat(fileNameReport, timeStr, 255);

39103911

writeHandle = openFileWrite (fileNameReport, 0);

3912if (writeHandle != 0 )

3913{

3914// HEADER

3915snprintf(writeBuffer, elcount(writeBuffer), "%s", "TYPE");


3917strncat(writeBuffer, "NAME", AT_MAX_LINE_CHARS);


3919strncat(writeBuffer, "TOL", AT_MAX_LINE_CHARS);



3922{

3923if(stepResult[i]==0)

3924snprintf(tmp, elcount(tmp), "%d (NT)", i+1);


3926snprintf(tmp, elcount(tmp), "%d", i+1);


3928snprintf(tmp, elcount(tmp), "%d (NOK)", i+1);



AT_MAX_LINE_CHARS);

3931}



39343935

// VARIABLES


3937{

3938switch(AT_TYPES[index])

3939{

3940case 0:

3941{


DI");

3943break;

3944}

3945case 1:

3946{


X10_Tester.can

of 128

AI");

3948break;

3949}

3950case 2:

3951{


DO");

3953break;

3954}

3955case 3:

3956{


PO");

3958break;

3959}

3960case 4:

3961{


AD");

3963break;

3964}

3965case 5:

3966{


DD");

3968break;

3969}

3970}


3972strncat(writeBuffer, AT_NAMES[index], AT_MAX_LINE_CHARS);


3974snprintf(tmp, elcount(tmp), "%d", AT_TOLERANCE[index]);




3978{

3979if( AT_TYPES[index] == 0 | AT_TYPES[index] == 1 |

AT_TYPES[index] == 4 | AT_TYPES[index] == 5)

3980{

3981if(AT_VALIDATION_RESULTS[index][i] == 0) // Not

Tested

3982snprintf(tmp, elcount(tmp), "NT");

3983if(AT_VALIDATION_RESULTS[index][i] == 1) // Not

Applicable

3984snprintf(tmp, elcount(tmp), "NA");

3985if(AT_VALIDATION_RESULTS[index][i] == 2) // OK

3986snprintf(tmp, elcount(tmp), "%d",

AT_MEASURED_VALUES[index][i]);

3987if(AT_VALIDATION_RESULTS[index][i] == 3) // NOK

3988snprintf(tmp, elcount(tmp), "%d (NOK)",

AT_MEASURED_VALUES[index][i]);

3989}

3990else

3991snprintf(tmp, elcount(tmp), "%d", AT_VALUES[index][i

]);

39923993

strncat(writeBuffer, tmp, AT_MAX_LINE_CHARS);

X10_Tester.can

of 128

3994if(i != getValue(AT_STEPS)-1) strncat(writeBuffer,

sep_str, AT_MAX_LINE_CHARS);

3995}



3998}

39994000

//BSS

4001snprintf(writeBuffer, elcount(writeBuffer), "%s", "COM");


4003strncat(writeBuffer, "BSS", AT_MAX_LINE_CHARS);


4005snprintf(tmp, elcount(tmp), "%d", 0);




4009{

4010snprintf(tmp, elcount(tmp), "%d", AT_MEASURED_VALUES[index+1

][i]);



AT_MAX_LINE_CHARS);

4013}



40164017

//LIN - State



4020strncat(writeBuffer, "LIN State", AT_MAX_LINE_CHARS);






4026{


][i]);


4029if(AT_MEASURED_VALUES[index+2][i]==2)

4030{

4031snprintf(tmp, elcount(tmp), "(NOK)");


4033}



AT_MAX_LINE_CHARS);

4036}



40394040

//LIN - Errors



4043strncat(writeBuffer, "LIN errors", AT_MAX_LINE_CHARS);



X10_Tester.can

of 128




4049{


][i]);



AT_MAX_LINE_CHARS);

4053}



4056//*********************

40574058

//Traceability

4059snprintf(writeBuffer, elcount(writeBuffer), "%s", "Traceability"

);


4061strncat(writeBuffer, "Soft.Num", AT_MAX_LINE_CHARS);


40634064

if(CheckingSwNum==1){snprintf(tmp, elcount(tmp), "%s", "OK");strncat(writeBuffer, tmp, AT_MAX_LINE_CHARS);}

4065else if(CheckingSwNum==2){snprintf(tmp, elcount(tmp), "%s", "NOK

");strncat(writeBuffer, tmp, AT_MAX_LINE_CHARS);}

4066CheckingSwNum=0;


40684069

snprintf(tmp, elcount(tmp), "%x", SwNum2);


4071snprintf(tmp, elcount(tmp), "%x", SwNum1);



4074snprintf(tmp, elcount(tmp), "%x", getValue(ID_Sw1_R));

4075strncat(writeBuffer, tmp , AT_MAX_LINE_CHARS);

4076snprintf(tmp, elcount(tmp), "%x", getValue(ID_Sw2_R));





40814082

snprintf(writeBuffer, elcount(writeBuffer), "%s", "Traceability");


4084strncat(writeBuffer, "Edit.Num", AT_MAX_LINE_CHARS);


40864087

if(CheckingEditNum==1){snprintf(tmp, elcount(tmp), "%s", "OK");strncat(writeBuffer, tmp, AT_MAX_LINE_CHARS);}

4088else if(CheckingEditNum==2){snprintf(tmp, elcount(tmp), "%s", "

NOK");strncat(writeBuffer, tmp, AT_MAX_LINE_CHARS);}

4089CheckingEditNum=0;


40914092

snprintf(tmp, elcount(tmp), "%x", EdNum2);


4094snprintf(tmp, elcount(tmp), "%x", EdNum1);

X10_Tester.can

of 128



4097snprintf(tmp, elcount(tmp), "%x", getValue(ID_Release1_R));


4099snprintf(tmp, elcount(tmp), "%x", getValue(ID_Release2_R));





4104//*********************

41054106

write("Validation Report Created");

4107fileClose(writeHandle);

4108}

4109else

4110{

4111write("Validation Report Could not be Created");

4112}

4113}

41144115

on envVar AT_Report

4116{


4118{

4119AT_SaveValidationReport();

4120}

4121}

41224123

on envVar ReadBattDiscon

4124{

4125if(getValue(this)==1)

4126{



41294130

RoutineDataBuffer[0]=0x21;

4131RoutineDataBuffer[1]=0x98;

4132RoutineArraySize=2;

4133settimer(Routine_T,200);

4134}

4135}

41364137

on envVar ResetBattDiscon

4138{


4140{



41434144

RoutineDataBuffer[0]=0x3B;





4149}

4150}

4151

X10_Tester.can

of 128

4152on envVar Read_LossGND

4153{


4155{



41584159





4163}

4164}

41654166

ClearDTCs ()

4167{

4168putValue(DTC1,0);

4169putValue(DTC2_1,0);








































X10_Tester.can

of 128















































42554256

putValue(DTC44_1,0);


42584259

putValue(DTC45_1,0);







X10_Tester.can

of 128


























4291}

42924293

ReportDTC(byte RxBuffer[],int length)

4294{

4295int n;

42964297

for(n=3;n<length;n=n+4)

4298{

4299if(RxBuffer[n]==0x92)

4300{

4301switch(RxBuffer[n+1])

4302{

4303case 0x0E:

4304if(RxBuffer[n+2]==0x04) putValue(DTC1,1);

4305break;

43064307

case 0x0F:

4308if(RxBuffer[n+2]==0x16) putValue(DTC33_1,1);





4313break;

43144315

case 0x11:


4317break;

43184319

case 0x12:




X10_Tester.can

of 128

4323break;

43244325

case 0x13:




4329break;

43304331

case 0x14:




4335break;

43364337

case 0x15:




4341break;

43424343

case 0x16:




4347break;

43484349

case 0x17:



4352break;

43534354

case 0x18:




4358break;

43594360

case 0x19:



4363if(RxBuffer[n+2]==0x12) putValue(DTC12_3,1)

;

4364break;

43654366

case 0x1A:




;

4370break;

43714372

case 0x1C:


4374break;

43754376

case 0x1D:


X10_Tester.can

of 128


4379break;

43804381

case 0x1E:



4384break;

43854386

case 0x1F:


4388break;

43894390

case 0x20:



4393break;

43944395

case 0x21:



4398break;

43994400

case 0x22:



4403break;

44044405

case 0x23:



4408break;

44094410

case 0x24:



4413break;

44144415

case 0x26:


4417break;

44184419

case 0x27:


4421break;

44224423

case 0x29:




4427break;

44284429

case 0x2A:




4433break;

4434

X10_Tester.can

of 128

4435case 0x2C:



4438break;

44394440

case 0x2D:


4442break;

44434444

case 0x2E:



4447break;

44484449

case 0x2F:



4452break;

44534454

case 0x30:





4459break;

44604461

case 0x31:




;

4465break;

44664467

case 0x33:



4470break;

44714472

case 0x35:


4474break;

44754476

case 0x36:


4478break;

44794480

case 0x37:




4484break;

44854486

case 0x38:



4489break;

4490

X10_Tester.can

of 128

4491case 0x39:



4494break;

44954496

case 0x3A:




4500break;

45014502

case 0x40:



4505break;

45064507

case 0x41:




4511break;

45124513

case 0x52:


4515break;

45164517

case 0x55:


4519break;

45204521

case 0x56:




4525break;

45264527

case 0x57:




4531break;

45324533

case 0x58:




4537break;

45384539

case 0x60:




4543break;

45444545

case 0x61:



X10_Tester.can

of 128

;

4548break;

45494550

case 0x62:


4552break;

45534554

case 0x63:








4562break;

45634564

case 0x64:








4572break;

45734574

case 0x65:



;

4577break;

45784579

case 0x66:



;

4582break;

45834584

case 0x67:



;


;



4590break;

45914592

case 0x68:



;


;

4596break;

4597

X10_Tester.can

of 128

4598case 0x69:



;


4602break;

46034604

case 0x70:


4606break;

46074608

case 0x71:

4609if(RxBuffer[n+2]==0x1D) putValue(DTC57_1,1);


;


4612break;

46134614

case 0x72:


4616break;

46174618

}

4619}

4620}

4621}

46224623

on envVar ReadDTC

4624{


4626{

4627putValue(ReadDTC,0);



46304631



4633RoutineDataBuffer[2]=0xEF;



4636DTRL_DTC=0;

4637}

4638}

46394640

on envVar ClearDTC

4641{


4643{

4644putValue(ClearDTC,0);



46474648


4649RoutineDataBuffer[1]=0xFF;




X10_Tester.can

of 128


4654}

4655}

46564657

on envVar ExtWatchdog_Ctrl

4658{


4660{



46634664






4669}

4670}

46714672

on timer Routine_T

4673{

4674for(x=0;x<RoutineArraySize;x++)

4675{

4676gTxDataBuffer[x]=RoutineDataBuffer[x];

4677}

4678txArraySize=RoutineArraySize;


46804681



4683}

46844685

on envVar Env_SBCReleaseSafeInactiveHigh

4686{


4688{



46914692






4697}

4698}

46994700

on envVar Env_SBCForceSafeActiveLow

4701{


4703{




47074708



X10_Tester.can

of 128




4713}

4714}

47154716

char interpreteAscii(byte asciicode)

4717{

4718Asciifound=0;

4719strncpy(DiagInfoASCII_," ",3);

4720switch(asciicode)

4721{

4722case 0x30: //--

4723strncpy(DiagInfoASCII_,"0",3);

4724Asciifound=1; break;

4725case 0x31: //--

4726strncpy(DiagInfoASCII_, "1",3);


4728case 0x32: //--



4731case 0x33: //--



4734case 0x34: //--



4737case 0x35: //--



4740case 0x36: //--



4743case 0x37: //--



4746case 0x38: //--



4749case 0x39: //--



4752case 0x41: //--

4753strncpy(DiagInfoASCII_, "A",3);


4755case 0x42: //--

4756strncpy(DiagInfoASCII_, "B",3);


4758case 0x43: //--

4759strncpy(DiagInfoASCII_, "C",3);


4761case 0x44: //--

4762strncpy(DiagInfoASCII_, "D",3);


4764case 0x45: //--

4765strncpy(DiagInfoASCII_, "E",3);


X10_Tester.can

of 128

4767case 0x46: //--

4768strncpy(DiagInfoASCII_, "F",3);


4770case 0x47: //--

4771strncpy(DiagInfoASCII_, "G",3);


4773case 0x48: //--

4774strncpy(DiagInfoASCII_, "H",3);


4776case 0x49: //--

4777strncpy(DiagInfoASCII_, "I",3);


4779case 0x4A: //--

4780strncpy(DiagInfoASCII_, "J",3);


4782case 0x4B: //--

4783strncpy(DiagInfoASCII_, "K",3);


4785case 0x4C: //--

4786strncpy(DiagInfoASCII_, "L",3);


4788case 0x4D: //--

4789strncpy(DiagInfoASCII_, "M",3);


4791case 0x4E: //--

4792strncpy(DiagInfoASCII_, "N",3);


4794case 0x4F: //--

4795strncpy(DiagInfoASCII_, "O",3);


4797case 0x50: //--

4798strncpy(DiagInfoASCII_, "P",3);


4800case 0x51: //--

4801strncpy(DiagInfoASCII_, "Q",3);


4803case 0x52: //--

4804strncpy(DiagInfoASCII_, "R",3);


4806case 0x53: //--

4807strncpy(DiagInfoASCII_, "S",3);


4809case 0x54: //--

4810strncpy(DiagInfoASCII_, "T",3);


4812case 0x55: //--

4813strncpy(DiagInfoASCII_, "U",3);


4815case 0x56: //--

4816strncpy(DiagInfoASCII_, "V",3);


4818case 0x57: //--

4819strncpy(DiagInfoASCII_, "W",3);


4821case 0x58: //--

4822strncpy(DiagInfoASCII_, "X",3);


X10_Tester.can

of 128

4824case 0x59: //--

4825strncpy(DiagInfoASCII_, "Y",3);


4827case 0x5A: //--

4828strncpy(DiagInfoASCII_, "Z",3);


4830case 0x61: //--

4831strncpy(DiagInfoASCII_, "a",3);


4833case 0x62: //--

4834strncpy(DiagInfoASCII_, "b",3);


4836case 0x63: //--

4837strncpy(DiagInfoASCII_, "c",3);


4839case 0x64: //--

4840strncpy(DiagInfoASCII_, "d",3);


4842case 0x65: //--

4843strncpy(DiagInfoASCII_, "e",3);


4845case 0x66: //--

4846strncpy(DiagInfoASCII_, "f",3);


4848case 0x67: //--

4849strncpy(DiagInfoASCII_, "g",3);


4851case 0x68: //--

4852strncpy(DiagInfoASCII_, "h",3);


4854case 0x69: //--

4855strncpy(DiagInfoASCII_, "i",3);


4857case 0x6A: //--

4858strncpy(DiagInfoASCII_, "j",3);


4860case 0x6B: //--

4861strncpy(DiagInfoASCII_, "k",3);


4863case 0x6C: //--

4864strncpy(DiagInfoASCII_, "l",3);


4866case 0x6D: //--

4867strncpy(DiagInfoASCII_, "m",3);


4869case 0x6E: //--

4870strncpy(DiagInfoASCII_, "n",3);


4872case 0x6F: //--

4873strncpy(DiagInfoASCII_, "o",3);


4875case 0x70: //--

4876strncpy(DiagInfoASCII_, "p",3);


4878case 0x71: //--

4879strncpy(DiagInfoASCII_, "q",3);


X10_Tester.can

of 128

4881case 0x72: //--

4882strncpy(DiagInfoASCII_, "r",3);


4884case 0x73: //--

4885strncpy(DiagInfoASCII_, "s",3);


4887case 0x74: //--

4888strncpy(DiagInfoASCII_, "t",3);


4890case 0x75: //--

4891strncpy(DiagInfoASCII_, "u",3);


4893case 0x76: //--

4894strncpy(DiagInfoASCII_, "v",3);


4896case 0x77: //--

4897strncpy(DiagInfoASCII_, "w",3);


4899case 0x78: //--

4900strncpy(DiagInfoASCII_, "x",3);


4902case 0x79: //--

4903strncpy(DiagInfoASCII_, "y",3);


4905case 0x7A: //--

4906strncpy(DiagInfoASCII_, "z",3);


4908default: //--

4909strncpy(DiagInfoASCII_, "?",3);

4910Asciifound=1;

4911break;

4912}

4913return(DiagInfoASCII_[0]);

4914}

49154916

on envVar SystId

4917{


4919{




49234924





4928}

4929}

49304931

WriteCfgParam ()

4932{

4933gTxDataBuffer[0]=0x3B;


49354936

for(x=0;x<21;x++)

4937{

X10_Tester.can

of 128

4938gTxDataBuffer[x+2]=Aux_DataBuffer[x];

4939}

49404941

if(inhibit==1)

4942{











4953}

4954else if(inhibit==0)

4955{











4966}

4967txArraySize=23;


4969}

49704971

on envVar Enable_DTCs

4972{


4974{



49774978





4982inhibit=0;

49834984

putvalue(Status_Enabled_DTCs,0);

4985putvalue(Status_Inhibit_DTCs,0);

4986}

4987}

49884989

on envVar Inhibit_DTCs

4990{


4992{



X10_Tester.can

of 128

49954996





5000inhibit=1;

50015002

putvalue(Status_Enabled_DTCs,0);

5003putvalue(Status_Inhibit_DTCs,0);

5004}

5005}

50065007

on envVar SwReset

5008{


5010{




50145015





5019}

5020}

50215022

on timer TimerCount

5023{

5024settimer(TimerCount,1000);

5025sec++;

5026if(sec>59)

5027{

5028sec=0;

5029min++;

5030}

5031if(min>59)

5032{

5033min=0;

5034hour++;

5035}

5036putValue(TimeInSec,sec);

5037putValue(TimeInMin,min);

5038putValue(TimeInHour,hour);

50395040

if(getValue(EAlternatorLoadD)==0xFF)

5041{

5042putValue(BSS_Alarm,1);

5043ReportError(getValue(EAlternatorLoadD),Voltage,hour,min,sec);

5044}

5045else{putValue(BSS_Alarm,0);}

5046}

50475048

on timer VoltageScheduler

5049{

5050if(increase==1)

5051{

X10_Tester.can

of 128

5052Voltage = Voltage + getValue(Stepvolt);

5053}

5054else if(increase==0)

5055{

5056Voltage = Voltage - getValue(Stepvolt);

5057}

50585059

snprintf(aux, 6, "%.2f", Voltage);

50605061

putValue(Source_Voltage,aux);

50625063

if((Voltage==16.00)&&(increase==1))

5064{

5065increase=0;

5066}

5067else if((Voltage==8.00)&&(increase==0))

5068{

5069increase=1;

5070}

50715072

putValue(BSSCurrentVolt,Voltage);

5073setTimer(VoltageScheduler,getValue(TimeStep));

5074}

50755076

on envVar StartBSSTest

5077{


5079{

5080increase = 1;

5081Voltage = 8.00;

5082snprintf(aux, 6, "%.2f", Voltage);

50835084

putValue(Source_Voltage,aux);

5085putValue(BSSCurrentVolt,Voltage);

5086setTimer(VoltageScheduler,getValue(TimeStep));

5087sec=0;

5088min=0;

5089hour=0;

5090settimer(TimerCount,1000);

5091glbHandle = OpenFileWrite ("ErrorReport_BSS_Test.txt",0);

5092}

5093}

50945095

on envVar StopBSSTest

5096{


5098{

5099increase = 1;

5100Voltage = 0.00;

5101snprintf(aux, 6, "%.2f", Voltage);

5102putValue(Source_Voltage,aux);

51035104

putValue(BSSCurrentVolt,Voltage);

5105cancelTimer(VoltageScheduler);

5106canceltimer(TimerCount);

5107fileClose (glbHandle);

5108}

X10_Tester.can

of 128

5109}

51105111

ReportError(int AltLoad,float Volt,int hh,int mm,int ss)

5112{

5113if ( glbHandle!=0 )

5114{

5115snprintf (buffer,elcount(buffer),"

*********************************\n");

5116filePutString (buffer, elcount(buffer),glbHandle);

5117snprintf (buffer,elcount(buffer),"ERROR - BSS_Value: %ld,

Voltage: %.2f V, Time: %ld:%ld:%ld\n",AltLoad,Volt,hh,mm,ss);


5119}

5120else write ("File 'ErrorReport_BSS_Test.txt' was not opened for

write access.");

5121}

51225123

Check_Traceability ()

5124{

5125char tmp[255];

51265127

if((getValue(ID_Sw1_R)==SwNum2)&&(getValue(ID_Sw2_R)==SwNum1))

5128{

5129CheckingSwNum=1;

5130}

5131else{CheckingSwNum=2;}

51325133

if((getValue(ID_Release1_R)==EdNum2)&&(getValue(ID_Release2_R)==EdNum1))

5134{

5135CheckingEditNum=1;

5136}

5137else{CheckingEditNum=2;}

51385139

if((CheckingSwNum == 1)&&(CheckingEditNum == 1)) //Software &Hardware Test OK

5140{

5141AT_Play(); //Start auto_test

5142}

5143else

5144{

5145/*Report Error on screen AT_Message*/

5146snprintf(tmp, elcount(tmp), "%s", "Software Version not Correct"

);

5147putValue(AT_Message, tmp);

5148}

5149}

51505151

LoadSystemIdent ()

5152{

5153int aux;

51545155

strncpy(fileUsed,"Traceability.sid",32);

51565157

aux=0;

5158aux=getProfileInt("Traceability","Soft_Num",0,fileUsed);

5159SwNum1=(aux & 0xFF);

X10_Tester.can

of 128

5160SwNum2=(((aux)>>8) & 0xFF);

51615162

aux=getProfileInt("Traceability","Edit_Num",0,fileUsed);

5163EdNum1=(aux & 0xFF);

5164EdNum2=(((aux)>>8) & 0xFF);

5165}

51665167

AT_Play ()

5168{







5175AT_OneStep = 0;

5176Auto_Test = 1;


5178}

51795180

on envVar VAR036

5181{


5183{

5184putValue(EStartingMode_BCM_R_,3);

5185}

5186else if(getValue(this)==0)

5187{

5188putValue(EStartingMode_BCM_R_,0);

5189}

5190}

51915192

on envVar VAR_FastGoToSleep

5193{


5195{


5197}

5198}

51995200

on envVar VAR_WakeUp

5201{


5203{


5205}

5206}

52075208

on envVar Apply_Param

5209{


5211{



5214putValue(WriteResult,0);

52155216

gTxDataBuffer[0]=0x3B;

X10_Tester.can

of 128


5218gTxDataBuffer[2]=getValue(Param_A);

5219gTxDataBuffer[3]=getValue(Param_B1);

5220gTxDataBuffer[4]=getValue(Param_B2);

5221gTxDataBuffer[5]=getValue(Param_C);

5222txArraySize=6;

52235224


5225}

5226}

52275228

on envVar AC_Variant

5229{

5230switch(getValue(this))

5231{

5232case 1:

5233//Gold AC Valve

5234putValue(Param_A, 10);

5235putValue(Param_B1, 73);


5237putValue(Param_C, 100); //99.7138

5238break;

52395240

case 2:

5241//Silver AC Valve




5245putValue(Param_C, 115); //114.838

5246break;

52475248

case 3:

5249//Black AC Valve




5253putValue(Param_C, 75); //75.45

5254break;

52555256

default:

5257//No AC Valve




5261putValue(Param_C, 0);

5262break;

5263}

5264}

52655266

on envVar Read_AC

5267{


5269{



52725273


X10_Tester.can

of 128


5275txArraySize=2;

52765277


5278}

5279}

52805281

on envVar Start_AC_Valve_Test

5282{

5283if(getValue(this) == 1)

5284{



52875288

putValue(WriteResult,0);

5289up=1;

5290ACV_T=1;

52915292

if(getValue(Choose_Method)==0)

5293{

5294AC_Valve_DC=getValue(AC_DutyC);

5295Offset=getValue(AC_Offset);

5296}

5297else if(getValue(Choose_Method)==1)

5298{

5299AC_Valve_DC=getValue(Initialcurr);

5300Offset=getValue(StepCurrent);

53015302

putvalue(EMinimumVoltagebyAC_, 1);

5303putvalue(EAC_StopAutoForbidden_, 1);

5304putvalue(EPumpActivationRequest_, 1);

5305putvalue(EACCompClutchRequest_, 1);

5306putvalue(EACCompWorkingMode_, 1);

5307putvalue(EFrontDefrostRequest_, 1);

5308putValue(EACCompClutchActivation_,1);

5309}

53105311

TestingTime=(getValue(Time_Test));

53125313

glbHandle = OpenFileWrite ("Values_ACValve_Test.txt",0);

53145315

//Ignition ON

5316// putValue(VAR046,0);

5317putValue(VAR045,1);

5318settimer(ReadT,200);

5319setTimer(Test_Time,TestingTime);

5320setTimer(timeT,1);

5321}

5322}

53235324

on timer timeT //comptador de temps

5325{

5326ms++;

5327if(ms>999)

5328{

5329s++;

5330ms=0;

X10_Tester.can

of 128

5331}

5332if(s>59)

5333{

5334s=0;

5335m++;

5336}

5337putValue(min,m);

5338putValue(sec,s);

5339setTimer(timeT,1);

5340}

53415342

on timer Test_Time

5343{

5344cancelTimer(ReadT);

5345cancelTimer(Watchdog);

53465347

if(up==1)

5348{

5349AC_Valve_DC = AC_Valve_DC + Offset;

5350}

5351else if(up==0)

5352{

5353AC_Valve_DC = AC_Valve_DC - Offset;

5354}

53555356

if(getValue(Choose_Method)==0)

5357{

5358//*********************

5359//putValue(VAR054,AC_Valve_DC);



5362gTxDataBuffer[2]=0xfb;


5364gTxDataBuffer[4]=(AC_Valve_DC*2);

53655366

txArraySize = 5;

53675368


5369//***************************

5370}

5371else if(getValue(Choose_Method)==1)

5372{

5373putValue(EACCompValveRequest_,AC_Valve_DC);

5374}

53755376

if(AC_Valve_DC==100)

5377{

5378up=0;

5379}

5380else if(AC_Valve_DC==0)

5381{

5382up=1;

5383}

5384setTimer(Test_Time,TestingTime);


5386setTimer(StopRT,((TestingTime*1000)-100));

5387settimer(Watchdog,((TestingTime*1000)-500));

X10_Tester.can

of 128

5388write("dc: %d",AC_Valve_DC);

5389}

53905391

on envVar StopACValveTest

5392{

5393if(getValue(this) == 1)

5394{



53975398

ACV_T=0;

5399cancelTimer(Test_Time);

5400cancelTimer(timeT);

54015402

//Ignition OFF




5406fileClose (glbHandle);

54075408

putValue(EACCompValveRequest_,0);

54095410

putvalue(EMinimumVoltagebyAC_, 0);

5411putvalue(EAC_StopAutoForbidden_, 0);

5412putvalue(EPumpActivationRequest_, 0);

5413putvalue(EACCompClutchRequest_, 0);

5414putvalue(EACCompWorkingMode_, 0);

5415putvalue(EFrontDefrostRequest_, 0);

5416putValue(EACCompClutchActivation_,0);

5417}

5418}

54195420

on timer ReadT

5421{

5422SendReadDataById(0x02);


5424}

54255426

ReportAC(int min,int sec,int ms,int ACV_Value,int ACV_Diag)

5427{

5428if ( glbHandle!=0 )

5429{

5430//snprintf (buffer,elcount(buffer),"

*********************************\n");

5431//filePutString (buffer, elcount(buffer),glbHandle);

5432snprintf (buffer,elcount(buffer),"Time: %ld:%ld:%ld; %ld; %ld\n"

,min,sec,ms,ACV_Value,ACV_Diag);


5434}

5435else write ("File 'Values_ACValve_Test.txt' was not opened for

write access.");

5436}

54375438

on timer StopRT

5439{

5440cancelTimer(ReadT);

5441}

X10_Tester.can

of 128

54425443

on timer t_ControlLighting

5444{

5445switch(CL_x)

5446{

5447case 1:

5448//IGNITION ON

5449putValue(EStartingMode_BCM_R_,2); //L1,L2,L3 (USM2010)

5450//putValue(EnvStartingMode_BCM_,2); //L4 (X61)

5451CL_x=2;


5453break;

54545455

case 2:

5456//Lights ON

5457//putValue(EnvFrontFogLightsRequest_,1); //High Beam

5458putValue(EFrontFogLightsRequest_,1);

5459//putValue(EnvLowBeamRequest_UCH__,1); //Low Beam

5460putValue(ELowBeamRequest_,1);

5461CL_x=3;


5463break;

54645465

case 3:

5466//Enable SPI Test


5468gTxDataBuffer[1]=0x9F;

5469txArraySize = 6;


5471break;

54725473

case 4:

5474//Begins of SPI Test

5475SPI_Check=1;







5482//settimer(t_ReadFeedbacks,200);

5483break;

54845485

case 5:

5486//End of SPI Test

5487//putValue(VAR_RefreshDiags,0);

5488canceltimer(t_ReadFeedbacks);

5489SPI_Check=0;







5496//Lights OFF

5497//putValue(EnvFrontFogLightsRequest_,0); //High Beam

5498putValue(EFrontFogLightsRequest_,0);

X10_Tester.can

of 128

5499//putValue(EnvLowBeamRequest_UCH__,0); //Low Beam

5500putValue(ELowBeamRequest_,0);

5501//IGNITION OFF

5502putValue(EStartingMode_BCM_R_,0); //L1,L2,L3 (USM2010)

5503//putValue(EnvStartingMode_BCM_,0); //L4 (X61)

5504CL_x=6;


5506break;

55075508

case 6:

5509putValue(SwReset,1);

5510break;

5511}

5512}

55135514

on envVar Control_Lighting_Test

5515{


5517{



5520CL_x=1;


5522}

5523}

55245525

on timer t_ReadFeedbacks

5526{

5527SendReadDataById(0x02);

5528settimer(t_ReadFeedbacks,30);

5529}

55305531

on envVar Run_DO_0_IOcab

5532{


5534{

5535T_On = getValue(Ton);

5536T_Off = getValue(Toff);

5537putValue(RemainCycles,getValue(Num_Cicles));

5538iter=1;

5539settimer(t_PulseGenerator,100);

5540}

5541else if(getValue(this)==0)

5542{

5543iter=10;

5544canceltimer(t_PulseGenerator);

5545}

5546}

55475548

on timer t_PulseGenerator

5549{

5550switch(iter)

5551{

5552case 1:

5553ciclesCount++;

5554if(ciclesCount>getValue(Num_Cicles))

5555{

X10_Tester.can

of 128

5556putValue(Run_DO_0_IOcab,0);

5557}

5558else

5559{

5560putValue(DO_0_IOcab,1);

5561iter=2;

5562settimer(t_PulseGenerator,T_On);

5563}

5564break;

55655566

case 2:

5567putValue(DO_0_IOcab,0);

5568iter=1;

5569settimer(t_PulseGenerator,T_Off);

5570putValue(RemainCycles,getValue(RemainCycles)-1);

5571break;

5572}

5573}

55745575

on envVar VAR_Variant

5576{

5577long i;

5578char varname[100];

5579long colourY;

5580long colourN;

5581long colourM;

55825583

colourY = makeRGB(255,255,255);

5584colourN = makeRGB(255,100,100);

55855586

switch(getValue(this))

5587{

5588case 0: // L0

5589{


5591{

5592if(i<10) snprintf(varname,elcount(varname), "STR00%d", i

);

5593else if(i<100) snprintf(varname,elcount(varname), "STR0

%d", i);

5594else snprintf(varname,elcount(varname), "STR%d", i);

55955596

if(VARIANT_L0[i] == 0) // Yes

5597setControlBackColor("X10 Functionality", varname,

colourY);

5598else if(VARIANT_L0[i] == 1) // No

5599setControlBackColor("X10 Functionality", varname,

colourN);

5600}

5601putValue(AT_File, "USM2010_L0.csv");

5602snprintf(variant, elcount(variant), "%s", "L0");

5603break;

5604}

56055606

default: //None

5607{


X10_Tester.can

of 128

5609{

5610if(i<10) snprintf(varname,elcount(varname), "STR00%d", i

);

5611else if(i<100) snprintf(varname,elcount(varname), "STR0

%d", i);

5612else snprintf(varname,elcount(varname), "STR%d", i);

56135614

setControlBackColor("X10 Functionality", varname,colourY);

5615}

5616putValue(AT_File, "None");

5617break;

5618}

5619}

5620}

56215622

BYTE AT_CheckVariant (long index)

5623{

5624// Checks if a signal is present in a variant

5625BYTE variant;

5626BYTE isOK;

56275628

variant = getValue(VAR_Variant);

5629isOK = 1;

5630if(variant == 0 & VARIANT_L0[index] != 0) isOK = 0;

56315632

return isOK;

5633}

56345635

on envVar EMV_Frequenz

5636{

56375638

if(getValue(this)) PutValue(StateCycle,1);

56395640

putValue(EMV_Frequenz_aux,getValue(EMV_Frequenz)/1000000);

5641controlSimulador=1;

56425643

}

56445645

on envVar EMV_Test_Start

5646{

56475648

if(getValue(this))

5649{

5650//Delay(2);

5651startaux=1;

5652}

5653}

56545655

on envVar EMV_Test_Stop

5656{

56575658

SetTimer(DelayStop,100);

5659//AT_Scheduler();

5660Delay(6);

56615662

}

X10_Tester.can

of 128

56635664

Delay (int timeD)

5665{

5666long i;

56675668

for(i=0; i<timeD*1e8; ++i)

5669{

56705671

}

567256735674

}

56755676

on timer tflagA

5677{

56785679

senueloA=1;

56805681

}

56825683

on timer DelayStop

5684{

56855686

switch(indexStop)

5687{

5688case 0:

5689{

5690startaux=0;

5691putValue(AT_Play,0);

5692indexStop=1;

5693setTimer(DelayStop,1000);

5694break;

5695}

5696case 1:

5697{


56995700

indexStop=2;


5702break;

5703}

5704case 2:

5705{

5706if (getValue(CYCLING_MODE)) putValue(CYCLING_XML,1);

5707indexStop=3;


5709break;

5710}

571157125713

case 3:

5714{

5715putValue(VAR_ALL_OFF,1);


5717//break;

5718}

5719

X10_Tester.can

of 128

57205721

}

5722}

57235724

CreateXMLCycling()

5725{

5726long i, j, z;

5727long tm[9];


5729char timebuffer[255];

5730char buffer[255];

5731char fileNameAT[255]="ImmunityCycle";

5732char fileFormatAT[255]=".xml";

573357345735

getLocalTime(tm);

5736573757385739

ltoa(tm[3],timebuffer,10);

5740strncat(fileNameAT,timebuffer,MAX_VAR_LENGTH);

5741strncat(fileNameAT,"_",MAX_VAR_LENGTH);

57425743

ltoa((tm[4]+1),timebuffer,10);



57465747

ltoa((tm[5]+1900),timebuffer,10);



57505751




5754//write("1%s",fileNameAT);

57555756





57605761



5763strncat(fileNameAT,fileFormatAT,MAX_VAR_LENGTH);


57655766

glbHandle = OpenFileWrite (fileNameAT,0);

57675768

if ( glbHandle!=0 )

5769{

577057715772

snprintf (buffer,elcount(buffer),"<?xml version='1.0'encoding='UTF-8'?>\n");


57745775

snprintf (buffer,elcount(buffer),"<?xml-stylesheet type='

X10_Tester.can

of 128

text/xsl' href='ImmunityCycle.xsl'?>\n");


57775778

snprintf (buffer,elcount(buffer),"<ImmunityCycle>");


57805781

snprintf (buffer,elcount(buffer),"\n\t<header>\n\t<test-title>Lab Technician</test-title>\n\t<test-date>%d/%d/%d %d:%d:%d</test-date>\n\t<test-project>USM2010_Functional_Panel v9.4</test-project>\n</header>",(tm[3]),(tm[4]+1),(tm[5]+1900), tm[2],tm[1],tm[0]);


57835784578557865787

for (i=0;i<=getValue(Ciclat);i++)

5788{

57895790

for (j=0;j<=getValue(AT_STEPS);j++)

5791{

57925793

for (z=0;z<getValue(AT_NVARS);z++)

5794{

5795if (ErrorImm[i][j][z].Error)

5796{

57975798

if (ErrorImm[i][j][z].State== getValue(AT_STEPS) || z==144)

5799{

58005801

snprintf (buffer,elcount(buffer),"\n\t<error>");

5802filePutString (buffer, elcount(buffer),

glbHandle);

58035804

snprintf (buffer,elcount(buffer),"\n\t\t<frequency> %f </frequency>",ErrorImm[i][j][z].Frequenz);


glbHandle);

58065807

snprintf (buffer,elcount(buffer),"\n\t\t<Cycle> %d </Cycle>", ErrorImm[i][j][z].Ciclat);


glbHandle);

58095810

snprintf (buffer,elcount(buffer),"\n\t\t<State> %d </State>",ErrorImm[i][j][z].State);


glbHandle);

58125813

snprintf (buffer,elcount(buffer),"\n\t\t<Name> %s </Name>",ErrorImm[i][j][z].Names);


glbHandle);

581558165817

snprintf (buffer,elcount(buffer),"\n

X10_Tester.can

of 128

\t\t<Min> %f </Min>",ErrorImm[i][j][z].minVal);


glbHandle);

58195820

snprintf (buffer,elcount(buffer),"\n\t\t<Max> %f </Max>",ErrorImm[i][j][z].maxVal);


glbHandle);

58225823

snprintf (buffer,elcount(buffer),"\n\t\t<Value> %f </Value>",ErrorImm[i][j][z].VALUE);


glbHandle);

58255826582758285829

if(ErrorImm[i][j][z].ImmunityField<= ErrorImm[i][j][z].Threshold)

5830{

5831snprintf (buffer,elcount(buffer),"\n

\t\t<immunityfield> %f </immunityfield>",ErrorImm[i][j][z].Threshold);


glbHandle);

58335834

snprintf (buffer,elcount(buffer),"\n\t\t<Threshold> %f </Threshold>",ErrorImm[i][j][z].Threshold);

5835filePutString (buffer, elcount(

buffer),glbHandle);

58365837

}

58385839

else

5840{

5841snprintf (buffer,elcount(buffer),"\n

\t\t<immunityfield> %f </immunityfield>",ErrorImm[i][j][z].ImmunityField);


glbHandle);

58435844

snprintf (buffer,elcount(buffer),"\n\t\t<Threshold> %f </Threshold>",ErrorImm[i][j][z].Threshold);

5845filePutString (buffer, elcount(

buffer),glbHandle);

5846}

58475848

snprintf (buffer,elcount(buffer),"\n\t</error>");

5849filePutString (buffer, elcount(buffer),glbHandle

);

58505851

}

58525853585458555856

}

X10_Tester.can

of 128

58575858

}

5859}

5860}

586158625863

snprintf (buffer,elcount(buffer),"\n</ImmunityCycle>\n");


58655866

FileClose(glbHandle);

5867strncpy(fileNameAT,"ImmunityCycle",MAX_VAR_LENGTH);

5868586958705871

}

587258735874587558765877587858795880

}

58815882

on timer DelayCalibration

5883{

58845885

char fileNameAT[255];


58875888

switch(indexDelay)

5889{

5890case 0:

5891{

58925893

putValue(VAR_Start,1);

5894indexDelay=1;


5896break;

5897}

58985899

case 1:

5900{

59015902

putValue(AT_Continous,1);

5903indexDelay=2;


5905break;

5906}

590759085909591059115912

case 2:

5913{

X10_Tester.can

of 128

59145915

if(getValueSize(AT_File)>1)

5916{

5917//SetControlColors ("EMC32","DisplayFile", MakeRGB(255,

255,255), MakeRGB(0,255,0));

5918//putValueToControl("EMC32","DisplayFile"," File is

loaded");

5919putValue(AT_Load,1);

5920indexDelay=3;


5922break;

5923}

59245925

else

5926{

5927indexDelay=2;


5929break;

5930}

593159325933

}

5934case 3:

5935{

59365937

//putValue(AT_Load,1);

59385939

if(getValue(AT_NVARS)>0 && getValue(AT_STEPS)>0)

5940{

5941SetControlColors ("EMC32","DisplayFile", MakeRGB(255,

255,255), MakeRGB(0,255,0));

5942putValueToControl("EMC32","DisplayFile"," File is loaded

");

5943indexDelay=4;


5945break;

5946}

59475948

else

5949{

5950SetControlColors ("EMC32","DisplayFile", MakeRGB(255,

255,255), MakeRGB(255,0,0));

5951putValueToControl("EMC32","DisplayFile"," Incorrect File

");

5952indexDelay=2;


5954break;

59555956

}

595759585959

}

5960case 4:

5961{


5963break;

5964}

X10_Tester.can

of 128

5965}

59665967

}

59685969

on busOff

5970{

5971putValue(CAN_STATE_LED,2);

5972/*putValue(CAN_State_Green,0);

5973putValue(CAN_State_Red,1);*/

5974}

59755976

on errorActive

5977{

59785979

putValue(CAN_STATE_LED,1);

5980putValue(CANSTATE,0);

5981arrayError[144][0] = arrayError[144][1];

5982arrayError[144][1] = getValue(CANSTATE);

5983VALUES[144]=0;

59845985

// Show the error features to panell canoe.

59865987

if(getValue(CYCLING_MODE))

5988{

59895990

if((arrayError[144][1] < arrayError[144][0]) && getValue(Ciclat)>1)

5991{

59925993

write("recuperem la comunicació");


59955996

ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Ciclat=getValue(Ciclat);

5997ErrorImm[getValue(Ciclat)][getValue(STATE)][144].State=

getValue(STATE);

5998strncpy(ErrorImm[getValue(Ciclat)][getValue(STATE)][144].

Names,AT_NAMES[144],MAX_VAR_LENGTH);

5999ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Frequenz=

getValue(EMV_Frequenz_aux);

6000ErrorImm[getValue(Ciclat)][getValue(STATE)][144].

ImmunityField= getValue(EMV_Feld);

6001ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Threshold

=getValue(Threshold);

6002ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Error= 1;

60036004

SetControlColors ("EMC32","Display", MakeRGB(255,255,255),MakeRGB(0,0,0));

6005putValueToControl("EMC32","Display","\nCycle: ");

6006putValueToControl("EMC32","Display",getValue(Ciclat),0);

6007putValueToControl("EMC32","Display"," State: ");

6008putValueToControl("EMC32","Display",getValue(STATE),0);

6009putValueToControl("EMC32","Display","\nNAME: ");

6010putValueToControl("EMC32","Display",AT_NAMES[144]);

6011putValueToControl("EMC32","Display","\nFrequency: ");

6012putValueToControl("EMC32","Display",getValue(

EMV_Frequenz_aux),0);

X10_Tester.can

of 128

6013putValueToControl("EMC32","Display"," MHz");

6014putValueToControl("EMC32","Display","\nImmunity Field: ");

6015putValueToControl("EMC32","Display",getValue(EMV_Feld),0);

6016putValueToControl("EMC32","Display"," V/m");

6017putValueToControl("EMC32","Display","\

n ");

60186019

}

6020}

6021}

60226023

on errorPassive

6024{


6026putValue(CANSTATE,1);

6027arrayError[144][0] = arrayError[144][1];

6028arrayError[144][1] = getValue(CANSTATE);

6029VALUES[144]=1;

60306031603260336034

}

60356036

ImmunityCycle (int i ,WORD AT_Step)

6037{

60386039

WORD minVal, maxVal;

6040long j;

604160426043

//Initialitze New Step;

6044if (AT_Step==0) AT_VALUES[i][getValue(AT_STEPS)]= AT_VALUES[i][

AT_Step];

6045604660476048

// Detection error signal flag

6049arrayError[i][0] = arrayError[i][1];

6050arrayError[i][1] = eflag[i];

60516052

// Display the checksum of monitorization signals

6053mEMC.EMC1=errorCounter;

6054output(mEMC);

605560566057


6058if(AT_VALUES[i][AT_Step] < AT_TOLERANCE[i]) minVal = 0;

6059else minVal = AT_VALUES[i][AT_Step] - AT_TOLERANCE[i];


60616062

if ((AT_VALIDATION_RESULTS[i][AT_Step] == 3))

6063{

6064findID(i,ErrorImm[0][0][i].Varid,AT_Step);

6065}

60666067

X10_Tester.can

of 128

60686069

// This function just detect when a failure occurs butnot when it dissapear.

6070if(( getValue(STATE)<(getValue(AT_STEPS))) && (

AT_VALIDATION_RESULTS[i][AT_Step] == 3))

6071{

607260736074

ErrorImm[getValue(Ciclat)][getValue(STATE)][i].Error= 0;

6075}

607660776078

//In case the failure don't disappear when the immunityfield down.

6079//ArrayError 0 and 1, just show the signals with

contain an error.

60806081

if ((getValue(EMV_Feld)<getValue(Threshold)) && (arrayError[i][1] == 1) && (arrayError[i][0] == 1))

6082{

60836084

ErrorImm[getValue(Ciclat)][getValue(STATE)][i].Ciclat= getValue(Ciclat);

6085ErrorImm[getValue(Ciclat)][getValue(STATE)][i].

State= getValue(STATE);


minVal= minVal;


maxVal= maxVal;


VALUE= VALUES[i];

6089strncpy(ErrorImm[getValue(Ciclat)][getValue(

STATE)][i].Names,AT_NAMES[i],MAX_VAR_LENGTH);


Frequenz= getValue(EMV_Frequenz_aux);


ImmunityField= getValue(Threshold);


Threshold=getValue(Threshold);


Error= 1;

60946095

if(getValue(STATE)==(getValue(AT_STEPS)))

6096{

60976098

SetControlColors ("EMC32","Display", MakeRGB(255,255,255), MakeRGB(0,0,0));



Ciclat),0);

6101putValueToControl("EMC32","Display","

State: ");


STATE),0);


6104putValueToControl("EMC32","Display",AT_NAMES[i]);

6105putValueToControl("EMC32","Display","\nmin: ");

X10_Tester.can

of 128

6106putValueToControl("EMC32","Display",minVal,0);

6107putValueToControl("EMC32","Display"," max: ");

6108putValueToControl("EMC32","Display",maxVal,0);

6109putValueToControl("EMC32","Display"," Value: ");

6110putValueToControl("EMC32","Display",VALUES[i],0);

6111putValueToControl("EMC32","Display","\nFrequency

: ");


EMV_Frequenz_aux),0);


6114putValueToControl("EMC32","Display","\nThe

failure remains below ");

6115SetControlColors ("EMC32","Display", MakeRGB(

255,255,255), MakeRGB(255,0,0));

6116putValueToControl("EMC32","Display",ErrorImm[

getValue(Ciclat)][getValue(STATE)][i].Threshold,0);

6117SetControlColors ("EMC32","Display", MakeRGB(

255,255,255), MakeRGB(0,0,0));



n ");

6120errorCounter=0;



61236124

}

61256126

}

61276128

// provoquem un flag de baixada (un error desapareixquan baixem el camp)

6129if(i ==144)

6130{

6131if (senueloC)

6132{


6134write("tflag ha sigut executat, %s", AT_NAMES[i]);

61356136

}

6137}

61386139

if(i ==80)

6140{

6141if (senueloA)

6142{


6144write("tflag ha sigut executat, %s", AT_NAMES[i]);

61456146

}

6147}

61486149

if(i ==76)

6150{

61516152

if (senueloB)

6153{


X10_Tester.can

of 128

6155write("tflag B ha sigut executat, %s", AT_NAMES[i]);

6156}

6157}

61586159

if (controlSimulador)

6160{

6161senueloA=0;

6162senueloB=0;

6163controlSimulador=0;

6164}

616561666167

// flag down when a failure disappears.

61686169

if (arrayError[i][1] < arrayError[i][0])

6170{

61716172

ErrorImm[getValue(Ciclat)][getValue(STATE)][i].Ciclat= getValue(Ciclat);


State= getValue(STATE);


minVal= minVal;


maxVal= maxVal;


VALUE= VALUES[i];

6177strncpy(ErrorImm[getValue(Ciclat)][getValue(



Frequenz= getValue(EMV_Frequenz_aux);


ImmunityField= getValue(EMV_Feld);


Threshold=getValue(Threshold);


Error= 1;

61826183

if(getValue(STATE)==(getValue(AT_STEPS)))

6184{

61856186

SetControlColors ("EMC32","Display",MakeRGB(255,255,255), MakeRGB(0,0,0));


nCycle: ");

6188putValueToControl("EMC32","Display",

getValue(Ciclat),0);


" State: ");


getValue(STATE),0);


nNAME: ");


AT_NAMES[i]);


nFrequency: ");

X10_Tester.can

of 128


getValue(EMV_Frequenz_aux),0);

6195putValueToControl("EMC32","Display","

MHz");


nImmunity Field: ");


getValue(EMV_Feld),0);

6198putValueToControl("EMC32","Display"," V/

m");


n ");

62006201

arrayError[i][0]=0;


62036204

write("Step %d",getValue(AT_Step));

62056206

if (errorCounter>0) errorCounter--;

6207}

62086209

}

62106211

// flag up when a new failure occurs

6212if ((arrayError[i][1] > arrayError[i][0]))

6213{



62166217

if (getValue(STATE)==(getValue(AT_STEPS)))

6218{



6221errorCounter++;

6222}

62236224

}

62256226

if (getValue(STATE)==(getValue(AT_STEPS)) && (getValue(EMV_Feld)==ErrorImm[getValue(Ciclat)][getValue(STATE)][i].Threshold))

6227{

6228errorCounter=0;

6229}

62306231

}

62326233

on key 'a'

6234{

62356236

settimer(tflagA,750);

62376238

}

62396240

// Find the ID correspond to PO -> AD, AI

6241// Find the ID correspond to DO -> DD

6242

X10_Tester.can

of 128

6243FindID (long index,long varIDaux, word AT_Step)

6244{

62456246

long i;

6247long IDfound;

62486249

IDfound=0;

62506251

for (i=0; i<getValue(AT_NVARS); i++)

6252{

62536254

if(TYPES[i] == 2 || TYPES[i] == 3) ///2: DO, 3: PO

6255{

6256if(varIDaux == ErrorImm[0][0][i].Varid)

6257{

6258//AT_VALIDATION_RESULTS[index][AT_Step] = 3;

6259AT_VALUES[i][getValue(AT_STEPS)]= AT_VALUES[i][AT_Step];

6260IDfound=1;

6261}

6262}

62636264

}

6265626662676268

if(TYPES[index] == 4 || TYPES[index] == 5) ///4: AD, 5: DD

6269{

6270;

6271if (!IDfound) AT_VALUES[index][getValue(AT_STEPS)]=

AT_VALUES[index][AT_Step];

6272}

62736274

AT_VALIDATION_RESULTS[index][AT_Step] = 3;

6275627662776278

}

62796280

on key 'b'

6281{

6282settimer(tflagB,750);

6283}

62846285

on timer tflagB

6286{

62876288

senueloB=1;

6289629062916292

}

62936294

Calibration (int i ,WORD AT_Step)

6295{

62966297

WORD minVal, maxVal;

6298

X10_Tester.can

of 128

62996300

// Detection Flag

6301arrayError[i][0] = arrayError[i][1];

6302arrayError[i][1] = eflag[i];

630363046305


6306if(AT_VALUES[i][AT_Step] < AT_TOLERANCE[i]) minVal = 0;

6307else minVal = AT_VALUES[i][AT_Step] - AT_TOLERANCE[i];


630963106311631263136314

// This function just detect when a failure occurs butnot when it dissapear.

63156316

if(( getValue(STATE)<(getValue(AT_STEPS))) && (AT_VALIDATION_RESULTS[i][AT_Step] == 3))

6317{

63186319

ErrorCalib[getValue(Ciclat)][getValue(STATE)][i].Ciclat= getValue(Ciclat);

6320ErrorCalib[getValue(Ciclat)][getValue(STATE)][i]

.State= getValue(STATE);


.minVal= minVal;


.maxVal= maxVal;


.VALUE= VALUES[i];

6324strncpy(ErrorCalib[getValue(Ciclat)][getValue(



.Error= 1;

632663276328

SetControlColors ("EMC32","DisplayCalib",MakeRGB(255,255,255), MakeRGB(0,0,0));

6329putValueToControl("EMC32","DisplayCalib","\

nCycle: ");

6330putValueToControl("EMC32","DisplayCalib",

getValue(Ciclat),0);


" State: ");


getValue(STATE),0);

6333putValueToControl("EMC32","DisplayCalib","\nNAME

: ");


AT_NAMES[i]);

6335putValueToControl("EMC32","DisplayCalib","\nmin

: ");

6336putValueToControl("EMC32","DisplayCalib",minVal,

0);

6337putValueToControl("EMC32","DisplayCalib"," max:

X10_Tester.can

of 128

");

6338putValueToControl("EMC32","DisplayCalib",maxVal,

0);

6339putValueToControl("EMC32","DisplayCalib"," Value

: ");

6340putValueToControl("EMC32","DisplayCalib",VALUES[

i],0);

6341putValueToControl("EMC32","DisplayCalib","\

n ");

634263436344634563466347

}

6348}

63496350

CreateXMLCalibration()

6351{

6352long i, j, z;

6353long tm[9];



635663576358

glbHandle = OpenFileWrite ("Calibration.xml",0);

63596360

if ( glbHandle!=0 )

6361{

63626363

getLocalTime(tm);

6364snprintf (buffer,elcount(buffer),"<?xml version='1.0'

encoding='UTF-8'?>\n");


63666367

snprintf (buffer,elcount(buffer),"<?xml-stylesheet type='text/xsl' href='Calibration.xsl'?>\n");


63696370

snprintf (buffer,elcount(buffer),"<ImmunityCycle>");


63726373

snprintf (buffer,elcount(buffer),"\n\t<header>\n\t<test-title>Lab Technician</test-title>\n\t<test-date>%d/%d/%d %d:%d:%d</test-date>\n\t<test-project>USM2010_Functional_Panel v9.4</test-project>\n</header>",(tm[3]),(tm[4]+1),(tm[5]+1900), tm[2],tm[1],tm[0]);


637563766377

for (i=0;i<=getValue(Ciclat);i++)

6378{

63796380

for (j=0;j<=getValue(AT_STEPS);j++)

6381{

63826383

for (z=0;z<getValue(AT_NVARS);z++)

6384{

X10_Tester.can

of 128

63856386

if (ErrorCalib[i][j][z].Error)

6387{

638863896390

snprintf (buffer,elcount(buffer),"\n\t<error>");


glbHandle);

63926393

snprintf (buffer,elcount(buffer),"\n\t\t<frequency> %f </frequency>",ErrorCalib[i][j][z].Frequenz);


glbHandle);

63956396

snprintf (buffer,elcount(buffer),"\n\t\t<Cycle> %d </Cycle>", ErrorCalib[i][j][z].Ciclat);


glbHandle);

63986399

snprintf (buffer,elcount(buffer),"\n\t\t<State> %d </State>",ErrorCalib[i][j][z].State);


glbHandle);

64016402

snprintf (buffer,elcount(buffer),"\n\t\t<Name> %s </Name>",ErrorCalib[i][j][z].Names);


glbHandle);

640464056406

snprintf (buffer,elcount(buffer),"\n\t\t<Min> %f </Min>",ErrorCalib[i][j][z].minVal);


glbHandle);

64086409

snprintf (buffer,elcount(buffer),"\n\t\t<Max> %f </Max>",ErrorCalib[i][j][z].maxVal);


glbHandle);

64116412

snprintf (buffer,elcount(buffer),"\n\t\t<Value> %f </Value>",ErrorCalib[i][j][z].VALUE);


glbHandle);

641464156416

snprintf (buffer,elcount(buffer),"\n\t</error>");


glbHandle);

641864196420

}

64216422

}

6423}

X10_Tester.can

of 128

6424}

642564266427

snprintf (buffer,elcount(buffer),"\n</ImmunityCycle>\n");


64296430

FileClose(glbHandle);

6431643264336434

}

643564366437643864396440644164426443

}

64446445

// CYCLING mode.

6446on envVar CYCLING_MODE

6447{


6449{

6450//Set the default background and text color for a specific control

of a panel.

6451//SetDefaultControlColors("EMC32","Display");

64526453

putValue(CALIBRATION_MODE,0);

6454putValue(Ciclat, 0);

6455putValue(STATE, 0);


6457putValue(VAR_Start,1);

6458}

64596460

}

64616462

on envVar CALIBRATION_MODE

6463{

64646465

if(getValue(this))

6466{



6469putValue(Ciclat,0);

6470putValue(CYCLING_MODE,0);

6471}

6472}

64736474

on envVar CALIBRATION_XML

6475{


6477{

6478CreateXMLCalibration();

6479}

X10_Tester.can

of 128

6480}

64816482

on envVar CYCLING_XML

6483{

6484putValue(CYCLING_XML,0);

6485CreateXMLCycling();

6486}

64876488

on key 'c'

6489{

6490settimer(tflagC,750);

6491//VALUES[144]=0;

6492}

64936494

on timer tflagC

6495{

64966497

senueloC=1;

6498649965006501

}

65026503

on envVar CANSTATE

6504{

65056506

if(getValue(this))

6507{

65086509

//write("arrayError[144][0]=%d",arrayError[144][0]);

6510//write("arrayError[144][1]=%d",arrayError[144][1]);

651165126513

/*if((arrayError[144][1] < arrayError[144][0]) && getValue(Ciclat)>1)

6514{

65156516

write("recuperem la comunicació");


65186519

ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Ciclat=getValue(Ciclat);

6520ErrorImm[getValue(Ciclat)][getValue(STATE)][144].State= getValue

(STATE);

6521strncpy(ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Names,

AT_NAMES[144],MAX_VAR_LENGTH);

6522ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Frequenz=

getValue(EMV_Frequenz_aux);

6523ErrorImm[getValue(Ciclat)][getValue(STATE)][144].ImmunityField=

getValue(EMV_Feld);

6524ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Threshold

=getValue(Threshold);

6525ErrorImm[getValue(Ciclat)][getValue(STATE)][144].Error= 1;

65266527

SetControlColors ("EMC32","Display", MakeRGB(255,255,255),MakeRGB(0,0,0));


X10_Tester.can

of 128

6529putValueToControl("EMC32","Display",getValue(Ciclat),0);

6530putValueToControl("EMC32","Display"," State: ");

6531putValueToControl("EMC32","Display",getValue(STATE),0);


6533putValueToControl("EMC32","Display",AT_NAMES[144]);

6534putValueToControl("EMC32","Display","\nFrequency: ");

6535putValueToControl("EMC32","Display",getValue(EMV_Frequenz_aux),0

);


6537putValueToControl("EMC32","Display","\nImmunity Field: ");

6538putValueToControl("EMC32","Display",getValue(EMV_Feld),0);



n ");

65416542

}*/

6543}

65446545

}

65466547

on timer FailureCAN

6548{

6549long indexCAN;

65506551

switch(indexCAN)

6552{

6553case 0:

6554{

6555putValue(VAR_Stop,1);

6556indexCAN=1;


6558break;

65596560

}

6561case 1:

6562{

6563putValue(VAR_Start,1);

6564indexCAN=2;


6566break;

65676568

}

6569case 2:

6570{

6571putValue(AT_Load,1);

6572indexCAN=3;


6574break;

65756576

}

65776578

case 3:

6579{


6581indexCAN=4;


6583break;

X10_Tester.can

of 128

6584}

65856586

case 4:

6587{


6589indexCAN=0;

6590//setTimer(FailureCAN,100);

6591write("ejecutamos todo el proceso");

6592break;

6593}

65946595

}

659665976598

}

65996600

on warningLimit

6601{


6603}

66046605

X10_Tester.can

of 128

x10 tester - · pdf filex10_tester.can page 3 of 128. 151 byte hastosendwritecolumnconfig = 0;...

Documents

Industrial Protocols User’s Guide...Industrial Protocols MODBUS/TCP MAP 1-3 Address Offset Data Type Interpretation Description Word 0 Hi byte = 0 x 00 Word 0 Lo byte = 0 x 01 Word

Networked Applications: Sockets - האקדמיתhbinsky/intro comp comm/Sockets.pdf · Four-byte long int: (byte 3, byte 2, byte 1, byte 0) vs. (byte 0, byte 1, byte 2, byte 3) String

Solution: Electricity: 1 kw-hr = (1 x10 3 J/s)(3.6 x10 3 s) = 3.6 x10 6 J 1 kw-hr = (1 x10 3 J/s)(3.6 x10 3 s) = 3.6 x10 6 J E/$ = 3.6 x10 6 /$0.1 = 3.6

x10 x10 x10 x10 x10 x10 - gsiccharter.com

UART WITH 16-BYTE FIFO’s - Farnell element14 WITH 16-BYTE FIFO’s ... Connect to logic 0 when using -IOR. CS0 12 14 9 I Chip Select-0. ... The UART transmitter

TECHNICAL SPECIFICATIONw...(43-byte command, structure of bytes 2~7 repeated 7 times) 0 0 0 0 1 0 0 0 0 1 21h 14 B2W LUT (LUTBW / LUTR) (43-byte command, structure of bytes 2~7 repeated

protocolo x10

Assembly Language for Intel-Based Computers, 5 Editionsite.iugaza.edu.ps/rsalamah/files/2013/02/09_StringsArrays.pdf · dest BYTE "MARTINEZ" str1 BYTE "Source is smaller",0dh,0ah,0

QUESTION 1....Byte 1 Byte 2 The location is indicated by the setting of one of the seven bits in byte 1. For example, location 4 is indicated by setting bit 4. Bit 0 of byte 1 acts

File Systems - Cornell University · maggie.txt12 0 0 0 EOF EOF 0 0 0 0 0 0 0 0 0 0 0. Folder: a file with 32-byte entries Each Entry: •8 byte name + 3 byte extension (ASCII) •creation

x10 Manual

HP PCL/PJL ReferenceSet · Specifies PCL parsing method as either 1-byte or 2-byte characters codes.? & t # P # = 0, 1 - All character codes processed as one-byte characters

Operating Systems - Virtual Memory and Page Replacement · PTE 0 PDE 1023 PTE 1 PTE #PTI Byte 0 Byte 1 PTE 1023 4 KiB Page #PML4I O set PML4E 511 Byte 4095 x86-32 • 1 access into

ATA Extensions Document - T13t13.org/Documents/UploadedDocuments/project/d1532v1r3d... · Web view7 6 5 4 3 2 1 0 Byte 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 Word Byte 1 Byte 0 31

Encoder assoluto multi-giro con protocollo CANopen, di ... · COB ID DLC Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 Byte 8 580H+Node 08H 80H Object L Object H Subindex Err.0

HANDS - tilelook.com€¦ · HAS1280 Hands Honey 12,5x25 5”x10” HAS1210 Hands White 12,5x25 5”x10” HAS1220 Hands Ivory 12,5x25 5”x10” HAS1240 Hands Pearl 12,5x25 5”x10”

New Product Bulletin - Farnell · Bit Assignment Bit 7 6 5 4 3 2 1 0 M12 Input Byte 0 4B 4A 3B 3A 2B 2A 1B 1A Byte 1 8B 8A 7B 7A 6B 6A 5B 5A M12 Output Byte 0 4B 4A 3B 3A 2B 2A 1B

09:04:41 x10 tutorial notes.txt 1 · 09:04:41 x10_tutorial_notes.txt 1 X10 Tutorial, 12.11.2010 at FAU Erlangen Christoph von Praun 0 Introduction ===== Welcome! This is a tutorial

Simulationsofwaternear hydrophilicandhydrophobicsurfacesrudi/sola/seminar-softmatter.pdf · X 2 a=1 8 e 0 4π 0r HaO + 0 4π 0r H1H2 X2 a=1 X10 i=1 e2 4π 0r Hai − (4) − X10 i=1

Manual x10

X10 Tutorial

Folio Byte by Byte 2009

W600 Datasheet - GitHub · Figure 4-1 W600 chip structure. 5 . 5 Address space division. 512M-Byte Block 0 Code 512M-Byte Block 1 SRAM 512M-Byte Block 2 Peripherals. 0X0000 0000 0X1FFF

x10 synopsis

ATA Extensions Document - T13 · Web viewIn memory byte 0 of a Word is stored in the lower byte address and byte 1 is stored in the higher byte address. On Paper: Byte 1 Byte 0 15

The Oxygen Cycle Kevin Kwong and John Solder 9.6 x10^9 kg 1.4 x10^18 kg 2.9 x10^20 kg 1.6 x10^16 kg Modified from

Submittal Package Cast Iron Service Weight System · 5” 5.94 5.30 3.00 4.94 0.18 0.15 ... 3”x10’ 59.5 4”x10’ 75.1 5”x10’ 100.4 6”x10’ 122.8 8”x10’ 180.5 10”x10’

Programming Manual (supplement) CAN module RTC CR30200x380 + node ID DLC = 6 Byte 0 = remaining time in days Byte 1 = remaining time in hours Byte 2 = Remaining time in minutes Byte

Operating manual Wireless hand wheel unit HBG 800-DP Funkhandrad HBG 800-DP_R04_E.pdf · 5 Status 1 Byte 0 - 255 6 LED’s 1-12 2 Byte (DW) 0 – 65535 7 Text line 1 12 Byte Array

Features - Silicon Labs · Features: - > 4000 bits of configurations - Can be configured through SMBus or hard coded ... (6:0) Byte offset for byte read or byte wr ite operation

Whitepaper: Introduction To ProfiBus DP - Automation.com · Web view7 6 5 4 3 2 1 0 X X X X X X X X 0=Consistency of Byte/Word. 1=Consistency Entire Length 0=Byte. ... 39 Introduction

MX25L12835F DATASHEET• Program/Erase Suspend and Resume operation • Electronic Identification - JEDEC 1-byte manufacturer ID and 2-byte device ID ... 0 1 0 1 5 (16 blocks, block

x10 Couplers

0¸0§0È0í0 UF X10 mûNØ Çe 1

Association Euratom-Cea TORE SUPRA Integration of High ... · Neutron (x10 10 /s) Zeff Ti(0) (keV) Line averaged density (x10 19 m-2) LHCD Power (MW) Transformer flux (Wb) Te(0) (keV)