Revision 5:38b2b8790b40, committed 2021-04-11

Comitter:

dragica

Date:

Sun Apr 11 09:08:16 2021 +0000

Parent:

4:28919318b141

Commit message:

SW napisan za testiranje nedelja 11 april 2021.

Changed in this revision

--- a/bq79606.cpp	Sun Mar 21 22:58:15 2021 +0000
+++ b/bq79606.cpp	Sun Apr 11 09:08:16 2021 +0000
@@ -15,12 +15,10 @@
 extern DigitalOut bmsWakeUp;
 
 void sendUART(int length, uint8_t * data){
-    pc1.printf("SENDING TO BOARD\n");
+    wait_ms(1); // MUST
     for(int i = 0; i < length; i++) {
-      //pc1.putc(data[i]);
       bms.putc(data[i]);
       }
-    //wait_ms(1);
 }
 
 void Wake79606(){
@@ -29,14 +27,7 @@
     bmsWakeUp = 0;
     wait_us(275);
     bmsWakeUp = 1;
-    
-    //NMOS TRANSISTOR LOGIC
-    
-    /*bmsWakeUp = 0;
-    wait_ms(50);
-    bmsWakeUp = 1;
-    wait_ms(50);
-    bmsWakeUp = 0;*/
+    wait_ms(10);
 }
 
 void AutoAddress()
@@ -300,6 +291,7 @@
     WriteReg(0, GPIO1_CONF, 0x20, 1, FRMWRT_ALL_NR); //configure GPIO as input
 
     WriteReg(0, AUX_ADC_CTRL1, 0x10, 1, FRMWRT_ALL_NR); //enable GPIO1 
