main.cpp

00001 /* AXF --GLOBAL VALVE BOARD TESTER
00002 PROGRAMM CREATED BY : JAYDEEP SHAH
00003 RESEARCH & DEVLOPMENT DEPARTMENT -- KEPL
00004 DATE : 22 JULY 2020
00005 VERSION : 1.0  -- MBED OPEN VERSION FILE
00006 */
00007 
00008 /*--------------------------------------------------------------------------*/
00009 
00010 /* OUTPUT DATA AVAILABLE ON LCD SCREEN  & ON TERMINAL ALSO
00011 TERMINAL 9600 BAUD 8-N-1 T TYPE 
00012 SUGGESTED TERMINAL : COOLTERM & PUTTY
00013 If any query /problems --> contact to R&D Dept of KEPL A'bad. 
00014 Board Turn on Time : 20 to 25 Sec acfetr power
00015 */
00016 
00017 /*--------------------------------------------------------------------------*/
00018 
00019 
00020 #include "mbed.h"               //MBED LIBRARY
00021 #include "TextLCD.h"            //LCD LIBRARY
00022 
00023 
00024 /* *************************SEMAPHORE CREATION BINARY********************************* */
00025 Semaphore A(0);
00026 
00027 
00028 
00029 #define BUFFER_SIZE 90   //SIZE OF BUFFER  -- TO STORE UART DATA
00030 
00031 TextLCD lcd(PC_0, PC_1, PB_4, PB_5, PB_3, PA_10, TextLCD::LCD20x4);  //LCD OBJECT CREATION WITH PANEL SIZE
00032 
00033 
00034 
00035 
00036 //******************************************************************************  UART SECTION AND FUNCTIONS
00037 
00038 
00039 char rxBuffer[BUFFER_SIZE];  //CREATE CIRCULAR BUFFER  -- TO STORE RECEIVE DATA
00040 
00041 unsigned int bufferReadingIndex=0;  //CREATE POINTER TO READ DATA FROM UART AND STORE INTO ARRAY
00042 
00043 unsigned int i=0; //counter to read data from buffer Array
00044 RawSerial UT(PA_0,PA_1);  //UART PIN DECLARATION
00045 RawSerial pc(USBTX,USBRX);  //HOST PC TERMINAL  - 9600 BAUD WITH 8-N-1 STTING
00046 
00047 //NOTE : UT OBJ FOR SLAVE BOARD & pc OBJ FOR TERMINAL
00048 
00049 //DEFINE Rx Interrupt function --DECLARATION
00050 void RxInterrupt(void);
00051 
00052 //Function that read response data
00053 void response(void);
00054 
00055 //******************************************************************************  UART SECTION & FUNCTIONS
00056 void WELCOME_SCREEN(void);  //LCD TURN ON DETAILS / POWR ON OR RESTART TIME
00057 
00058 
00059 //void LCD_REFRESH(void);  // Thread Function -- to refresh LCD screen------------------------------------------------------TH2
00060 
00061 void START_NEW_TEST(void);  // Function that call by button press -- new test start
00062 volatile bool TEST_FLAG = 0U; //FLAG TO AVOID PUSH BUTTON EFFECT WHEN BOARD ON
00063 
00064 volatile bool PROCESS_FLAG = 0U; //PROCESS_FLAG -- DURING TESTING ITS ON = 1
00065 
00066 volatile uint8_t PCB_COUNTER = 0; //GLOBAL PCB COUNTER
00067 
00068 //float CURRENT_MEASUREMENT(void); //Thread Function current measurement function that return float value--------------------TH1
00069 
00070 float voltage = 0; //Voltage measurement functions
00071 
00072 //Create Interrupt object -- Pin -- Push button connection********************** DIGITAL I/O SECTION AND INTERRUPT
00073 InterruptIn swt(PB_2); //PUSH BUTTON CONNECTED WITH THIS PIN 
00074 
00075 //LED_BUZZER CONNECTION
00076 DigitalOut RED_LED(PB_13);  //
00077 DigitalOut BLUE_LED(PB_14);
00078 DigitalOut GREEN_LED(PB_15);
00079 DigitalOut BUZZER(PC_8);  //BUZZER CONNECT
00080 
00081 //******************************************************************************  DIGITAL I/O SECTION END
00082 
00083 //RESULT AND ERROR FUNCTIONS
00084 void result(void);
00085 void error(uint8_t);
00086 
00087 //LCD FLAG -- THIS IS FOR RETRIVE DATA FROM ARRAY
00088 volatile uint8_t LCD_FLAG = 0;
00089 
00090 //NEW_TEST_UPDATE_LCD
00091 void NEW_TEST_UPDATE_LCD();
00092 
00093 //TESTING SCHEDULE FUNCTION
00094 void TEST_PROCESS(void);
00095 
00096 //******************************* VARIABLE TO STORE ADC DATA
00097 float current = 0; //Global value
00098 float AARAY[10],SUM=0;
00099 
00100 // THREAD FUNCTIONS*************************************************************  THREAD SECTION
00101 void CURRENT(void); //TO FIND INPUT DC CURRENT
00102 void CURRENT_MEASUREMENT()
00103 {
00104     while(true)
00105     {
00106         CURRENT();  //FUNCTION CALL TO MEASURE CURRENT
00107         
00108         //Thread Yield
00109         ThisThread::sleep_for(100); //Thread sleep 
00110     }
00111     
00112 }
00113 
00114 void LCD_REFRESH()
00115 {
00116  volatile bool v =0;
00117  while(true)
00118  {
00119   v = A.try_acquire();
00120   
00121   if(v==1)
00122   {
00123   lcd.locate(0,3);
00124   lcd.printf("Current = %.2f mA",current);
00125   lcd.locate(19,3);
00126   lcd.printf(".");
00127   pc.printf("\n Input Current is = %.2f mA",current);
00128   ThisThread::sleep_for(10);   
00129  }
00130  }
00131      
00132 }
00133 //******************************************************************************  THREAD SECTION END
00134 
00135 //CREATE TWO THREAD
00136 Thread T1(osPriorityLow),T2;
00137 
00138 
00139 //******************************************************************************   ADC SECTION
00140 /*
00141 // INA-225 TEXAS INSTRUMENT BOARDS TO AMPLIFY LOW VOLTAGE SIGNAL WITH GAIN 200
00142 //SHUNT RESISTOR = 0.6 Ohm
00143 //Vref : 3.3 
00144 // I (current) = ((((ADC O/P - Offset)) * 3.3) *200 ) / 0.6) * 1000      mA
00145 CLASS --> AnalogIn
00146 Object return value between 0 to 1
00147 If 5 V system and you try to read 2.5 V from ADC PIN than OP = 0.5
00148 PLEASE NOTE : MBED USE 3.3 Vref
00149 For more information look at thread details
00150 */
00151 AnalogIn ANG(PC_3); //Port pin PC_3 last pin for ADC -- Create object
00152 
00153 
00154 /***************************************************************************
00155 UART BUFFER PROBLEMS : FLUSH ()
00156 NOTE : MBED HAVE NO SUCH TYPE OF FUNCTIONS
00157 SO YOU NEED TO CLEAR UART BUFFER BEFORE REPEAT THE PROCEDURE
00158 SIMPLE WAY IS READ THE INTERNAL UART BUFFER
00159 ***************************************************************************/
00160 //MAKE FUNCTION TO RESET BUFFER DATA AND COUNTER
00161 
00162 void BUFFER_CLEAR(void);
00163 
00164 
00165 //MAIN FUNCTIONAL AREA*************************************************************
00166 
00167 //****************FOR NEXT STAGE OF PROJECT
00168 
00169 bool NEXT = 0U;
00170 bool ERROR_FLAG = 0U;
00171 
00172 //*************************************LDR AREA LIGHT DETECTION*****************************
00173 //NOTE LDR SUPPLY BY 3.3 VOLT -- PLEASE NOTE THIS 
00174 AnalogIn LDR(PB_0);   //PB_0 is LDR sensor input 
00175 float LDR_VALUE = 0;  // TO STORE LDR DATA
00176 
00177 
00178 
00179 int main()
00180 {
00181 
00182 UT.baud(57600);  //BAUD RATE SETTING
00183 UT.format(8,Serial::None,1);   //FORMAT OF UART COMMUNICATION
00184 
00185 //INTERRUPT ATTACHMENT WHEN RECEIVE DATA --UART INTERRUPT
00186 UT.attach(&RxInterrupt,Serial::RxIrq);
00187 
00188 //PUSH BUTTON INTERRUPT FUNCTION  -- PUSH BUTTON INTERRUPT
00189 swt.rise(&TEST_PROCESS);  //THIS FUNCTION Call when push button press
00190 wait(5);
00191 pc.printf("*********************************************************************\n");
00192 pc.printf("\n STM POWER ON -- DATA INITIALIZATION \n");
00193 pc.printf("\n PROGRAM CREATED BY : R_AND_D DEPT of KEPL \n");
00194 pc.printf("\n Program Version 1.0 \n");
00195 pc.printf("\n Any changes of the program lead toward Board OS Crash or bugs");
00196 pc.printf("\n NOTE : Permission require before any Hardware /or software changes \n");
00197 pc.printf("\n RTOS TRYING TO ACCESS THREAD CODE......INITIALIZATIO OF RTOS START.....\n");
00198 pc.printf("\n");
00199 pc.printf("\n Do not press any Button\n");
00200 pc.printf("\n *******************************************************************\n");
00201 
00202 
00203 //INITIAL ALL LED OFF
00204 pc.printf("\n MAKE ALL LEDS and BUZZER OFF  \n");
00205 RED_LED = 0;
00206 GREEN_LED = 0;
00207 BLUE_LED = 0;
00208 BUZZER = 0;
00209 
00210 WELCOME_SCREEN(); //TO INITIALIZE DATA
00211 
00212 pc.printf("\n \n \n Good Luck !!!! \n");
00213 pc.printf("\n CURRENT MEASUREMENT UNIT TURNING ON...........\n");
00214 
00215 T1.start(CURRENT_MEASUREMENT);
00216 T2.start(LCD_REFRESH);
00217 
00218 pc.printf("\n All Thread create succesffully\n");
00219 wait_ms(500);
00220 pc.printf("\n NOW PLUG THE UNIT AND PRESS THE BUTTON \n");
00221 while(true)
00222 {
00223     BLUE_LED = 0;
00224     START_NEW_TEST(); //This function only work if FLAG SET
00225     wait_ms(500);
00226 
00227     BLUE_LED = 1;
00228 
00229 }
00230 
00231 }
00232 
00233 void RxInterrupt()      //if Rx buffer have data --- Interrupt call
00234 {
00235     //Because of Interrupt -- Ideally no CONTEXT SWITCH
00236     if(UT.readable())  //IF data available
00237     {
00238         rxBuffer[bufferReadingIndex++] = UT.getc();   // read and store into Buffer
00239         if(bufferReadingIndex >= BUFFER_SIZE)  // If limit cross
00240         {
00241             bufferReadingIndex =0; // RESET CONTER
00242         }
00243     }
00244 }
00245 
00246 void response()  //FUNCTION TO READ DATA
00247 {
00248     char rxByte;
00249     printf("\n");
00250 
00251 //NEED TO STOP CONTEXT SWITCH 
00252     while(i != bufferReadingIndex)  //READ WHILE COMPLETE DATA NOT RECEIVED
00253     {
00254         rxByte = rxBuffer[i];  //READ DATA ONE BY ONE CHARACTER
00255         pc.putc(rxByte); // SEND ON TERMINAL
00256         i++;  //COUNTER INCREMEN
00257         
00258         if(i >= BUFFER_SIZE) //IF LIMIT CROSS
00259         {
00260             i = 0;   //RESET COUNTER
00261         }
00262     }
00263     
00264     //USE THREAD YIELD FOR UPDATE OTHER THREADS
00265     
00266 
00267 
00268     LCD_FLAG = 0; //RESET -- VERSION READ COMPLETED
00269     //THREA YIELD
00270         
00271 
00272 }
00273 
00274 void START_NEW_TEST(void)
00275 {
00276     if(TEST_FLAG == 1U && PROCESS_FLAG == 0U)
00277     {
00278         //FLAG MUST BE ZERO
00279         NEXT = 0;
00280         ERROR_FLAG = 0;
00281         RED_LED =0;
00282         GREEN_LED =1;
00283         PROCESS_FLAG = 1U;
00284         //turn test flag on
00285         TEST_FLAG =1U;
00286         //COUNTER++
00287         PCB_COUNTER++;
00288         //NEED TO WAIT 25 ms
00289         pc.printf("\n \n  \n");
00290         pc.printf("***********************************************************");
00291         pc.printf("AXV 001  PCB NUMBER = %u",PCB_COUNTER);
00292         NEW_TEST_UPDATE_LCD();  //THIS FUNCTION IS ONLY FOR DELAY
00293 
00294     
00295     A.release();
00296     //last fucntion to reset flag and display test result
00297     wait(0.5);
00298      //CLEAR THE BUFFER BEFORE UART COMM
00299     //***************TEST - 1 ENTER INTEST MODE AND VERSION READ------------------------------TEST1
00300     BUFFER_CLEAR();
00301     UT.putc('T');  //ENTER IN TEST MODE  -- SLAVE BOARD ENTER INTO TEST MODE
00302     A.release();
00303     ThisThread::sleep_for(1000);
00304     response();
00305     wait(0.10);
00306     //FETCHING VERSION NUMBER 01.34
00307     lcd.cls();
00308     wait(1);
00309     lcd.locate(0,0);
00310     lcd.printf("");
00311     lcd.printf("VERSION TEST ON");
00312     {
00313         uint8_t j=0;
00314         char temp_buf[6];
00315         char ver[] = "01.34";
00316         pc.puts("\n FETCHING VERSION FROM IC: ");
00317        for(j=13;j<18;j++)
00318        {
00319             pc.putc(rxBuffer[j]);
00320             temp_buf[j-13] = rxBuffer[j];
00321         }
00322         temp_buf[5] = '\n';
00323         float value = atof(temp_buf);
00324         pc.printf("\n VERSION VALUE IS %f",value);
00325             if(value == 1.340000f)
00326         {
00327             pc.printf("\n Correct Version receive \n");
00328             //PRINT DATA ON LCD
00329             lcd.locate(0,1);
00330             lcd.printf("VERSION = 1.34");
00331             lcd.locate(0,2);
00332             lcd.printf("VERSION TEST OK");
00333             //GO FOR NEXT TEST
00334             NEXT = 1; //READY FOR NEXT TEST
00335             CURRENT();
00336             A.release();
00337             wait(6);
00338             
00339         
00340         }
00341         else
00342         {
00343             pc.printf("\n Wrong version \n");
00344             //ERROR - STOP TEST
00345             ERROR_FLAG = 1;
00346             error(1);
00347             NEXT = 0;
00348         }
00349         
00350         j = 0;
00351         //Clear the buffer data to avoid mistakes
00352 
00353     } 
00354     if(NEXT == 1) //****************    RED LED TESTING    *********************
00355     {
00356         float CURRENT_TEMP = 0;
00357         NEXT = 0;
00358         lcd.cls();
00359         CURRENT();
00360         A.release();
00361         wait(2);
00362         BUFFER_CLEAR();
00363         lcd.locate(0,0);
00364         lcd.printf("");
00365         lcd.locate(0,0);
00366         lcd.printf("RED LED TEST ON");
00367         pc.printf("\n RED LED TESTING START");
00368         UT.putc('d');   // RED LED OF SLAVE BOARD ON
00369         A.release();
00370         wait(1);
00371         response(); //Read Response from Slave
00372         pc.printf("\n RED LED COMMAND RELEASE ");
00373         lcd.locate(0,1);
00374         {
00375             float LDR_AVG =0;
00376             float S = 0;
00377             int8_t z;
00378         
00379             
00380         for(z = 0; z < 10; z++)
00381         {
00382          
00383          LDR_VALUE = LDR.read();
00384          wait_ms(20);
00385          S = S + LDR_VALUE;
00386             
00387         }
00388         LDR_AVG = S /10;
00389         LDR_VALUE = LDR_AVG;
00390         }
00391         lcd.printf("RED LED ON COMMAND");
00392         BUFFER_CLEAR();
00393         A.release();
00394         wait(2);
00395         A.release();
00396         wait(2);
00397         CURRENT();
00398         A.release();
00399         wait(2);
00400         CURRENT_TEMP = current;
00401         pc.printf("\n RED LED ON TIME CURRENT =     %f",current);
00402         lcd.locate(0,1);
00403         lcd.printf("RED LED OFF COMMAND");
00404         UT.putc('b');
00405         A.release();
00406         wait(2);
00407         response();
00408         BUFFER_CLEAR();
00409         pc.printf("RED LED TEST FINISH");
00410         
00411         //result time 
00412         if(LDR_VALUE > 0.650)
00413         {
00414         lcd.locate(0,0);
00415         lcd.printf("");
00416         lcd.printf("RED LED TEST OK");
00417         lcd.locate(0,1);
00418         lcd.printf("                   ");
00419         lcd.locate(0,1);
00420         lcd.printf("LED ON DETECTED");
00421         NEXT = 1;
00422         pc.printf("\n RED LED DETECT SUCCESSFULLY");
00423                 
00424         //CLEAR LCD CONTENT
00425         wait(6);
00426         LDR_VALUE = 0;
00427         }
00428         else
00429         {
00430             pc.printf("\n PROBLEM in LED DETECTION");
00431             NEXT = 0;
00432             ERROR_FLAG = 1;
00433             error(5);
00434 
00435             
00436         }
00437         wait_ms(200);
00438         if(CURRENT_TEMP < 12.0 || CURRENT_TEMP > 20.5)
00439         {
00440          pc.printf("\n OVER OR UNDER CURRENT ERROR \n");
00441          pc.printf("\n This Error at time of LED on/off process \n");
00442          NEXT = 0;
00443          ERROR_FLAG = 1;
00444          CURRENT_TEMP =0;
00445          error(7);
00446          
00447          }      
00448 
00449     }
00450     if(NEXT == 1)//**********************************CALIBRATION ON
00451     {
00452         NEXT =0;
00453         pc.printf("\n CALIBRATION ON ");
00454         lcd.locate(0,0);
00455         lcd.printf("                   ");
00456         lcd.locate(0,0);
00457         lcd.printf("CALIBRATION ON");
00458         lcd.locate(0,1);
00459         lcd.printf("                   ");
00460         lcd.locate(0,1);
00461         wait(1);
00462         lcd.printf("In PROGRESS....");
00463         pc.printf("\n CALIBRATION PROCESS IN PROGRESS");
00464         BUFFER_CLEAR();
00465         UT.putc('c');
00466         A.release();
00467         wait(5);
00468         UT.putc('s');
00469         A.release();
00470         wait(1);
00471         lcd.locate(0,2);
00472         lcd.printf("                   ");
00473         lcd.locate(0,2);
00474         pc.printf("\n CALIBRATION COMPLETE");
00475         lcd.printf("DATA SAVE OK");
00476         lcd.locate(0,1);
00477         lcd.printf("                   ");
00478         lcd.locate(0,1);
00479         lcd.printf("CALIBRATION DONE");
00480         A.release();
00481         wait(3);
00482         A.release();
00483         wait(4);
00484         NEXT = 1;
00485         
00486     }
00487     if(NEXT ==1)//*****************************BATTERY VOLTAGE TEST
00488     {
00489         uint32_t G_VAL = 0;
00490         float vol = 0;
00491         NEXT =0;
00492         ERROR_FLAG = 0;
00493         lcd.locate(0,1);
00494         lcd.printf("                   ");
00495         lcd.locate(0,2);
00496         lcd.printf("                   ");
00497         lcd.locate(0,0);
00498         lcd.printf("                   ");
00499         lcd.locate(0,0);
00500         lcd.printf("Voltage Test ON");
00501         pc.printf("\n VOLTAGE TEST BEGIN");
00502         BUFFER_CLEAR();
00503         UT.putc('A');
00504         A.release();
00505         wait(1);
00506         response();
00507         //DECODE DATA >>>>>>>>>>>>>>>>>>>>>>>BATTERY VOLTAGE <<<<<<<<<<<<<<<<<<<
00508         {
00509         uint8_t b=0;
00510         char temp_buf[5];
00511         pc.puts("\n \n \n DECODE BATTERY VOLTAGE: ");
00512        for(b=1;b<5;b++)
00513        {
00514             pc.putc(rxBuffer[b]);
00515             temp_buf[b-1] = rxBuffer[b];
00516         }
00517         temp_buf[4] = '\n';
00518         
00519         //*****************************HEX TO DEC*******************************
00520     {
00521     int base = 1; 
00522       
00523     int dec_val = 0;
00524     int i1;
00525       
00526     // Extracting characters as digits from last character 
00527     for (i1=3; i1>=0; i1--) 
00528     {    
00529         // if character lies in '0'-'9', converting  
00530         // it to integral 0-9 by subtracting 48 from 
00531         // ASCII value. 
00532         if (temp_buf[i1]>='0' && temp_buf[i1]<='9') 
00533         { 
00534             dec_val += (temp_buf[i1] - 48)*base; 
00535                   
00536             // incrementing base by power 
00537             base = base * 16; 
00538         } 
00539   
00540         // if character lies in 'A'-'F' , converting  
00541         // it to integral 10 - 15 by subtracting 55  
00542         // from ASCII value 
00543         else if (temp_buf[i1]>='A' && temp_buf[i1]<='F') 
00544         { 
00545             dec_val += (temp_buf[i1] - 55)*base;
00546                base = base*16; 
00547         } 
00548 
00549         }
00550         pc.printf("\n value = %d",dec_val);
00551         G_VAL = dec_val;
00552         }
00553         }
00554         pc.printf("\n GVAL %d",G_VAL);
00555         float T1;
00556         T1 = (float)(G_VAL/65535.0);
00557         pc.printf("\n T1 = %f",T1);
00558         float T2;
00559         T2 = (float)(T1*3.6);
00560         pc.printf("\n T2 = %f",T2);
00561         vol = (23.68 * (T2/10));
00562         pc.printf("\n VOLTAGE LEVEL = %f",vol);
00563         lcd.locate(0,2);
00564         lcd.printf("                   ");
00565         lcd.locate(0,2);
00566         lcd.printf("Voltage = %.2f V",vol);
00567         G_VAL = 0;
00568         BUFFER_CLEAR();
00569         wait(5);
00570         if(vol >= 6 || vol <= 4.5)
00571         {
00572          NEXT = 0;
00573          ERROR_FLAG = 1;
00574          error(10);   
00575         }
00576         else
00577         {
00578         NEXT = 1;
00579         ERROR_FLAG = 0;
00580         }
00581 
00582         
00583     }
00584     if(NEXT == 1)// ********************************* CURRENT TEST
00585     {
00586         lcd.locate(0,0);
00587         BUFFER_CLEAR();
00588         NEXT = 0;
00589         pc.printf("\n CURRENT TEST START");
00590         A.release();
00591         wait(2);
00592         CURRENT();
00593         lcd.locate(0,1);
00594         lcd.printf("                   ");
00595         lcd.locate(0,1);
00596         lcd.printf("CURRENT = %f",current);
00597         if(current > 6.5)
00598         {
00599             CURRENT();
00600             wait(2);
00601         }
00602         if(current > 6.5)
00603         {
00604             error(2);
00605             NEXT = 0;
00606             ERROR_FLAG = 1;   
00607         }
00608         else
00609         {
00610             
00611         NEXT = 1;
00612         ERROR_FLAG = 0;
00613         }
00614     
00615     }
00616 
00617     //END OF TEST -- NO NEED TO CHECK NEXT FLAG
00618     UT.putc('Q');
00619     wait(1);
00620     BUFFER_CLEAR();
00621     
00622     if(ERROR_FLAG == 0)
00623     {
00624     result();
00625     }
00626     
00627     }  //OUTER SIDE BEGIN
00628     TEST_FLAG = 0U;
00629     PROCESS_FLAG = 0U;
00630     GREEN_LED = 0U;
00631     RED_LED = 0U;
00632     NEXT = 0;
00633     ERROR_FLAG =0;
00634     
00635 }
00636 void result()
00637 {
00638 {
00639 wait(3);
00640 lcd.cls();
00641 lcd.locate(0,0);
00642 lcd.printf("TEST SUCCESSFUL OK");
00643 lcd.locate(0,1);
00644 lcd.printf("BOARD TEST - PASS");
00645 lcd.locate(0,2);
00646 lcd.printf("PLUG NEW BOARD");
00647 lcd.locate(0,3);
00648 lcd.printf("Total Test = %u",PCB_COUNTER);
00649 GREEN_LED =1;
00650 RED_LED =0;
00651 BLUE_LED =0;
00652 BUZZER = 1;
00653 wait(0.5);
00654 BUZZER =0;
00655 wait(3);
00656 }
00657 
00658 //AT END OF PROCESS
00659 TEST_FLAG = 0U;
00660 PROCESS_FLAG = 0U;
00661 GREEN_LED = 1U;
00662 pc.printf("\n PCB AXV 001 TEST COMPLETED : TEST STATUS - PASS \n");
00663 pc.printf("\n ******************************END OF TEST************************************ \n");
00664 pc.printf("Total Test = %u",PCB_COUNTER);
00665 pc.printf("\n  \n \n");
00666 pc.printf("\n PLUG NEW BOARD AND PRESS THE BUTTON");
00667 pc.printf("\n \n \n");
00668 wait(5);
00669 
00670 }
00671 
00672 void error(uint8_t error_number)
00673 {
00674 {
00675  RED_LED=1;
00676  GREEN_LED=0;
00677  BLUE_LED=0;
00678  BUZZER = 1;
00679  wait(3);
00680  BUZZER =0;
00681  lcd.cls();
00682  lcd.locate(0,0);
00683  lcd.printf("Oops ..ERROR");
00684  pc.printf("\n Test Fail ");
00685  pc.printf("\n Error -- Contact to HOD");
00686  lcd.locate(0,2);
00687 lcd.printf("PLUG NEW BOARD");
00688 lcd.locate(0,3);
00689 lcd.printf("Total Test = %u",PCB_COUNTER);
00690 if(error_number == 1)
00691 {
00692  lcd.locate(0,1);
00693  lcd.printf("WRONG VERSION");
00694  pc.printf("\n ERROR CODE  = 0x1");
00695  pc.printf("\n WRONG VERSION OF SOFTWARE , PLEASE CHECK");
00696  pc.printf("\n POSSIBLE SOLUTION \n");
00697  pc.printf("\n 1) REPROGRAM BOARD 2) CHECK SUPPLY VOLTAGE ");
00698  wait(3);
00699 }
00700 if(error_number == 2)
00701 {
00702  lcd.locate(0,1);
00703  lcd.printf("                   ");
00704  lcd.locate(0,1);
00705  lcd.printf("OVER CURRENT ");
00706  pc.printf("\n ERROR CODE = 0X2");
00707  pc.printf("\n OVER CURRENT ERROR");
00708  pc.printf("\n POSSIBLE SOLUTION");
00709  pc.printf("\n TRY TO WASH BOARD AGAIN and RECHECK");
00710  wait(10);
00711  lcd.locate(0,1);
00712  lcd.printf("");
00713  CURRENT();
00714  A.release();
00715  wait(10);
00716  
00717 }
00718 if(error_number == 5)
00719 {
00720     pc.printf("\n ERROR NUMBER = 0X5");
00721     pc.printf("\n RED LED DETECTION FAIL");
00722     lcd.locate(0,1);
00723     lcd.printf("                   ");
00724     lcd.locate(0,1);
00725     lcd.printf("LED TEST FAIL");
00726     A.release();
00727     wait(1);
00728     pc.printf("\n POSSIBLE SOLUTION");
00729     pc.printf("\n 1) CHECK LED MANUALLY - IF IT IS IN ON STATE PLEASE ADJUST SENSOR POSITION ");
00730     pc.printf("\n Contact to R&D DEPT. for Hardare Amendement");
00731     pc.printf("\n 2) If LED is not working state - check polarity");
00732     pc.printf("\n contact to HOD");
00733     
00734 }
00735 if(error_number == 7)
00736 {
00737     lcd.locate(0,1);
00738     lcd.printf("                   ");
00739     lcd.locate(0,1);
00740     lcd.printf("LED Curr. Outer range");
00741     pc.printf("\n LED TAKING OUTER RANGE CURRENT \n");
00742     A.release();
00743     wait(2);
00744     
00745 }
00746 if(error_number == 10)
00747 {
00748     pc.printf("\n SUPPLY VOLTAGE ERROR \n");
00749     lcd.locate(0,1);
00750     lcd.printf("                   ");
00751     lcd.locate(0,1);
00752     lcd.printf("SUPP. VOLTAGE ERROR");
00753     wait(5);
00754 }
00755     
00756 }
00757     
00758 //AT END OF PROCESS    
00759 TEST_FLAG = 0U;
00760 PROCESS_FLAG = 0U;
00761 RED_LED =1;
00762 BUZZER = 1;
00763 NEXT = 0;
00764 //ERROR_FLAG =0;
00765 wait(3);
00766 BUZZER =0;
00767 pc.printf("\n *******************ERROR DESCRIPTION END **************************");
00768 pc.printf("\n ***************************END OF TEST ****************************");
00769 }   
00770 
00771 void WELCOME_SCREEN()
00772 {
00773 pc.printf("\n");
00774 pc.printf("AXV GOLBAL VALVE TESTER -- FOLLOW THE STEPS \n");
00775 
00776 RED_LED = 1;
00777 GREEN_LED = 1;
00778 BLUE_LED =1;
00779 BUZZER = 1;
00780 wait(1);
00781 BUZZER = 0;
00782 
00783 
00784 //WELCOME SCREEN DATA
00785 lcd.cls(); //clear the screen first
00786 lcd.printf("     Welcome !!!");
00787 lcd.locate(0,1);
00788 lcd.printf("GLOBAL V- TESTER");
00789 lcd.locate(0,2);
00790 lcd.printf("POWERED BY : KEPL ");
00791 lcd.locate(0,3);
00792 lcd.printf("R_AND_D DEPARTMENT");
00793 wait(5);
00794 lcd.cls();
00795 lcd.locate(0,0);
00796 lcd.printf("Loading...");
00797 lcd.locate(11,0);
00798 pc.printf("\n DATA LOADING .....");
00799 pc.printf("\n Veryfying....");
00800 wait_ms(500);
00801 lcd.printf(".");
00802 lcd.locate(12,0);
00803 wait_ms(500);
00804 lcd.printf("...");
00805 wait_ms(1000);
00806 lcd.locate(13,0);
00807 lcd.printf("..");
00808 lcd.locate(0,1);
00809 lcd.printf("INITIALIZATION...");
00810 wait_ms(4000);
00811 pc.printf("\n LCD COMMUNICATION Successful \n");
00812 lcd.cls();
00813 lcd.locate(0,0);
00814 lcd.printf("Done !!!!");
00815 lcd.locate(0,1);
00816 lcd.printf("TEST MODE ON");
00817 lcd.locate(0,2);
00818 lcd.printf("COUNT = 0");
00819 wait_ms(5000);
00820 lcd.cls();
00821 lcd.locate(0,0);
00822 BLUE_LED = 1;
00823 BUZZER = 1;
00824 wait_ms(250);
00825 BUZZER = 0;
00826 pc.printf("\n SOFTWARE CHECKED & READY TO USE \n");
00827 pc.printf("\n ESD PROTECTION REQUIRE");
00828 pc.printf("\n KEEP YOUR EYES ON TERMINAL OR ON LCD");
00829 pc.printf("\n LED VISUAL AND BUZZER SOUND INDICATION HELPS YOU !!!");
00830 lcd.printf("AXV -T");
00831 lcd.locate(10,0);
00832 lcd.printf("Count %u",PCB_COUNTER);
00833 
00834 }
00835 
00836 void NEW_TEST_UPDATE_LCD()
00837 {
00838     GREEN_LED = 1;
00839     BLUE_LED = 1;
00840     lcd.cls();
00841     lcd.locate(0,0);
00842     lcd.printf("TESTING ON...");
00843     pc.printf("\n \n \n");
00844     pc.printf("\n NEW TEST START");
00845     wait(8); //8 SECOND 
00846     lcd.locate(0,1);
00847     lcd.printf("TEST SETUP ON");
00848     pc.printf("\n BOARD SCANNING...");
00849     wait(8);
00850     lcd.locate(0,2);
00851     lcd.printf("MAKING CONNECTION");
00852     pc.printf("\n COMMUNICATION ESTABLISHMENT \n");
00853     wait(5);
00854     lcd.locate(0,3);
00855     lcd.printf("READY FOR TESTING");
00856     wait(5);
00857     lcd.cls();
00858     lcd.locate(0,0);
00859     lcd.printf("TEST MODE N 0%u",PCB_COUNTER);
00860     pc.printf("TEST MODE ON - COUNT = %u",PCB_COUNTER);
00861     A.release();
00862     wait(0.5);
00863     
00864 }
00865 
00866 /*Below Function is part of ISR ;so do not write big code inside it
00867 If possible than only set and reset flag only
00868 Because while servicing Interrupt OS can not schedule or switch other thread or Task
00869 In future during updation of version please consider RTOS Management Rule
00870 or contact Reserach & development team : JAYDEEP SHAH
00871 */
00872 
00873 void TEST_PROCESS()  //This Function is connected with ISR Of Push_button
00874 {
00875     if(TEST_FLAG == 0U && PROCESS_FLAG == 0U)
00876     {
00877         TEST_FLAG = 1U;
00878     }
00879     else
00880     {
00881         TEST_FLAG = 0U;
00882         
00883     }
00884 
00885 }
00886 void CURRENT()
00887 {
00888         for(int i =0;i <10 ; i++)  //Array to make result smoother
00889         {
00890             AARAY[i] = ANG.read();  //Read the data
00891             ThisThread::sleep_for(20);  //Thread sleep for make ADC ready for next result
00892             SUM = SUM + AARAY[i]; //Store result
00893         } 
00894         float value = (SUM /10);  //Finding Average value 
00895         
00896         current = (((((((value)) * 3.3)-0.28)/200)/0.6)*1000);  //Finding current
00897         current = current + 2.5;  // 2.5 is offset (when current is < 50 mA)
00898         
00899         //pc.printf("\n Current (mA) = %f",current);  //Print data on Serial console -- I used CoolTerm
00900         
00901         SUM = 0;  //At the end sum must be zero
00902         //A.release();
00903     
00904 }
00905 
00906 void BUFFER_CLEAR()
00907 {
00908     RxInterrupt(); // To clear serial buffer
00909     i = 0U;
00910     bufferReadingIndex = 0U;
00911     for(int k =0; k<50 ; k++) // ****************CLEAR 50 BYTES BUFFER
00912     {
00913      rxBuffer[k] = ' ';   
00914     }
00915 }