Revision 194:ab528911780d, committed 2016-06-29

Comitter:

ee12b079

Date:

Wed Jun 29 14:24:12 2016 +0000

Parent:

193:f76b475d7807

Child:

195:6a549c0e9287

Commit message:

Sdcard function updated

Changed in this revision

--- a/DefinitionsAndGlobals.h	Wed Jun 29 14:12:43 2016 +0000
+++ b/DefinitionsAndGlobals.h	Wed Jun 29 14:24:12 2016 +0000
@@ -184,4 +184,8 @@
 CDMS_HK_actual actual_data;
 CDMS_HK_quant quant_data;
 CDMS_HK_min_max min_max_data;
-bool firstCount=true;
\ No newline at end of file
+bool firstCount=true;
+
+//SD HK
+uint32_t FSC_CURRENT[6];
+uint32_t FSC_LAST[6];
\ No newline at end of file

--- a/cdms_sd.h	Wed Jun 29 14:12:43 2016 +0000
+++ b/cdms_sd.h	Wed Jun 29 14:24:12 2016 +0000
@@ -23,22 +23,29 @@
 
 #define SD_MAX_CYCLES 10000
 
-extern uint8_t SD_INIT_FLAGS;
+uint32_t SD_SCP_FIRST=1001;
+uint32_t SD_SCP_LAST=2000;
+uint32_t SD_SFF_AT_FIRST=2001;
+uint32_t SD_SFF_AT_LAST = 3000;
+uint32_t SD_SFF_BT_FIRST =3001;
+uint32_t SD_SFF_BT_LAST=4000;
+uint32_t SD_HK_ARCH_FIRST=4001;
+uint32_t SD_HK_ARCH_LAST= 5000;
+uint32_t LOG_FIRST =5001;
+uint32_t LOG_LAST=6000;
+uint32_t SD_MNG_SECT=7000;
 
-
+extern uint8_t SD_INIT_FLAGS;
 
 int initialise_card();
 int initialise_card_v1();
 int initialise_card_v2();
 int disk_write(const uint8_t *, uint64_t);
 int disk_read(uint8_t *, uint64_t);
-int disk_initialize();
 int disk_erase(int,int);
 
-//void FCTN_CDMS_INIT_SD();
-//int FCTN_CDMS_WR_SD(const uint8_t *, uint64_t);
-//int FCTN_CDMS_RD_SD(uint8_t *, uint64_t);
-uint32_t FCTN_SD_MNGR(uint8_t);
+uint32_t FCTN_SD_MNG(uint8_t);
+int INCREMENT_SD_LIB(uint8_t);
 
 
 int cmd(int, int);
@@ -49,7 +56,7 @@
 int write(const uint8_t*, uint32_t );
 static uint32_t ext_bits(unsigned char *, int , int );
 int SD_WRITE(uint8_t*,uint32_t,uint8_t);
-void FCTN_CDMS_SD_INIT();
+int FCTN_CDMS_SD_INIT();
 int SD_READ(uint8_t*,uint32_t,uint8_t);
 #define SDCARD_FAIL 0
 #define SDCARD_V1   1
@@ -57,145 +64,221 @@
 #define SDCARD_V2HC 3
 
 
-
-
-
-
-
-
-
-
-
 int cdv;
 uint64_t sd_sectors();
 uint64_t sectors;
 