+
 }
 
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/canMessage.h	Sun Apr 11 09:08:16 2021 +0000
@@ -0,0 +1,54 @@
+#include "mbed.h"
+
+const BYTE gpioID = 0x72;
+const BYTE uvID = 0x90;
+const BYTE ovID = 0x50;
+const BYTE utID = 0x99;
+const BYTE otID = 0x49;
+const BYTE toneID = 0x80;
+const BYTE uartID = 0x81;
+const BYTE uartRCID = 0x98;
+const BYTE uartRRID = 0x97;
+const BYTE uartTRID = 0x65;
+const BYTE COMHID = 0x63;
+const BYTE COMHRCID = 0x95;
+const BYTE COMHRRID = 0x73;
+const BYTE COMHTRID = 0x66;
+const BYTE COMLID = 0x91;
+const BYTE COMLRCID = 0x90;
+const BYTE COMLRRID = 0x72;
+const BYTE COMLTRID = 0x33;
+const BYTE otpID = 0x94;
+const BYTE railID = 0x32;
+const BYTE ovuvBistID = 0x22;
+const BYTE otutBistID = 0x26;
+const BYTE tempID = 0x70;
+const BYTE voltID = 0X71;
+
+extern CAN can1;
+extern CANMessage message1;
+
+
+void sendCANbyte(BYTE ID, BYTE data)
+{
+    message1.id = ID;
+    message1.data[0] = data;
+    can1.write(message1);
+}
+
+void sendCAN(BYTE ID, int data)
+{
+    message1.id = ID;
+    
+    int j = 0;
+    BYTE dataMOD = data % 256 ;
+    int dataDIV = data;
+    
+    while(dataDIV > 0)
+    {
+         message1. data[j++]= dataMOD;
+         dataDIV = dataDIV >> 8;
+         dataMOD = dataDIV % 256;
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/handlers.h	Sun Apr 11 09:08:16 2021 +0000
@@ -0,0 +1,225 @@
+#include "mbed.h"
+#include "canMessage.h"
+//REGISTER 
+volatile int gpioFault = 0;
+volatile int uvFault = 0;
+volatile int ovFault = 0;
+volatile int utFault = 0;
+volatile int otFault = 0;
+volatile int toneFault = 0;
+volatile int uartFault = 0;
+volatile int uartRCFault = 0;
+volatile int uartRRFault = 0;
+volatile int uartTRFault = 0;
+volatile int COMHFault = 0;
+volatile int COMHRCFault = 0;
+volatile int COMHRRFault = 0;
+volatile int COMHTRFault = 0;
+volatile int COMLFault = 0;
+volatile int COMLRCFault = 0;
+volatile int COMLRRFault = 0;
+volatile int COMLTRFault = 0;
+volatile int otpFault = 0;
+volatile int railFault = 0;
+volatile int ovuvBistFault = 0;
+volatile int otutBistFault = 0;
+extern Serial pc1;
+
+
+void GPIOHandler()
+{
+    if (gpioFault != 0)
+    {
+        pc1.printf("GPIO FAULT = %X\n", gpioFault);   
+        sendCANbyte(gpioID, gpioFault);
+    }
+}
+
+void UVHandler()
+{
+    if (uvFault != 0)
+    {
+        pc1.printf("UNDER VOLTAGE FAULT = %X\n", uvFault); 
+        sendCANbyte(uvID, uvFault);
+    }
+}
+
+void OVHandler()
+{
+    if (ovFault != 0)
+    {
+        pc1.printf("OVER VOLTAGE FAULT = %X\n", ovFault); 
+        sendCANbyte(ovID, ovFault);
+    }
+}
+
+void UTHandler()
+{
+    if (utFault != 0)
+    {
+        pc1.printf("UNDER TEMPERATURE FAULT = %X\n", utFault);   
+        sendCANbyte(utID, utFault);   
+    }
+}
+
+void OTHandler()
+{
+    if (otFault != 0)
+    {
+        pc1.printf("OVER TEMPERATURE FAULT = %X\n", otFault);   
+        sendCANbyte(otID, otFault);
+    }
+}
+
+void ToneHandler()
+{
+    if (toneFault != 0)
+    {
+        pc1.printf("Bus Status FAULT = %X\n", toneFault);   
+        sendCANbyte(toneID, toneFault);
+    }
+}
+
+void UARTHandler()
+{
+    if (uartFault != 0)
+    {
+        pc1.printf("UART FAULT Status = %X\n", uartFault);   
+        sendCANbyte(uartID, uartFault);
+    }
+}
+
+void UARTRCHandler()
+{
+    if (uartRCFault != 0)
+    {
+        pc1.printf("UART Receive Command FAULT Status = %X\n", uartRCFault);   
+        sendCANbyte(uartRCID, uartRCFault);
+    }
+}
+
+void UARTRRHandler()
+{
+    if (uartRRFault != 0)
+    {
+        pc1.printf("UART Receive Response FAULT Status = %X\n", uartRRFault);   
+        sendCANbyte(uartRRID, uartRRFault);
+    }
+}
+
+void UARTTRHandler()
+{
+    if (uartTRFault != 0)
+    {
+        pc1.printf("UART Transmit FAULT Status = %X\n", uartTRFault);   
+        sendCANbyte(uartTRID, uartTRFault);
+    }
+}
+
+void COMHHandler()
+{
+    if (COMHFault != 0)
+    {
+        pc1.printf("COMH FAULT Status = %X\n", COMHFault);   
+        sendCANbyte(COMHID, COMHFault);
+    }
+}
+
+void COMHRCHandler()
+{
+    if (COMHRCFault != 0)
+    {
+        pc1.printf("COMH Receive Command FAULT Status = %X\n", COMHRCFault);   
+        sendCANbyte(COMHRCID, COMHRCFault);
+    }
+}
+
+void COMHRRHandler()
+{
+    if (COMHRRFault != 0)
+    {
+        pc1.printf("COMH Receive Response FAULT Status = %X\n", COMHRRFault);  
+        sendCANbyte(COMHRRID, COMHRRFault); 
+    }
+}
+
+void COMHTRHandler()
+{
+    if (COMHTRFault != 0)
+    {
+        pc1.printf("COMH Trasmit FAULT Status = %X\n", COMHTRFault);
+        sendCANbyte(COMHTRID, COMHTRFault);    
+    }
+}
+
+void COMLHandler()
+{
+    if (COMLFault != 0)
+    {
+        pc1.printf("COML FAULT Status = %X\n", COMLFault);
+        sendCANbyte(COMLID, COMLFault);    
+    }
+}
+
+void COMLRCHandler()
+{
+    if (COMLRCFault != 0)
+    {
+        pc1.printf("COML Receive Command FAULT Status = %X\n", COMLRCFault);
+        sendCANbyte(COMLRCID, COMLRCFault);    
+    }
+}
+
+void COMLRRHandler()
+{
+    if (COMLRRFault != 0)
+    {
+        pc1.printf("COML Receive Response FAULT Status = %X\n", COMLRRFault);
+        sendCANbyte(COMLRRID, COMLRRFault);    
+    }
+}
+
+void COMLTRHandler()
+{
+    if (COMLTRFault != 0)
+    {
+        pc1.printf("COML Trasmit FAULT Status = %X\n", COMLTRFault);
+        sendCANbyte(COMLTRID, COMLTRFault);    
+    }
+}
+
+void OTPHandler()
+{
+    if (otpFault != 0)
+    {
+        pc1.printf("OTP PAGE FAULT Status = %X\n", otpFault);   
+        sendCANbyte(otpID, otpFault); 
+    }
+}
+
+void RAILHandler()
+{
+    if (railFault != 0)
+    {
+        pc1.printf("POWER RAIL FAULT Status = %X\n", railFault);   
+        sendCANbyte(railID, railFault); 
+    }
+}
+
+void OVUVBISTHandler()
+{
+    if (ovuvBistFault != 0)
+    {
+        pc1.printf("OVER VOLTAGE UNDER VOLTAGE BIST FAULT Status = %X\n", ovuvBistFault);   
+        sendCANbyte(ovuvBistID, ovuvBistFault); 
+    }
+}
+
+void OTUTBISTHandler()
+{
+    if (otutBistFault != 0)
+    {
+        pc1.printf("OVER TEMPERATURE UNDER TEMPERATURE BIST FAULT Status = %X\n", otutBistFault);   
+        sendCANbyte(otutBistID, otutBistFault); 
+    }
+}
\ No newline at end of file

--- a/main.cpp	Sun Mar 21 22:58:15 2021 +0000
+++ b/main.cpp	Sun Apr 11 09:08:16 2021 +0000
@@ -1,6 +1,8 @@
 #include "mbed.h"
 #include "bq79606.h"
-
+#include "math.h"
+#include "handlers.h"
+#include "ntc.h"
 // - - - PIN CONFIGURATION - - -
 
 DigitalIn bmsFault(PB_4);
@@ -9,11 +11,11 @@
 // - - - UART CONFIGURATION - - -
 
 Serial bms(PA_0, PA_1, 250000); //UART ka BMS Slaveu
-Serial pc1(USBTX, USBRX, 9600);//PC_10, PC_11,9600); //UART ka PCu Serijskom monitoru
+Serial pc1(USBTX, USBRX, 9600);//PC_10, PC_11,9600); //UART ka PCu Serijskom monitoru     
 
+//- - - CAN CONFIGURATION - - - 
 CAN can1(PB_8, PB_9, 500000);
-CANMessage message1;
-        
+CANMessage message1; 
 
 BYTE recBuff[1024];
 volatile int recLen=0;
@@ -21,50 +23,55 @@
 volatile bool full = false;
 volatile int rdLen=0;
 int counter = 0;
+volatile int devStat = 0;
+volatile int cbRun = 1;
+volatile int cbDone = 0;
+
+volatile int faultSUM = 0;
+volatile int DEVStat = 0;
+
+volatile double extern Vin;
+volatile double extern Rref;
 
 uint8_t pFrame1[(MAXBYTES+6)*TOTALBOARDS];
 
 void callback() {
     // Note: you need to actually read from the serial to clear the RX interrupt
-    //pc1.printf("* * *    Uspesan PRIJEM!     * * *\n");
-    
-        //pc1.printf("rec = %d", c);
         recBuff[recLen++] = bms.getc();
         if(expected==0) expected = recBuff[0]+7; //prvi bajt je (broj data - 1), +1 device id, +2 reg address, +2 CRC
-        //pc1.printf("Prva rec = %d", recBuff[0]); 
         if(expected == recLen){
-            //pc1.printf("\n\n- - - USAO U EXPECTED - - -\n"); 
-            full = true;
             rdLen = expected;
             expected = 0;
             recLen = 0;
+            full = true;
         }
-        
-    
-    //full = true;
-    //recLen = 0;
-    //rdLen = 17; //samo test - nebitno koji broj
 }
 
-void waitFrame(){
+int waitRegRead()
+{
     while(!full);
-    //wait(2);
+    wait_us(500);
     full=false;
-    pc1.printf("\n%d\n", rdLen);
-    for(int i = 0;i<rdLen;i++){
-        pc1.printf("%X ",recBuff[i]);
-    }
+    return recBuff[4];
+}
+  
+
+
+ 
+ void waitFrame(){
+    while(!full);
+    wait_us(500);
+    full=false;
     
     pc1.printf("\n\n- - - VOLTAGE - - -\n"); 
-    message1.id = 0x71;
+    message1.id = voltID;
     int j = 0;
     for(int i = 4; i < recBuff[0] + 4; i += 2){
         int voltage = recBuff[i+1];   //LSB
         voltage |= (recBuff[i]) << 8; //MSB
         double vol = voltage*0.0001907349;
-        //double vol = ((double)voltage)/65536.0 * 5.0;
         pc1.printf("CELL[%d] = %6.2f V\n", i/2-1, vol);
-        
+        //sendCAN(voltID, vol);
         message1.data[j++] = recBuff[i];
         
     }
@@ -74,51 +81,283 @@
 }
 
 
-void waitFrameTemp(){
+void waitFrameTemp(){ 
     while(!full);
-    //wait(2);
     full=false;
     pc1.printf("****** TEMPERATURA *****");
     pc1.printf("\n%d\n", rdLen);
     for(int i = 0;i<rdLen;i++){
         pc1.printf("%X ",recBuff[i]);
     }
-        int voltage = recBuff[5];   //LSB
-        voltage |= (recBuff[4]) << 8; //MSB
-        double vol = voltage*0.0001907349;
-        //double vol = ((double)voltage)/65536.0 * 5.0;
-        pc1.printf("temp1  = %f V\n", vol);
-   
+    int voltage = recBuff[5];   //LSB
+    voltage |= (recBuff[4]) << 8; //MSB
+    double Vout = voltage*0.0001907349;
+    int temp = naponskiRazdelnik(Vout);
+    sendCANbyte(tempID, temp);
+}
+
+void StartBalancingAndWaitToFinish()
+{
+    cbRun = 1;
+    cbDone = 0;
+    WriteReg(0, CB_CONFIG, 0xFA, 1, FRMWRT_ALL_NR); // Odds then Evens, continue regardless of fault condition, 30sec, seconds
+    
+    WriteReg(0, CB_DONE_THRESHOLD, 0x5F, 1, FRMWRT_ALL_NR); // Thresh hold set to value 3.6V, CBDONE comparators enabled
+    //Enabling the CBDONE voltage threshold overrides the OVUV function and pauses it.
+    
+    WriteReg(0, CB_CELL1_CTRL, 0xBC, 1, FRMWRT_ALL_NR);//cell 1- 1 minute balance timer
+    WriteReg(0, CB_CELL2_CTRL, 0xBC, 1, FRMWRT_ALL_NR);//cell 2- 1 minute balance timer
+    WriteReg(0, CB_CELL3_CTRL, 0xBC, 1, FRMWRT_ALL_NR);//cell 3- 1 minute balance timer
+    
+    WriteReg(0, CONTROL2, 0x30, 1, FRMWRT_ALL_NR);//BAL_GO set to 1, and TSREF enabled
+    wait_us(100);
+    pc1.printf("Setupovano balansiranje\n");
+    while (cbRun)
+    {
+        ReadReg(0, DEV_STAT, pFrame1, 1 , 0, FRMWRT_ALL_R);
+        wait(1);
+        devStat = recBuff[4];
+        cbRun = (devStat & 0x10) >> 4;
+        wait_us(500);
+        if (!cbRun)
+        {
+            pc1.printf("DEV STAT = %d\n", devStat);
+            pc1.printf("CBRUN = %d\n", cbRun);
+            //wait(10);
+        }
+    }
+    
+    while(!cbDone)
+    {
+        ReadReg(0, DEV_STAT, pFrame1, 1 , 0, FRMWRT_ALL_R);
+        wait(1);
+        devStat = recBuff[4];
+        cbDone = (devStat & 0x40) >> 6;
+        wait_us(500);
+        if (cbDone)
+        {
+            pc1.printf("DEV STAT = %d\n", devStat);
+            pc1.printf("CBDONE = %d\n", cbDone);
+            //wait(10);
+        }
+    }
+    // Cleanup
+    WriteReg(0, CONTROL2, 0x00, 1, FRMWRT_ALL_NR);//Reset
+    WriteReg(0, CB_DONE_THRESHOLD, 0x20, 1, FRMWRT_ALL_NR);
 }
-void waitFrameResponse(){
-    while(!full);
-    full = false;
-    for(int i = 0;i < rdLen; i++){
-        pc1.printf("%X ", recBuff[i]);
+
+void cellBalanceEnable()
+{
+    cbRun = 1;
+    cbDone = 0;
+    WriteReg(0, CB_CONFIG, 0xFA, 1, FRMWRT_ALL_NR); // Odds then Evens, continue regardless of fault condition, 30sec, seconds
+    
+    WriteReg(0, CB_DONE_THRESHOLD, 0x5F, 1, FRMWRT_ALL_NR); // Thresh hold set to value 3.6V, CBDONE comparators enabled
+    //Enabling the CBDONE voltage threshold overrides the OVUV function and pauses it.
+    
+    WriteReg(0, CB_CELL1_CTRL, 0xBC, 1, FRMWRT_ALL_NR);//cell 1- 1 minute balance timer
+    WriteReg(0, CB_CELL2_CTRL, 0xBC, 1, FRMWRT_ALL_NR);//cell 2- 1 minute balance timer
+    WriteReg(0, CB_CELL3_CTRL, 0xBC, 1, FRMWRT_ALL_NR);//cell 3- 1 minute balance timer
+    
+    WriteReg(0, CONTROL2, 0x30, 1, FRMWRT_ALL_NR);//BAL_GO set to 1, and TSREF enabled
+    wait_us(100);
+    pc1.printf("Setupovano balansiranje\n");
+}
+
+void waitBalancingToFinish()
+{
+      while (cbRun)
+    {
+        ReadReg(0, DEV_STAT, pFrame1, 1 , 0, FRMWRT_ALL_R);
+        wait(1);
+        devStat = recBuff[4];
+        cbRun = (devStat & 0x10) >> 4;
+        wait_us(500);
+        if (!cbRun)
+        {
+            pc1.printf("DEV STAT = %d\n", devStat);
+            pc1.printf("CBRUN = %d\n", cbRun);
+        }
     }
-    pc1.printf("\n");
+    
+    while(!cbDone)
+    {
+        ReadReg(0, DEV_STAT, pFrame1, 1 , 0, FRMWRT_ALL_R);
+        wait(1);
+        devStat = recBuff[4];
+        cbDone = (devStat & 0x40) >> 6;
+        wait_us(500);
+        if (cbDone)
+        {
+            pc1.printf("DEV STAT = %d\n", devStat);
+            pc1.printf("CBDONE = %d\n", cbDone);
+            //wait(10);
+        }
+    } 
+}
+
+void cellBalanceDisable()
+{
+     WriteReg(0, CONTROL2, 0x00, 1, FRMWRT_ALL_NR);//Reset
+     WriteReg(0, CB_DONE_THRESHOLD, 0x20, 1, FRMWRT_ALL_NR);
+}
+
+void isCellBalancingDone()
+{
+        ReadReg(0, DEV_STAT, pFrame1, 1 , 0, FRMWRT_ALL_R);
+        wait(1);
+        devStat = recBuff[4];
+        cbDone = (devStat & 0x40) >> 6;
+        cbRun = (devStat & 0x10) >> 4;
+        wait_us(500);
+        pc1.printf("cbDone= %d  cbRun= %d\n", cbDone, cbRun);
+        wait(104);
+        ReadReg(0, DEV_STAT, pFrame1, 1 , 0, FRMWRT_ALL_R);
+        wait(1);
+        devStat = recBuff[4];
+        cbDone = (devStat & 0x40) >> 6;
+        cbRun = (devStat & 0x10) >> 4;  
 }
 
+void faultRead()
+{
+    pc1.printf("\n FAULT REGISTER STATUS START \n");
+    
+    ReadReg(0, GPIO_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    gpioFault = waitRegRead();
+    GPIOHandler();
+    
+    ReadReg(0, UV_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    uvFault = waitRegRead();
+    UVHandler();
+    
+    ReadReg(0, OV_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    ovFault = waitRegRead();
+    OVHandler();
+    
+    ReadReg(0, UT_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    utFault = waitRegRead();
+    UTHandler();
+    
+    ReadReg(0, OT_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    otFault = waitRegRead();
+    OTHandler();
+    
+    ReadReg(0, TONE_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    toneFault = waitRegRead();
+    ToneHandler();
+    
+    ReadReg(0, COMM_UART_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    uartFault = waitRegRead();
+    UARTHandler();
+    
+    ReadReg(0, COMM_UART_RC_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    uartRCFault = waitRegRead();
+    UARTRCHandler();
+    
+    ReadReg(0, COMM_UART_RR_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    uartRRFault = waitRegRead();
+    UARTRRHandler();
+    
+    ReadReg(0, COMM_UART_TR_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    uartTRFault = waitRegRead();
+    UARTTRHandler();
+    
+    ReadReg(0, COMM_COMH_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMHFault = waitRegRead();
+    COMHHandler();
+    
+    ReadReg(0, COMM_COMH_RC_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMHRCFault = waitRegRead();
+    COMHRCHandler();
+    
+    ReadReg(0, COMM_COMH_RR_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMHRRFault = waitRegRead();
+    COMHRRHandler();
+    
+    ReadReg(0, COMM_COMH_TR_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMHTRFault = waitRegRead();
+    COMHTRHandler();
+    
+    ReadReg(0, COMM_COML_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMLFault = waitRegRead();
+    COMLHandler();
+
+    ReadReg(0, COMM_COML_RC_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMLRCFault = waitRegRead();
+    COMLRCHandler();
+    
+    ReadReg(0, COMM_COML_RR_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMLRRFault = waitRegRead();
+    COMLRRHandler();
+    
+    ReadReg(0, COMM_COML_TR_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    COMLTRFault = waitRegRead();
+    COMLHandler();
+    
+    ReadReg(0, OTP_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    otpFault = waitRegRead();
+    OTPHandler();
+    
+    ReadReg(0, RAIL_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R);
+    railFault = waitRegRead();
+    RAILHandler();
+    
+    ReadReg(0, OVUV_BIST_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    ovuvBistFault = waitRegRead();
+    OVUVBISTHandler();
+    
+    ReadReg(0, OTUT_BIST_FAULT, pFrame1, 1, 0, FRMWRT_ALL_R); 
+    otutBistFault = waitRegRead();
+    OTUTBISTHandler();
+    
+    pc1.printf("FAULT REGISTER STATUS END \n\n");
+}
+
+void checkDeviceStatus()
+{
+    pc1.printf("\n DEVICE STATUS START \n");
+    
+    ReadReg(0, FAULT_SUM, pFrame1, 1, 0, FRMWRT_SGL_R);
+    faultSUM = waitRegRead();
+    pc1.printf("Fault sum = %X\n", faultSUM);
+    
+    if(faultSUM != 0)
+    {
+        faultRead();
+    }
+    
+    ReadReg(0, DEV_STAT, pFrame1, 1, 0, FRMWRT_SGL_R);
+    DEVStat = waitRegRead();
+    pc1.printf("DEV STAT = %X\n", DEVStat);
+    
+    pc1.printf("DEVICE STATUS END\n");
+}
+
+void requestTemperature()
+{
+    WriteReg(0, CONTROL2, 0x02, 1, FRMWRT_ALL_NR);
+    ReadReg(0, AUX_GPIO1H, pFrame1, 2 , 0, FRMWRT_ALL_R); 
+        
+    waitFrameTemp();   
+    wait(1);
+}
+
+void requestVoltage()
+{
+    ReadReg(0, VCELL1H , pFrame1, 6 , 0, FRMWRT_ALL_R); //6 bajtova jer cita od adrese VCELL1H po dva bajta za svaki kanal (ima 3 kanala)
+    waitFrame();
+}
 
 int main(){
-    pc1.printf("Main ulazak\n");
     bms.attach(&callback);
-    pc1.printf("Main after attacha\n");
     Wake79606();
-    pc1.printf("woken up\n");
-    //DigitalOut(PA_0, 0);
-    //DigitalOut(PA_1, 0);
-    //wait(1);
-    //DigitalOut(PA_0, 1);
-    //DigitalOut(PA_1, 1);
-    //bms(PA_0, PA_1, 250000);
+
     bms.baud(10);
     bms.send_break();
     bms.baud(250000);
-    //wait_ms(500);
-    //bms.clear_break();
     
-    wait(2); //marta rekla da mozda treba da se doda wait
+    //wait(2); //marta rekla da mozda treba da se doda wait
     AutoAddress();
     
     
@@ -126,6 +365,7 @@
     
     wait(2);
     init();
+    arrayInit();
     /*WriteReg(0, COMM_TO, 0x00, 1, FRMWRT_ALL_NR); //disable COMM timeout because printf takes a long time between reads
     WriteReg(0, SYSFLT1_FLT_RST, 0xFFFFFF, 3, FRMWRT_ALL_NR);   //reset system faults
     WriteReg(0, SYSFLT1_FLT_MSK, 0xFFFFFF, 3, FRMWRT_ALL_NR);   //mask system faults (so we can test boards and not worry about triggering these faults accidentally)
@@ -133,37 +373,18 @@
     //SET UP MAIN ADC
     WriteReg(0, CELL_ADC_CTRL, 0x3F, 1, FRMWRT_ALL_NR);     //enable conversions for all cells
     WriteReg(0, CELL_ADC_CONF2, 0x08, 1, FRMWRT_ALL_NR);    //set continuous ADC conversions, and set minimum conversion interval
-    WriteReg(0, CONTROL2, 0x01, 1, FRMWRT_ALL_NR);          //CELL_ADC_GO = 1
-    wait_ms(5);*/
+    WriteReg(0, CONTROL2, 0x01, 1, FRMWRT_ALL_NR);          //CELL_ADC_GO = 1*/
     
-    //bmsWakeUp = 0;
-    pc1.printf("Pre while-a\n");
     while (1) {
-        pc1.printf("Main Code \n");
-                
-        pc1.printf("Board 0 \n");
-        
-        
-        
         
-        wait(2);
-        //while(bms.readable()) bms.getc();
-        int rdLen = ReadReg(0, VCELL1H , pFrame1, 6 , 0, FRMWRT_ALL_R); //6 bajtova jer cita od adrese VCELL1H po dva bajta za svaki kanal (ima 3 kanala)
-        
-        
-        
-        waitFrame();
+        requestVoltage();
+        requestTemperature();
+        /*cellBalanceEnable();
+        waitBalancingToFinish();
+        cellBalanceDisable();
+        isCellBalancingDone();*/
         
-        WriteReg(0, CONTROL2, 0x02, 1, FRMWRT_ALL_NR);
-        ReadReg(0, AUX_GPIO1H, pFrame1, 2 , 0, FRMWRT_ALL_R); 
-        
-        waitFrameTemp();
-        
-        
-        //slanje zahteva za GRESKAMA
-        //ReadReg(0, 0x52, &wTemp, 2, 0); // 0ms timeout
-        //waitFrameResponse();
-        
+        checkDeviceStatus();
 
     }
     

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ntc.h	Sun Apr 11 09:08:16 2021 +0000
@@ -0,0 +1,202 @@
+#include "mbed.h"
+const int n = 71;
+
+int arrayTemp[n];
+volatile double Vin = 5;
+volatile double Rref = 13000;
+
+void arrayInit()
+{
+    arrayTemp[0] = 32650;
+    
+    arrayTemp[1] = 31029;
+    
+    arrayTemp[2] = 29498;
+    
+    arrayTemp[3] = 28052;
+    
+    arrayTemp[4] = 26685;
+    
+    arrayTemp[5] = 25392;
+    
+    arrayTemp[6] = 24170;
+    
+    arrayTemp[7] = 23013;
+    
+    arrayTemp[8] = 21918;
+    
+    arrayTemp[9] = 20882;
+    
+    arrayTemp[10] = 19901;
+    
+    arrayTemp[11] = 18971;
+    
+    arrayTemp[12] = 18090;
+    
+    arrayTemp[13] = 17255;
+    
+    arrayTemp[14] = 16463;
+    
+    arrayTemp[15] = 15712;
+    
+    arrayTemp[16] = 14999;
+    
+    arrayTemp[17] = 14323;
+    
+    arrayTemp[18] = 13681;
+    
+    arrayTemp[19] = 13072;
+    
+    arrayTemp[20] = 12493;
+    
+    arrayTemp[21] = 11942;
+    
+    arrayTemp[22] = 11419;
+    
+    arrayTemp[23] = 10922;
+    
+    arrayTemp[24] = 10450;
+    
+    arrayTemp[25] = 10000;
+    
+    arrayTemp[26] = 9572;
+    
+    arrayTemp[27] = 9165;
+    
+    arrayTemp[28] = 8777;
+    
+    arrayTemp[29] = 8408;
+    
+    arrayTemp[30] = 8057;
+    
+    arrayTemp[31] = 7722;
+    
+    arrayTemp[32] = 7402;
+    
+    arrayTemp[33] = 7098;
+    
+    arrayTemp[34] = 6808;
+    
+    arrayTemp[35] = 6531;
+    
+    arrayTemp[36] = 6267;
+    
+    arrayTemp[37] = 6015;
+    
+    arrayTemp[38] = 5775;
+    
+    arrayTemp[39] = 5545;
+    
+    arrayTemp[40] = 5326;
+    
+    arrayTemp[41] = 5117;
+    
+    arrayTemp[42] = 4917;
+    
+    arrayTemp[43] = 4725;
+    
+    arrayTemp[44] = 4543;
+    
+    arrayTemp[45] = 4368;
+    
+    arrayTemp[46] = 4201;
+    
+    arrayTemp[47] = 4041;
+    
+    arrayTemp[48] = 3888;
+    
+    arrayTemp[49] = 3742;
+    
+    arrayTemp[50] = 3602;
+    
+    arrayTemp[51] = 3468;
+    
+    arrayTemp[52] = 3340;
+    
+    arrayTemp[53] = 3217;
+    
+    arrayTemp[54] = 3099;
+    
+    arrayTemp[55] = 2986;
+    
+    arrayTemp[56] = 2878;
+    
+    arrayTemp[57] = 2774;
+    
+    arrayTemp[58] = 2675;
+    
+    arrayTemp[59] = 2579;
+    
+    arrayTemp[60] = 2488;
+    
+    arrayTemp[61] = 2400;
+    
+    arrayTemp[62] = 2316;
+    
+    arrayTemp[63] = 2235;
+    
+    arrayTemp[64] = 2157;
+    
+    arrayTemp[65] = 2083;
+    
+    arrayTemp[66] = 2011;
+    
+    arrayTemp[67] = 1942;
+    
+    arrayTemp[68] = 1876;
+    
+    arrayTemp[69] = 1813;
+    
+    arrayTemp[70] = 1752;
+}
+
+double temp_funkcija_prenosa(double x)
+{
+    double mres1 = 1+((x*1000000000)/3.225804);
+    double mres2 = pow(mres1, 0.1409242);
+    double res = -139.9343 + (9663.0153/mres2);
+    return res;
+}
+
+double binarySearch(double resistance)
+{
+    if (resistance >= 1752 && resistance <= 32650)
+    { 
+        int front;
+        int rear;
+        int mid;
+        front = 0;
+        rear = 71 - 1;
+        while(front <= rear)
+        {
+            mid = (front + rear)/2; 
+            if (arrayTemp[mid] > resistance && arrayTemp[mid + 1] < resistance )
+            {
+                return (mid + mid + 1) / 2;
+            }
+            else if (arrayTemp[mid] < resistance && arrayTemp[mid-1] > resistance)
+            {
+               return (mid + mid - 1) / 2;
+            }
+            else if (arrayTemp[mid] > resistance )
+            {
+                front = mid;
+            }
+            else
+            {
+                rear = mid;
+            }
+        }    
+    }
+    
+    return temp_funkcija_prenosa(resistance); 
+    
+} 
+int naponskiRazdelnik(double Vout)
+{
+    double Rterm = Rref * (Vin/Vout - 1);
+    pc1.printf("Otpornost NTC-a  = %6.2f OHM\n", Rterm);
+    double temperature = binarySearch(Rterm);
+    pc1.printf("Temperature of GPIO1  = %6.2f C\n", temperature);
+    return temperature;
+}
\ No newline at end of file