Binary 还有其他存储二进制数的方法吗

二进制数通常与固定位置的MSB和LSB一起存储；从LSB到MSB，每一位的权重都是原来的两倍。还有其他存储二进制数的方法吗

当需要表示一个数字所需的逻辑电子位数最少时，传统方法可能是最有效的方法，但这种方法存在一些缺点。一个缺点是，当顺序计数时，LSB的切换非常高，因为它在每次递增计数时切换状态。 我试图对每个位的权重进行置乱，以便在顺序计数时，表示二进制数的每个位都具有相同的切换量。实现此方法有许多优点，即使数字需要更多位

一个优点是EEPROM的使用寿命会延长，因为在表示存储号码的所有物理单元中都会发生等量的切换。超频cpu、纠错等的另一个优点

如果示波器探针检查传统的地址总线，LSB需要做大量的工作，而MSB非常空闲

传统方法： （数目） 0000 0001 0010 0011 0100 拟议的新方法：

---

（扰码编码器）（数字）

像这样的二进制数字系统怎么样？当以非常高的总线速度计数时，晶体管不会过热，因此会限制时钟速度

该解决方案同时使用base-2和base-1二进制来生成数字

（（基-2二进制数）*以位为单位的大小（基-1二进制数））+基-1二进制数

因此，对于16位总线，高字节二进制base-2和低字节二进制base-1，最大计数为 （（2^8）-1）*8）+8）=2048

EEPROM寿命问题的解决方案可以是：

使用EEPROM，仅在写入新数据时更改所需的单元，以最大限度地延长使用寿命

4字节（32位）表示数字的基2部分，13字节（100位）表示数字的基1部分

（（32位基数-2二进制数）x100）+（100位二进制基数-1计数计数器）

最大计数为（（（2^32）-1）*100）+100）=429496729700

这种方法应该从EEPROM或闪存中获得最大的使用寿命，对于闪存，base-1数字应该反向存储，因为擦除状态是逻辑1

EEPROM可以读取、递增、写入2个数量级以上的数字，实现100万而不是1万的计数

给我发一封电子邮件，我可以给你这个程序，它在MVS 2013控制台中工作

lion@palmbeach.freeserve.co.uk

/*www.goatelectronics.com解决方案*/

/*该程序旨在测试eeprom的寿命，写入相同的页面和单元*/

/*32位base-2二进制数+100位base-1二进制数构成数字*/

/*字节0-最高有效字节，二进制基数2*/

/*字节1-*/

/*字节2-*/

/*字节3-最低有效字节，二进制基数2*/

/*字节4-32位数字的8位CRC后缀，稍后执行*/

/*字节5-二进制基数1的0到8计数*/

/*字节6-二进制基数1的计数9到16*/

/*字节7-计数17至24的*/

/*字节8-计数25到32*/

/*字节9-计数33到40*/

/*字节10-计数41至48*/

/*字节11-计数49到56*/

/*字节12-计数57到64*/

/*字节13-计数65到72*/

/*字节14-计数73到80*/

/*字节15-计数81到88*/

/*字节16-计数89到96*/

/*字节17-计数97到100*/

#include "stdafx.h"
#include <iostream>
#include <conio.h>
using namespace std;