-void FCTN_CDMS_SD_INIT()
-{
-   
-    initialise_card();
-    
-    disk_initialize();
-         
+int FCTN_CDMS_SD_INIT()
+{   
+    int i = initialise_card();
+    debug_if(SD_DBG, "init card = %d\n", i);
+    sectors = sd_sectors();
+
+    // Set block length to 512 (CMD16)
+    if (cmd(16, 512) != 0) {
+        debug("\rSet 512-byte block timed out\r\n");
+        return 1;
+    } else {
+    //printf("\rDisk initialization successfull\r\n");
+    }
+
+    spi.frequency(1000000); // Set to 1MHz for data transfer
+    return 0;
 }
 
     
 
 uint32_t  FCTN_SD_MNGR(uint8_t sid)
-
 {
-   
-    uint32_t SD_MNG_SECT=7000;
-    
     uint32_t fsc;
+    uint32_t start_fsc;
     uint8_t buffer[512];
     int b=disk_read(buffer, SD_MNG_SECT);
-    if(sid==0x1)
+    if(sid==0x01)
     {
-        
         fsc=(uint32_t)(buffer[0]<<24)+(uint32_t)(buffer[1]<<16)+(uint32_t)(buffer[2]<<8)+(uint32_t)buffer[3];
-        uint32_t next_fsc=fsc+1;
-        buffer[0]=(uint8_t) (next_fsc>>24 & 0xFF);
-        buffer[1]=(uint8_t) (next_fsc>>16 & 0xFF);
-        buffer[2]=(uint8_t) (next_fsc>>8 & 0xFF);
-        buffer[3]=(uint8_t) (next_fsc & 0xFF);
-        buffer[511]+=2;
-        disk_write(buffer,SD_MNG_SECT);
+        start_fsc=(uint32_t)(buffer[4]<<24)+(uint32_t)(buffer[5]<<16)+(uint32_t)(buffer[6]<<8)+(uint32_t)buffer[7];
+        FSC_CURRENT[1] = fsc;
+        FSC_LAST[1] = start_fsc;
+    }
+    if(sid==0x02)
+    {
+        fsc=(uint32_t)(buffer[8]<<24)+(uint32_t)(buffer[9]<<16)+(uint32_t)(buffer[10]<<8)+(uint32_t)buffer[11];
+        start_fsc=(uint32_t)(buffer[12]<<24)+(uint32_t)(buffer[13]<<16)+(uint32_t)(buffer[14]<<8)+(uint32_t)buffer[15];
+        FSC_CURRENT[2] = fsc;
+        FSC_LAST[2] = start_fsc;
+    }
+    if(sid==0x03)
+    {
+        fsc=(uint32_t)(buffer[16]<<24)+(uint32_t)(buffer[17]<<16)+(uint32_t)(buffer[18]<<8)+(uint32_t)buffer[19];
+        start_fsc=(uint32_t)(buffer[20]<<24)+(uint32_t)(buffer[21]<<16)+(uint32_t)(buffer[22]<<8)+(uint32_t)buffer[23];
+        FSC_CURRENT[3] = fsc;
+        FSC_LAST[3] = start_fsc;
+    }
+    if(sid==0x04)
+    {
+        fsc=(uint32_t)(buffer[24]<<24)+(uint32_t)(buffer[25]<<16)+(uint32_t)(buffer[26]<<8)+(uint32_t)buffer[27];
+        start_fsc=(uint32_t)(buffer[28]<<24)+(uint32_t)(buffer[29]<<16)+(uint32_t)(buffer[30]<<8)+(uint32_t)buffer[31];
+        FSC_CURRENT[4] = fsc;
+        FSC_LAST[4] = start_fsc;
     }
-    if(sid==0x2)
+    if(sid==0x05)
+    {
+        fsc=(uint32_t)(buffer[32]<<24)+(uint32_t)(buffer[33]<<16)+(uint32_t)(buffer[34]<<8)+(uint32_t)buffer[35];
+        start_fsc=(uint32_t)(buffer[36]<<24)+(uint32_t)(buffer[37]<<16)+(uint32_t)(buffer[38]<<8)+(uint32_t)buffer[39];
+        FSC_CURRENT[5] = fsc;
+        FSC_LAST[5] = start_fsc;
+    }
+    return fsc;
+}
+
+int INCREMENT_SD_LIB(uint8_t sid)
+{
+    uint32_t fsc;
+    uint32_t start_fsc;
+    uint8_t buffer[512];
+    disk_read(buffer,SD_MNG_SECT);
+    if(sid==0x01)
     {
-        fsc=(uint32_t)(buffer[4]<<24)+(uint32_t)(buffer[5]<<16)+(uint32_t)(buffer[6]<<8)+(uint32_t)buffer[7];
-        uint32_t next_fsc=fsc+1;
-        buffer[4]=(uint8_t) (next_fsc>>24 & 0xFF);
-        buffer[5]=(uint8_t) (next_fsc>>16 & 0xFF);
-        buffer[6]=(uint8_t) (next_fsc>>8 & 0xFF);
-        buffer[7]=(uint8_t) (next_fsc & 0xFF);
-        buffer[511]+=2;
-        disk_write(buffer,SD_MNG_SECT);
+        fsc=(uint32_t)(buffer[0]<<24)+(uint32_t)(buffer[1]<<16)+(uint32_t)(buffer[2]<<8)+(uint32_t)buffer[3];
+        start_fsc=(uint32_t)(buffer[4]<<24)+(uint32_t)(buffer[5]<<16)+(uint32_t)(buffer[6]<<8)+(uint32_t)buffer[7];
+        buffer[0]=(uint8_t) (fsc>>24 & 0xFF);
+        buffer[1]=(uint8_t) (fsc>>16 & 0xFF);
+        buffer[2]=(uint8_t) (fsc>>8 & 0xFF);
+        buffer[3]=(uint8_t) (fsc & 0xFF);
+        if(fsc > SD_SCP_LAST-SD_SCP_FIRST+1)
+        {
+            start_fsc = start_fsc+1;
+            buffer[4]=(uint8_t) (start_fsc>>24 & 0xFF);
+            buffer[5]=(uint8_t) (start_fsc>>16 & 0xFF);
+            buffer[6]=(uint8_t) (start_fsc>>8 & 0xFF);
+            buffer[7]=(uint8_t) (start_fsc & 0xFF);
+        }
+        return disk_write(buffer,SD_MNG_SECT);
     }
-    if(sid==0x3)
+    if(sid==0x02)
     {
         fsc=(uint32_t)(buffer[8]<<24)+(uint32_t)(buffer[9]<<16)+(uint32_t)(buffer[10]<<8)+(uint32_t)buffer[11];
-        uint32_t next_fsc=fsc+1;
-        buffer[8]=(uint8_t) (next_fsc>>24 & 0xFF);
-        buffer[9]=(uint8_t) (next_fsc>>16 & 0xFF);
-        buffer[10]=(uint8_t) (next_fsc>>8 & 0xFF);
-        buffer[11]=(uint8_t) (next_fsc & 0xFF);
-        buffer[511]+=2;
-        disk_write(buffer,SD_MNG_SECT);
+        start_fsc=(uint32_t)(buffer[12]<<24)+(uint32_t)(buffer[13]<<16)+(uint32_t)(buffer[14]<<8)+(uint32_t)buffer[15];
+        buffer[8]=(uint8_t) (fsc>>24 & 0xFF);
+        buffer[9]=(uint8_t) (fsc>>16 & 0xFF);
+        buffer[10]=(uint8_t) (fsc>>8 & 0xFF);
+        buffer[11]=(uint8_t) (fsc & 0xFF);
+        if(fsc > SD_SFF_AT_LAST-SD_SFF_AT_FIRST+1)
+        {
+            start_fsc = start_fsc+1;
+            buffer[12]=(uint8_t) (start_fsc>>24 & 0xFF);
+            buffer[13]=(uint8_t) (start_fsc>>16 & 0xFF);
+            buffer[14]=(uint8_t) (start_fsc>>8 & 0xFF);
+            buffer[15]=(uint8_t) (start_fsc & 0xFF);
+        }
+        return disk_write(buffer,SD_MNG_SECT);
     }
-     if(sid==0x4)
-    {
-        fsc=(uint32_t)(buffer[12]<<24)+(uint32_t)(buffer[13]<<16)+(uint32_t)(buffer[14]<<8)+(uint32_t)buffer[15];
-        uint32_t next_fsc=fsc+1;
-        buffer[12]=(uint8_t) (next_fsc>>24 & 0xFF);
-        buffer[13]=(uint8_t) (next_fsc>>16 & 0xFF);
-        buffer[14]=(uint8_t) (next_fsc>>8 & 0xFF);
-        buffer[15]=(uint8_t) (next_fsc & 0xFF);
-        buffer[511]+=2;
-        disk_write(buffer,SD_MNG_SECT);
-    }
-     if(sid==0x5)
+    if(sid==0x03)
     {
         fsc=(uint32_t)(buffer[16]<<24)+(uint32_t)(buffer[17]<<16)+(uint32_t)(buffer[18]<<8)+(uint32_t)buffer[19];
-        uint32_t next_fsc=fsc+1;
-        buffer[16]=(uint8_t) (next_fsc>>24 & 0xFF);
-        buffer[17]=(uint8_t) (next_fsc>>16 & 0xFF);
-        buffer[18]=(uint8_t) (next_fsc>>8 & 0xFF);
-        buffer[19]=(uint8_t) (next_fsc & 0xFF);
-        buffer[511]+=2;
-        disk_write(buffer,SD_MNG_SECT);
+        start_fsc=(uint32_t)(buffer[20]<<24)+(uint32_t)(buffer[21]<<16)+(uint32_t)(buffer[22]<<8)+(uint32_t)buffer[23];
+        buffer[16]=(uint8_t) (fsc>>24 & 0xFF);
+        buffer[17]=(uint8_t) (fsc>>16 & 0xFF);
+        buffer[18]=(uint8_t) (fsc>>8 & 0xFF);
+        buffer[19]=(uint8_t) (fsc & 0xFF);
+        if(fsc > SD_SFF_BT_LAST-SD_SFF_BT_FIRST+1)
+        {
+            start_fsc = start_fsc+1;
+            buffer[20]=(uint8_t) (start_fsc>>24 & 0xFF);
+            buffer[21]=(uint8_t) (start_fsc>>16 & 0xFF);
+            buffer[22]=(uint8_t) (start_fsc>>8 & 0xFF);
+            buffer[23]=(uint8_t) (start_fsc & 0xFF);
+        }
+        return disk_write(buffer,SD_MNG_SECT);
     }
-    return fsc;
+     if(sid==0x04)
+    {
+        fsc=(uint32_t)(buffer[24]<<24)+(uint32_t)(buffer[25]<<16)+(uint32_t)(buffer[26]<<8)+(uint32_t)buffer[27];
+        start_fsc=(uint32_t)(buffer[28]<<24)+(uint32_t)(buffer[29]<<16)+(uint32_t)(buffer[30]<<8)+(uint32_t)buffer[31];
+        buffer[24]=(uint8_t) (fsc>>24 & 0xFF);
+        buffer[25]=(uint8_t) (fsc>>16 & 0xFF);
+        buffer[26]=(uint8_t) (fsc>>8 & 0xFF);
+        buffer[27]=(uint8_t) (fsc & 0xFF);
+        if(fsc > SD_HK_ARCH_LAST-SD_HK_ARCH_FIRST+1)
+        {
+            start_fsc = start_fsc+1;
+            buffer[28]=(uint8_t) (start_fsc>>24 & 0xFF);
+            buffer[29]=(uint8_t) (start_fsc>>16 & 0xFF);
+            buffer[30]=(uint8_t) (start_fsc>>8 & 0xFF);
+            buffer[31]=(uint8_t) (start_fsc & 0xFF);
+        }
+        return disk_write(buffer,SD_MNG_SECT);
+    }
+     if(sid==0x05)
+    {
+        fsc=(uint32_t)(buffer[32]<<24)+(uint32_t)(buffer[33]<<16)+(uint32_t)(buffer[34]<<8)+(uint32_t)buffer[35];
+        start_fsc=(uint32_t)(buffer[36]<<24)+(uint32_t)(buffer[37]<<16)+(uint32_t)(buffer[38]<<8)+(uint32_t)buffer[39];
+        buffer[32]=(uint8_t) (fsc>>24 & 0xFF);
+        buffer[33]=(uint8_t) (fsc>>16 & 0xFF);
+        buffer[34]=(uint8_t) (fsc>>8 & 0xFF);
+        buffer[35]=(uint8_t) (fsc & 0xFF);
+        if(fsc > LOG_LAST-LOG_FIRST+1)
+        {
+            start_fsc = start_fsc+1;
+            buffer[36]=(uint8_t) (start_fsc>>24 & 0xFF);
+            buffer[37]=(uint8_t) (start_fsc>>16 & 0xFF);
+            buffer[38]=(uint8_t) (start_fsc>>8 & 0xFF);
+            buffer[39]=(uint8_t) (start_fsc & 0xFF);
+        }
+        return disk_write(buffer,SD_MNG_SECT);
+    }
+    return -1;
 }
 
 
 int SD_WRITE(uint8_t* buffer,uint32_t fsc,uint8_t sid)
 {
-   
-    uint32_t SD_SCP_FIRST=1001;
-    uint32_t SD_SCP_LAST=2000;
-    uint32_t SD_SFF_AT_FIRST=2001;
-    uint32_t SD_SFF_AT_LAST = 3000;
-    uint32_t SD_SFF_BT_FIRST =3001;
-    uint32_t SD_SFF_BT_LAST=4000;
-    uint32_t SD_HK_ARCH_FIRST=4001;
-    uint32_t SD_HK_ARCH_LAST= 5000;
-    uint32_t LOG_FIRST =5001;
-    uint32_t LOG_LAST=6000;
-    uint32_t SD_MNG_SECT=7000;
     uint32_t block_number;
-    int result;
-    if(sid==0x0)
+    int result = 10;
+    if(sid==0x01)
     {
+        //block_number=SD_SCP_FIRST+(fsc%(SD_SCP_LAST-SD_SCP_FIRST+1))-1;
         block_number=SD_SCP_FIRST+fsc;
-//        printf("write_block_number=%d\r\n",block_number);
         result= disk_write(buffer,block_number);
+        if(result == 0)
+            INCREMENT_SD_LIB(sid);
+        return result;
+    }
+   if(sid==0x02)
+    {
+        //block_number= SD_SFF_AT_FIRST+(fsc%(SD_SFF_AT_LAST - SD_SFF_AT_FIRST+1))-1;
+        block_number= SD_SFF_AT_FIRST+fsc;
+        result= disk_write(buffer,block_number);
+        if(result == 0)
+            INCREMENT_SD_LIB(sid);
         return result;
     }
-   if(sid==0x1)
+     if(sid==0x03)
     {
-        block_number=SD_SFF_AT_FIRST + fsc;
+        //block_number= SD_SFF_BT_FIRST +(fsc%(SD_SFF_BT_LAST - SD_SFF_BT_FIRST +1))-1;
+        block_number= SD_SFF_BT_FIRST +fsc;
         result= disk_write(buffer,block_number);
-        return result;
-    }
-     if(sid==0x2)
-    {
-        block_number=SD_SFF_BT_FIRST + fsc;
-        result= disk_write(buffer,block_number);
+        if(result == 0)
+            INCREMENT_SD_LIB(sid);
         return result;
     }
-     if(sid==0x3)
+     if(sid==0x04)
     {
-        block_number=SD_HK_ARCH_FIRST+fsc;
-//        sd1.printf("Block number is %d \r\n",block_number);
+        //block_number=SD_HK_ARCH_FIRST +(fsc%(SD_HK_ARCH_LAST - SD_HK_ARCH_FIRST +1))-1;
+        block_number=SD_HK_ARCH_FIRST +fsc;
         result= disk_write(buffer,block_number);
+        if(result == 0)
+            INCREMENT_SD_LIB(sid);
         return result;
     }
-     if(sid==0x4)
+     if(sid==0x05)
     {
-        block_number=LOG_FIRST +fsc;
+        //block_number= LOG_FIRST +(fsc%(LOG_FIRST - LOG_FIRST +1))-1;
+        block_number= LOG_FIRST +fsc;
         result= disk_write(buffer,block_number);
+        if(result == 0)
+            INCREMENT_SD_LIB(sid);
         return result;
     }
     return 1;
@@ -203,42 +286,29 @@
 
 int SD_READ(uint8_t* buffer,uint32_t fsc,uint8_t sid)
 {
-   
-    uint32_t SD_SCP_FIRST=1001;
-    uint32_t SD_SCP_LAST=2000;
-    uint32_t SD_SFF_AT_FIRST=2001;
-    uint32_t SD_SFF_AT_LAST = 3000;
-    uint32_t SD_SFF_BT_FIRST =3001;
-    uint32_t SD_SFF_BT_LAST=4000;
-    uint32_t SD_HK_ARCH_FIRST=4001;
-    uint32_t SD_HK_ARCH_LAST= 5000;
-    uint32_t LOG_FIRST =5001;
-    uint32_t LOG_LAST=6000;
-    uint32_t SD_MNG_SECT=7000;
     uint32_t block_number;
     int result;
-    if(sid==0x0)
+    if(sid==0x01)
     {
         block_number=SD_SCP_FIRST + fsc;
-//        sd1.printf("read_block_number=%d\r\n",block_number);
         result= disk_read(buffer,block_number);
     }
-   else if(sid==0x1)
+   else if(sid==0x02)
     {
         block_number=SD_SFF_AT_FIRST + fsc;
         result= disk_read(buffer,block_number);
     }
-    else if(sid==0x2)
+    else if(sid==0x03)
     {
         block_number=SD_SFF_BT_FIRST + fsc;
         result= disk_read(buffer,block_number);
     }
-    else if(sid==0x3)
+    else if(sid==0x04)
     {
         block_number=SD_HK_ARCH_FIRST + fsc;
         result= disk_read(buffer,block_number);
     }
-    else if(sid==0x4)
+    else if(sid==0x05)
     {
         block_number=LOG_FIRST +fsc;
         result= disk_read(buffer,block_number);
@@ -259,21 +329,25 @@
     for (int i = 0; i < 16; i++) {
         spi.write(0xFF);
     }
-
+    uint8_t R1_response = cmd(0,0);
+    gPC.printf("0x%02X",R1_response);
     // send CMD0, should return with all zeros except IDLE STATE set (bit 0)
-    if (cmd(0, 0) != R1_IDLE_STATE) {
+    if (R1_response != R1_IDLE_STATE) {
         debug("No disk, or could not put SD card in to spi idle state\r\n");
         return SDCARD_FAIL;
     }
+    else
+        gPC.puts("SD Card is in IDLE state\n\r");    
 
-// send CMD8 to determine whther it is ver 2.x
+    // send CMD8 to determine whther it is ver 2.x
     int r = cmd8();
     if (r == R1_IDLE_STATE) {
-        gPC.printf("\rEntering v2\r\n");
-        return initialise_card_v2();
+        gPC.puts("Entering V2\r");
+        int q =  initialise_card_v2();
+        return q;
 
     } else if (r == (R1_IDLE_STATE | R1_ILLEGAL_COMMAND)) {
-        gPC.printf("\rEntering v1\r\n");
+        gPC.puts("Entering V1");
         return initialise_card_v1();
 
     } else {
@@ -307,13 +381,11 @@
         cmd58();
         cmd(55, 0);
         if (cmd(41, 0x40000000) == 0) {
-            #if DEBUG
-            gPC.puts("\rv2 initialization successfull\r\n");
-            #endif
+            if (DEBUG)
+                gPC.puts("\rv2 initialization successfull\r\n");
             cmd58();
             debug_if(SD_DBG, "\n\rInit: SDCARD_V2\n\r");
             cdv = 1;
-
             return SDCARD_V2;
         }
     }
@@ -487,7 +559,7 @@
     }
     cs_sd = 1;
     spi.write(0xFF);
-    return -1; // timeout
+    return 1; // timeout
 }
 
 static uint32_t ext_bits(unsigned char *data, int msb, int lsb)
@@ -506,20 +578,7 @@
 
 int disk_initialize()
 {
-    int i = initialise_card();
-    debug_if(SD_DBG, "init card = %d\n", i);
-    sectors = sd_sectors();
 
-    // Set block length to 512 (CMD16)
-    if (cmd(16, 512) != 0) {
-        debug("\rSet 512-byte block timed out\r\n");
-        return 1;
-    } else {
-        gPC.printf("\rDisk initialization successfull\r\n");
-    }
-
-    spi.frequency(1000000); // Set to 1MHz for data transfer
-    return 0;
 }
 
 int disk_write(const uint8_t *buffer, uint64_t block_number)
@@ -531,9 +590,9 @@
     }
 
     // send the data block
-    return write(buffer, 512);
+    write(buffer, 512);
     //printf("Written Successfully bro \n");
-
+    return 0;
 }
 
 int write(const uint8_t*buffer, uint32_t length)