新聞中心
        
	
        
	
        
	
        EEPW首頁 
	 > 嵌入式系統 > 設計應用 > 淺談如果通過程序讀取AT24系列芯片型號
        
    
        

        

        


	
	
	

        
	
        
		
        
			
        淺談如果通過程序讀取AT24系列芯片型號
        
						
        
				作者：
				時間：2016-11-10
				來源：網絡

							
				
				
				
				收藏
			
        

			
        
				
				
			
        

			
        
			
			
        
			
			
        
				
				
			
        
                
			對于一般的AT24芯片來說，要獲取型號并不復雜，那就是用眼睛看，這個是沒有問題的。但是，如果我們用的是AT24系列的IC卡呢？如果我們用的是白卡呢？那么怎么來判斷這張卡片究竟是什么型號的？

          對于以上問題，我們想大家都有不同的看法，但是，不知道您是否真正嘗試過呢？能正確讀取AT24C01到AT24C1024之間的各種型號嗎？

          為了解決這個問題，本人思考了好幾天，以通過多種實驗去驗證，今天終于獲取結果了，不過本人先聲明，我這里只有3中類型的卡（C02, C16, C64），每種類型有2張或以上，驗證都是正確的。如果你有其他類型的卡不妨也試試，如果嘗試了，請把結果告訴本人，在下先謝了。

          下面我們先談談這類芯片的一些基礎知識，得到這些基礎知識后，看您能否想出解決這個問題的方法，再看看方法是否和我一樣的。
        對于24C系列的IC卡來說，其讀寫操作完全和24C系列芯片的讀寫操作一致，所有，下面我們就以此系列芯片為基礎進行介紹。對于這系列芯片的資料特別多而且也非常詳細，下面我們就借《嵌入式實時操作系統Small RTOS51原理及應用》中的第20章串行E2PROM芯片Cat24WCxx驅動程序的內容來描述。

           雖然這一章中講的芯片不是ATMEL的，但是和這一系列完全兼容。

        1. 參數表




        2. 器件地址表



        3. 數據地址表

        3.png(92.89 KB, 下載次數: 0)
        本文引用地址：http://www.104case.com/article/201611/317396.htm
        下載附件保存到相冊
        2013-10-25 07:58 上傳



        4. 操作時序

        從上面的表格和圖我們可以獲取以下信息：

        1. 不同型號其容量不同；
        2. 不同型號的頁寫入不同；
        3. 不同型號的擴展數量不同。

          還可以看出，對于24C01/02/04/08/16的數據地址只有1字節，而24C32/64/128/256等的數據地址為兩字節。我們仔細想想發現，1字節的數據地址對于24C01/02剛好夠用，而對于24C04/08/16來說卻不夠用，所以，還必須配合器件地址實現讀寫操作。

         至此，您是否想出分別型號的方法？
        想法1：通過訪問器件的最高地址實現.

          我們知道AT24C01的最大容量為1Kbit，以就是128字節，如果我們讀寫128以后的地址不正確，我們就可以確定這個芯片的型號就為AT24C01了。如果用同樣的方法，從大到小的訪問，應該就可以區分這一系列芯片的不同型號了。
         
           有了想法，那我們不妨試試吧。。。。。。。

         結果如何呢？你是否猜到了？



        。。。


          通過驗證我們可以獲得結論：不管是什么型號的芯片都可以正確讀寫，根本無法分辨這一系列。24C01/02以及24C32/64/128/256無法通過24C04/08/16的程序，但其他程序都可以操作。而24C04/08/16可以通過全部型號的讀寫操作。

         也就是說：我們只能把這一系列芯片分為兩大類，而無法分辨其型號。

        奇怪，這個 問題是怎樣產生的呢？

         查看芯片資料我們不難發現，如果讀寫操作超過芯片地址，它是不會返回錯誤的，而是地址回卷，又從最小的地址開始，所以，就是你寫入地址超過芯片范圍也無法獲取錯誤。

           至于24C04/08/16能夠通過各個型號芯片的讀寫程序，是以為，這三個芯片的地址有特殊性。在讀寫超過8位地址的地方是通過與頁地址配合實現的，以就是說這三個芯片的地址是由：0xA* + 8Bit構成；而24C01/02的地址是由0xA0 + 8位地址構成；24C32/64/128/256的地址是由：0xA0 + 16位地址構成。

         由這三個地址可以看出，由于24C04/08/16支持0xA*地址，所以可以通過各種格式的讀取，而其他兩類不支持0xA0以外的地址，所以當通過24C04/08/16程序讀寫這兩類芯片時就會出現錯誤。當然24C04/08/16這三個芯片的地址由有些區別，例如04的只有1位，08的有2位，16的有3位，我們可以通過程序進一步區分這三個型號。
        想法2：通過頁讀寫操作實現.

         我們知道，不同型號其頁大小是有區別的，當操作超過頁面時，芯片或滾動覆蓋，我們可以通過寫入最大頁面數據，根據讀取的數據可以知道其滾動狀態，從而讀取芯片頁面大小。

         但是，AT24C01的頁字節為8，AT24C02/04/08/16的頁字節為16，AT24C32/64的頁字節為32，AT24C128/256的頁字節為64，所以我們只能分出這4類芯片，還是無法實現所有型號的判別。
        通過上面的想法和實際可以得出，以上兩種方法都很難實現對這一系列芯片的正確讀取。下面我們通過連續寫入多字節進行試驗。

        例如：同時在芯片的最后幾個空間內同時寫入4字節的數據：
        1.  u8 tmpBuf[] = {0x00, 0x00, 0x00, 0x00};
        2.   u8 tmpDat[] = {0xAA, 0x55, 0xFF, 0x00};
        3.  
        4.   ATReadDat(type, addr-3, tmpBuf, 4);             // 數據暫存
        5.   ATWriteDat(type, addr-3, tmpDat, 4);              // 寫入驗證數據
        6.  
        7.   memset(tmpDat, 0, 4);   
        8.   ATReadDat(type, addr-3, tmpDat, 4);             // 讀取驗證數據
        9.   ATWriteDat(type, addr-3, tmpBuf, 4);              // 恢復寫入前
        11.   return ((memcmp(tmpDat, "xAAx55xFFx00", 4) == 0) ? 0x00 : 0x01);
        復制代碼
        通過以上試驗可以發現，讀寫24C02和24C16已經沒有問題，完全可以爭取的區分這兩類芯片。但還是不能讀取24C64之類的芯片。


        進一步修改代碼：


        我們知道，由于芯片超地址時會出現覆蓋寫入，那么我們能不能把基礎可能會出現覆蓋的地方寫入不同值了，如果發現覆蓋就可以說明這個型號是錯的，如果沒有覆蓋就說這個型號是對的：
        1.   u8 tmpBuf[] = {0x00, 0x00};
        2.   u8 tmpDat[] = {0xAA, 0x55};
        3.  
        4.   ATReadDat(type, ((addr+1)/2)-1, &tmpBuf[0], 1);         // 數據暫存
        5.   ATReadDat(type, addr, &tmpBuf[1], 1);         
        7.   ATWriteDat(type, ((addr+1)/2)-1, &tmpDat[0], 1);
        8.   ATWriteDat(type, addr, &tmpDat[1], 1);            // 寫入驗證數據
        9.  
        10.   memset(tmpDat, 0, 2);   
        11.   ATReadDat(type, ((addr+1)/2)-1, &tmpDat[0], 1);
        12.   ATReadDat(type, addr, &tmpDat[1], 1);             // 讀取驗證數據
        13.  
        14.   ATWriteDat(type, ((addr+1)/2)-1, &tmpBuf[0], 1);          // 恢復寫入前
        15.   ATWriteDat(type, addr, &tmpBuf[1], 1);
        17.   return ((memcmp(tmpDat, "xAAx55", 2) == 0) ? 0x00 : 0x01);
        復制代碼
        通過上面的代碼驗證獲得，現在可以區別出24C64了，但卻不能區別出24C02/16等。為什么會這樣呢？連續的讀寫可以區別24C02/16但不能區別24C64，現在雖然能區別24C64了，可其他的反而不行了，能否把這種方法和連續寫入多字節組合呢？
        1.   u8 tmpBuf[] = {0x00, 0x00, 0x00, 0x00};
        2.   u8 tmpDat[] = {0xAA, 0x55, 0xFF, 0x00};
        3.  
        4.   ATReadDat(type, ((addr+1)/2)-2, &tmpBuf[0], 2);         // 數據暫存
        5.   ATReadDat(type, addr-1, &tmpBuf[2], 2);         
        7.   ATWriteDat(type, ((addr+1)/2)-2, &tmpDat[0], 2);
        8.   ATWriteDat(type, addr-1, &tmpDat[2], 2);            // 寫入驗證數據
        9.  
        10.   memset(tmpDat, 0, 4);   
        11.   ATReadDat(type, ((addr+1)/2)-2, &tmpDat[0], 2);
        12.   ATReadDat(type, addr-1, &tmpDat[2], 2);             // 讀取驗證數據
        13.  
        14.   ATWriteDat(type, ((addr+1)/2)-2, &tmpBuf[0], 2);          // 恢復寫入前
        15.   ATWriteDat(type, addr-1, &tmpBuf[2], 2);
        17.   return ((memcmp(tmpDat, "xAAx55xFFx00", 4) == 0) ? 0x00 : 0x01);
        復制代碼
        通過上面的代碼修改和試驗，我們現在可以區別這三種型號了，通過我的推算應該是這種方法已經可以讀取這一系列的各種型號，不過由于本人手里只有這3種卡片，其他的沒有辦法試驗。

        至于為什么這樣寫可以實現，本人也還沒有一個完整的理論依據，大家不妨一起想想，如果你先想出來，請告訴我一下。
        以上的程序卻是能夠實現型號辨別，但一個新的問題出現了。例如：向24C02等單地址卡片里邊寫入雙地址數據時，由于時序的不同，芯片處理時，會把雙地址的第2字節作為數據寫入到單地址芯片中，由于我們的程序沒有考慮這一點，所以，會導致其他地址的數據出現錯誤。

          下面我們舉例說明：

           用上面的程序，我們判別型號的順序是256->128->64->32->16->08->04->02->01，寫入的地址是芯片的最大地址的最后兩個字節和芯片最大地址的一半的最后兩個字節，這樣做的目的是試圖通過數據覆蓋來判斷型號，例如，如果最大地址的最后兩個字節覆蓋了一半的最后兩個字節，固然不是這個型號。

        所以在按照24c256來想AT24C02寫入數據是，我們是通過在地址：16382（0x3FFE）寫入兩個字節（0xAA, 0x55），再在地址32766（7FFE）寫入兩個字節（0xFF, 0x00），通過讀取整片AT24C02芯片獲得：

         [48] = 0xAA，
         [49] = 0x55,
         [63] = 0xFE,

         [112] = 0xFF，
         [113] = 0x00,
         [127] = 0xFE, 

         通過仔細分析我們發現，芯片處理時，首先把地址16382（0x3FFE）分為2字節處理，高字節為地址即63（0x3F），低字節為數據0xFE，再加上AT24C02的頁面大小為16字節，地址0x3F已經是頁面的最高地址，后面再寫入數據時就會發生頁面翻轉現象，而頁面的起始地址正好是48（0x30），故而后面發生的兩字節數據就寫入了48和49.

         后面兩個字節的數據也是完全一致的現象，所以，這個程序破壞來原始數據。
        判斷出卡片型號是必須的，但絕對不能破壞數據，為此我們還必須想辦法解決這一問題：

        下面我們談談另外一思路：通過頁和地址來實現。

           我們知道AT24C01為8字節一頁， AT24C02/04/08/16為16字節一頁， AT24C32/64為32字節為一頁， AT24C128/256為64字節為一頁。我們完全可以通過寫頁數據，通過判斷是否有數據被覆蓋實現，過程如下：

          寫入16字節數據->讀寫一致為AT24C02/04/08/16中一種，否則判斷8字節是否一致，一致為AT24C01，否則為其他->通過寫最大地址判斷是否覆蓋，來判斷究竟是AT24C02/04/08/16中的那一致。其他型號過程一致，代碼如下：
        1. ATC_TYP ATCReadType(void)
        2. {
        3.   u8 i;
        4.   u8 tmpBuf[64] = {0};
        5.   u8 tmpDat[64] = {0};
        6.   u8 cmpDat[64] = {0};
        7.  
        8.   //--------------------------------- 單地址判斷 -----------------------------
        9.   for (i=0; i<16; i++)                  // 初始化
        10.   {
        11.   tmpDat[i] = i;
        12.   cmpDat[i] = i;
        13.   }
        14.  
        15.   // AT24C01的頁為8字節，AT24C02/04/08/16的頁為16字節
        16.   // 通過讀寫16來判斷頁大小，從而區分AT24C01
        17.   ATCReadNByte(AT24C02, 0, tmpBuf, 16);             // 數據暫存
        18.   ATCWriteNByte(AT24C02, 0, tmpDat, 16);            // 寫入驗證數據
        19.   memset(tmpDat, 0, 16);
        20.   ATCReadNByte(AT24C02, 0, tmpDat, 16);             // 讀驗證數據
        21.  
        22.   if (memcmp(tmpDat, cmpDat, 16) == 0)              // AT24C02/04/08/16
        23.   {
        24.   ATCWriteNByte(AT24C02, 0, tmpBuf, 16);            // 恢復數據
        25.   
        26.   // AT24C02/04/08/16中，通過頁地址共同組成地址，故可以通過頁區別型號
        27.   for (i=4; i>0; i--)                 
        28.   {
        29.     ATCReadByte((ATC_TYP)(i), ATC_Par[(ATC_TYP)(i)].MaxAddr, &tmpDat[0]);
        30.     ATCWriteByte((ATC_TYP)(i), ATC_Par[(ATC_TYP)(i)].MaxAddr, 0xAA);
        31.     ATCReadByte((ATC_TYP)(i), ATC_Par[(ATC_TYP)(i)].MaxAddr, &tmpDat[1]);
        32.     if (tmpDat[1] == 0xAA)
        33.     {
        34.       ATCWriteByte((ATC_TYP)(i), ATC_Par[(ATC_TYP)(i)].MaxAddr, tmpDat[0]);
        35.       return ((ATC_TYP)(i));
        36.     }
        37.   }
        38.   }
        39.   else
        40.   {
        41.   if (memcmp(&tmpDat[8], cmpDat, 8) == 0)           // AT24C01
        42.   {
        43.     ATCWriteNByte(AT24C01, 0, tmpBuf, 8);           // 恢復數據
        44.     return AT24C01;
        45.   }
        46.   }
        48.   //--------------------------------- 雙地址判斷 -----------------------------
        49.   for (i=0; i<64; i++)                  // 初始化
        50.   {
        51.   tmpDat[i] = i;
        52.   cmpDat[i] = i;
        53.   }
        54.  
        55.   ATCReadNByte(AT24C128, 0, tmpBuf, 64);            // 數據暫存
        56.   ATCWriteNByte(AT24C128, 0, tmpDat, 64);             // 寫入驗證數據
        57.   memset(tmpDat, 0, 64);
        58.   ATCReadNByte(AT24C128, 0, tmpDat, 64);            // 讀驗證數據
        59.  
        60.   if (memcmp(tmpDat, cmpDat, 64) == 0)              // AT24C128/256
        61.   {
        62.   ATCWriteNByte(AT24C128, 0, tmpBuf, 64);           // 恢復數據
        63.   
        64.   ATCReadByte(AT24C256, 0, &tmpDat[0]);
        65.   ATCReadByte(AT24C256, ATC_Par[AT24C128].Capacity, &tmpDat[1]);
        66.   
        67.   ATCWriteByte(AT24C256, 0, 0xAA);
        68.   ATCWriteByte(AT24C256, ATC_Par[AT24C128].Capacity, 0x55);
        69.   
        70.   ATCReadByte(AT24C256, 0, &tmpDat[2]);
        71.   ATCReadByte(AT24C256, ATC_Par[AT24C128].Capacity, &tmpDat[3]);
        72.   if ((tmpDat[2] == 0xAA) && (tmpDat[3] == 0x55))
        73.   {
        74.     ATCWriteByte(AT24C256, 0, tmpDat[0]);
        75.     ATCWriteByte(AT24C256, ATC_Par[AT24C128].Capacity, tmpDat[1]);
        76.     return AT24C256;
        77.   }
        78.   else
        79.   {
        80.     ATCWriteByte(AT24C128, 0, tmpDat[0]);
        81.     return AT24C128;
        82.   }  
        83.   }
        84.   else                        // AT24C128/256
        85.   {
        86.   if (memcmp(&tmpDat[32], cmpDat, 32) == 0)
        87.   {
        88.     ATCWriteNByte(AT24C64, 0, tmpBuf, 32);
        89.     ATCReadByte(AT24C64, 0, &tmpDat[0]);
        90.     ATCReadByte(AT24C64, ATC_Par[AT24C32].Capacity, &tmpDat[1]);
        91.     
        92.     ATCWriteByte(AT24C64, 0, 0xAA);
        93.     ATCWriteByte(AT24C64, ATC_Par[AT24C32].Capacity, 0x55);
        94.     
        95.     ATCReadByte(AT24C64, 0, &tmpDat[2]);
        96.     ATCReadByte(AT24C64, ATC_Par[AT24C32].Capacity, &tmpDat[3]);
        97.     if ((tmpDat[2] == 0xAA) && (tmpDat[3] == 0x55))
        98.     {
        99.       ATCWriteByte(AT24C64, 0, tmpDat[0]);
        100.       ATCWriteByte(AT24C64, ATC_Par[AT24C32].Capacity, tmpDat[1]);
        101.       return AT24C64;
        102.     }
        103.     else
        104.     {
        105.       ATCWriteByte(AT24C32, 0, tmpDat[0]);
        106.       return AT24C32;
        107.     }
        108.   }
        109.   } 
        111.   return ATC_TYP_MAX;
        112. }
        復制代碼
        具體代碼不再分析，代碼確實能夠實現型號識別，但是否破壞數據，暫時還沒有發現，大家不妨試試，如果破壞了數據，我們再做進一步分析并改善。
        下面我們再介紹一種比較簡單，而且不會破壞數據的方法。

         我們知道從AT24C01~256之間，由于容量和地址的區別，我們可以把這一系列分為三大類：

          1. 單地址，直接8位地址操作：AT24C01/02
          2. 單地址，8位地址加3位頁地址組合操作：AT24C04/08/16
          3. 雙地址，直接16位地址操作：AT24C32/64/128/256

         由上面的三大類我們可以看出，要區別型號，可以通過先分類，再分別通過每一類中型號的差異進行進一步的區別。

           首先我們可以看出，從地址上來分可以把以上芯片分為單地址和雙地址，從頁面組合上來分我們可以把他們分為有組合和無組合兩種，所以，我們可以通過這兩種方法先把這系列芯片分為2類，之后再進行細分。例如：

          從地址上來分->單地址為AT24C01/02/04/08/16,雙地址為AT24C32/64/128/256：
          
          1. 單地址5種芯片，有頁組合的有3種，這三種中 AT24C16由3位組合，AT24C08由2位組合，AT24C04由一位組合，所以當我們讀寫0xAE地址正確時一定是AT24C16，如果不正確，讀寫0xA6正確時一定是AT24C08，如果還不正確，讀寫0xA2正確時一定是AT24C04，如果還不正確那，一定是AT24C01/02中的一種，而對于AT24C01/02來說，不同的只是地址范圍，如果寫地址0和地址128，如果數據覆蓋，那一定是AT24C01，如果沒有覆蓋那一定是AT24C02.

          2. 雙地址4種芯片，沒有也組合，而不同的只有地址范圍，這一定和AT24C01/02是完全一致的，所以，由于區別的方法也和這兩個芯片一樣，通過覆蓋可以輕松的判斷出芯片型號。
        1. /**************************************************************************************
        2. * FunctionName : ATCReadType()
        3. * Description  : 寫器件型號
        4. * EntryParameter : None
        5. * ReturnValue  : None
        6. **************************************************************************************/
        7. u8 ATCReadType(void)
        8. {
        9.   u8 i;
        10.   u8 tmpBuf[3] = {0};
        11.   u8 tmpDat[3] = {0};
        12.  
        13.   ATCReadNByte(AT24C32, 0, tmpBuf, 1);              // 讀取雙地址0的一字節暫存
        14.   ATCReadNByte(AT24C16, 0, &tmpBuf[1], 2);            // 讀取單地址0的二字節暫存
        15.  
        16.   ATCWriteNByte(AT24C32, 0, "xA5", 1);             // 按照雙地址格式寫入一字節數據
        17.  
        18.   ATCReadNByte(AT24C32, 0, tmpDat, 1);              // 按照雙地址格式讀取一字節數據
        19.   ATCReadNByte(AT24C16, 0, &tmpDat[1], 2);            // 按照單地址格式讀取二字節數據
        20.  
        21.   if ((tmpDat[1] == 0x00) && (tmpDat[2] == 0xA5))         // 單地址芯片    
        22.   {
        23.   ATCWriteNByte(AT24C16, 0, &tmpBuf[1], 2);           // 恢復數據
        24.   
        25.   //-------------------------------- AT24c04/08/16 -----------------------
        26.   
        27.   for (i=AT24C16; i>AT24C02; i--)             // AT24c04/08/16
        28.   {
        29.     ATCReadByte(i, ATC_Par[i].MaxAddr, &tmpBuf[0]);
        30.     ATCWriteByte(i, ATC_Par[i].MaxAddr, 0xAA);
        31.     ATCReadByte(i, ATC_Par[i].MaxAddr, &tmpDat[0]);
        32.     ATCWriteByte(i, ATC_Par[i].MaxAddr, tmpBuf[0]);
        33.     
        34.     if (tmpDat[0] == 0xAA)
        35.     {
        36.       return i;
        37.     }
        38.   }
        39.   
        40.   //-------------------------------- AT24c01/02 --------------------------
        41.   
        42.   ATCReadByte(AT24C02, 0, &tmpBuf[0]);
        43.   ATCReadByte(AT24C02, 128, &tmpBuf[1]);  
        44.   ATCWriteByte(AT24C02, 0, 0xAA);
        45.   ATCWriteByte(AT24C02, 128, 0x55);
        46.   
        47.   ATCReadByte(AT24C02, 0, &tmpDat[0]);
        48.   ATCReadByte(AT24C02, 128, &tmpDat[1]);
        49.   ATCWriteByte(AT24C02, 0, tmpBuf[0]);
        50.   ATCWriteByte(AT24C02, 128, tmpBuf[1]);
        51.   
        52.   return (tmpDat[0] == 0x55) ? AT24C01 : AT24C02;
        53.   }
        54.   else
        55.   {
        56.   if (tmpDat[0] == 0xA5)                // 雙地址芯片
        57.   {
        58.     ATCWriteNByte(AT24C256, 0, &tmpBuf[0], 1);        // 恢復數據
        59.     
        60.     //-------------------------------- AT24c32/64/128/256 --------------
        61.     
        62.     for (i=AT24C256; i>AT24C16; i--)
        63.     {
        64.       ATCReadByte(i, 0, &tmpBuf[0]);
        65.       ATCReadByte(i, ATC_Par[i-1].Capacity, &tmpBuf[1]);
        66.      
        67.       ATCWriteByte(i, 0, 0xAA);
        68.       ATCWriteByte(i, ATC_Par[i-1].Capacity, 0x55);
        69.      
        70.       ATCReadByte(i, 0, &tmpDat[0]);
        71.       ATCReadByte(i, ATC_Par[i-1].Capacity, &tmpDat[1]);
        72.      
        73.       ATCWriteByte(i, 0, tmpBuf[0]);
        74.       ATCWriteByte(i, ATC_Par[i-1].Capacity, tmpBuf[1]);
        75.      
        76.       if ((tmpDat[0] == 0xAA) && (tmpDat[1] == 0x55))
        77.       {
        78.       return i;
        79.       }
        80.     }
        81.     
        82.     return AT24C256;
        83.   }
        84.   else                      // 非AT系列芯片
        85.   {
        86.     return ATC_TYP_MAX;
        87.   }
        88.   }
        89. }
        復制代碼
        對于上面的程序需要注意，我們的方法是通過寫入數據之后讀取進行判斷的，所以在寫入數據之前必須把要寫入的地址數據暫存，完成判斷后必須恢復，絕對不能破壞芯片類的數據。

           在單地址和雙地址的判斷中，我們按照兩種方法進行數據暫存，因為我們剛開始并不知道卡片究竟是什么型號，所以，在判斷出來后，按照單雙地址分別恢復也保證數據的正確性。

          還有一點需要強調，我們在按照雙地址方式，在地址0的地方寫入0xA5數據，如果芯片確實是雙地址，那么該數據一定寫入地址0，數據數據為0xA5，但是如果該芯片為單地址，那么地址的低8為就被作為數據一起寫入了，所以會導致，地址0開始寫入兩字節數據，一字節為0（地址的低8位被當做第一個數據了），一字節為0xA5（數據卻作為第2字節數據寫入了）。所以通過這兩字節數據可以輕松的判斷出究竟是單地址還是雙地址。
        
				
            
                
			
							
        
                
			              
              
            
        
		
        
		
        
		
        
		
        
		
        
			
          
				
        • 
					
					
			  	
          • 
			  	
        • 
					
					
			  	
          • 
			  	
        • 
					
					
			  	
          • 
				
        • 
					
					
				
          • 
				
        • 
					
					
				
          • 
			
        
			
        
		
        
		
		
        
		
        
			
			
		
        
        
			
		

	

        
	
	
        
		
        
			
        評論
        					
		
        
		
        
			
        
			
				
        
					
					
        
						
                        
					
        
				
        
                		
						
						
			
        
		
        
		
        
		
        
            
			
            
		
        
	
        
	
        
	
        
		
		

        


	
        
	
        
		
		
	
        


    
        
        
        技術專區
        
      
        
      
        
			
      
         
       

        

   











        
	
        
	    關閉
	
        
	
	

        














	
	



        




        





主站蜘蛛池模板：
溧水县|
云梦县|
蓝山县|
安化县|
岱山县|
璧山县|
勃利县|
南部县|
康马县|
疏附县|
阿图什市|
江都市|
姜堰市|
红桥区|
利辛县|
金寨县|
奉新县|
杨浦区|
四子王旗|
时尚|
浪卡子县|
绥宁县|
海兴县|
察雅县|
多伦县|
金阳县|
莒南县|
台东县|
沅陵县|
山阳县|
顺平县|
安阳县|
肇庆市|
南和县|
浮山县|
高淳县|
海盐县|
崇信县|
望都县|
兴城市|
罗源县|