/* emulate the eeprom *here* , byte read and write */
unsigned char eeprom[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
                       0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 

unsigned int EEPROM_read (void)
{
unsigned char i_u8;
unsigned int value_u32, value_A_u32, value_B_u32, value_C_u32,      value_D_u32 = 0;
unsigned int base_1_u32 = 0;
value_A_u32 = eeprom[0];
value_A_u32 = value_A_u32 << 24;
value_B_u32 = eeprom[1];
value_B_u32 = value_B_u32 << 16;
value_C_u32 = eeprom[2];
value_C_u32 = value_C_u32 << 8;
value_D_u32 = eeprom[3];
value_u32 = value_A_u32 | value_B_u32 | value_C_u32 | value_D_u32;
/* eeprom[4]  reserved location for CRC checksum! */

value_u32 = value_u32 * 100;

for (i_u8 = 5; eeprom[i_u8] == 0xFF; i_u8++)
{
    base_1_u32 = base_1_u32 + 8;
}

switch (eeprom[i_u8])
{
case 0x80: base_1_u32 = base_1_u32 + 1;
    break;
case 0xC0: base_1_u32 = base_1_u32 + 2;
    break;
case 0xE0: base_1_u32 = base_1_u32 + 3;
    break;
case 0xF0: base_1_u32 = base_1_u32 + 4;
    break;
case 0xF8: base_1_u32 = base_1_u32 + 5;
    break;
case 0xFC: base_1_u32 = base_1_u32 + 6;
    break;
case 0xFE: base_1_u32 = base_1_u32 + 7;
    break;
default:; /*if here, faulty EEPROM with base-1 number*/
}

value_u32 = value_u32 + base_1_u32;

return (value_u32);

}

void EEPROM_write(unsigned int number_u32)
{
unsigned char i_u8, remainder_u8;
unsigned int value_u32;

value_u32 = number_u32;

value_u32 = value_u32 / 100;

eeprom[0] = (unsigned char)((value_u32 & 0xFF000000) >> 24);
eeprom[1] = (unsigned char)((value_u32 & 0x00FF0000) >> 16);
eeprom[2] = (unsigned char)((value_u32 & 0x0000FF00) >> 8);
eeprom[3] = (unsigned char)((value_u32 & 0x000000FF));

remainder_u8 = (unsigned char)(number_u32 % 100);
if (!remainder_u8)
{
    for (i_u8 = 5; i_u8 < 18; i_u8++)
    {
        eeprom[i_u8] = 0x00;
    }
}

for (i_u8 = 5; remainder_u8 >=8; i_u8++)
{
    eeprom[i_u8] = 0xFF;
    remainder_u8 = remainder_u8 - 8;
}

switch (remainder_u8)
{
case 1: eeprom[i_u8] = 0x80;
    break;
case 2: eeprom[i_u8] = 0xC0;
    break;
case 3: eeprom[i_u8] = 0xE0;
    break;
case 4: eeprom[i_u8] = 0xF0;
    break;
case 5: eeprom[i_u8] = 0xF8;
    break;
case 6: eeprom[i_u8] = 0xFC;
    break;
case 7: eeprom[i_u8] = 0xFE;
    break;
default:; /**/
}
}


int _tmain(int argc, _TCHAR* argv[])
{
unsigned char i_u8;
unsigned int test_number_u32;
unsigned int loop_u32 = 0;

while (loop_u32 <0xFFFFFFFF)
{
    test_number_u32 = EEPROM_read();
    test_number_u32++;
    EEPROM_write(test_number_u32);

    for (i_u8 = 0; i_u8 < 18; i_u8++)
    {
        printf(" %x", eeprom[i_u8]);
    }
    printf(" \n");
    loop_u32++;
}

#包括“stdafx.h”
#包括
#包括
使用名称空间std；
/*模拟eeprom*此处*，字节读取和写入*/
无符号字符eeprom[]={0,0,0,0,0,0,0,0,0,0,0，
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 
无符号整数EEPROM_读取（无效）
{
无符号字符i_u8；
无符号整数值_u32，值_A_u32，值_B_u32，值_C_u32，值_D_u32=0；
无符号整数基_1_32=0；
值_A_u32=eeprom[0]；
值_A_u32=值_A_u32>16）；
eeprom[2]=（无符号字符）（（值_32&0x0000FF00）>>8）；
eeprom[3]=（无符号字符）（（值_32&0x000000FF））；
余数_u8=（无符号字符）（数字_u32%100）；
如果（！余数_u8）
{
对于（i_u8=5；i_u8<18；i_u8++）
{
eeprom[i_u8]=0x00；
}
}
对于（i_u8=5；余数i_u8>=8；i_u8++）
{
eeprom[i_u8]=0xFF；
余数_u8=余数_u8-8；
}
开关（余数_u8）
{
情况1:eeprom[i_u8]=0x80；
打破
情况2:eeprom[i_u8]=0xC0；
打破
情况3:eeprom[i_u8]=0xE0；
打破
情况4:eeprom[i_u8]=0xF0；
打破
情况5:eeprom[i_u8]=0xF8；
打破
情况6:eeprom[i_u8]=0xFC；
打破
情况7:eeprom[i_u8]=0xFE；
打破
违约：/**/
}
}
int _tmain（int argc，_TCHAR*argv[]
{
无符号字符i_u8；
无符号整数测试\编号\ 32；
无符号整数循环_u32=0；
while（loop_u32这对于堆栈溢出来说太宽了。在这里你应该问一些有直接答案的问题（对你的问题的直接答案是：“是的，当然有。你可以随意存储它们”，这不是很有用！）。为了解决您对平衡每个位的权重的担忧，您可以走极端，使用base-1类型编码（“计算1”），但它会很慢，而且你不能计数得很高。扰码编码器编号前缀是一个查找表，用于查找存储单元中每个位位置的权重，这样在顺序计数时，所有存储单元都有相同数量的逻辑状态切换。我想你也可能是在误解或ant改写您的问题。通常，EEPROM中的值不会不断变化。您可以设置它们并将其保留，通常作为固件或其他ROM。虽然它们可以改变，但EEPROM中的总周期数通常为