есть ли другие методы хранения двоичных чисел

Как насчет такой двоичной системы счисления? При счете с очень высокой скоростью шины транзисторы не перегреваются и поэтому ограничивают тактовую частоту.

Решение использует как двоичную систему с основанием 2, так и двоичную систему с основанием 1 для создания числа.

((двоичное число с основанием 2)*size_of_in_bits(двоичное число с основанием 1)) + двоичное число с основанием 1

поэтому для 16-битной шины со старшим байтом двоичной базы-2 и младшим байтом двоичной базы-1 максимальное количество будет ((2^8)-1)*8)+8) = 2048

Решение проблемы жизни EEPROM может быть следующим:

Использование EEPROM, которое изменяет только необходимые ячейки при записи новых данных, чтобы увеличить срок службы.

4 байта (32 бита) для части числа с основанием 2 и 13 байтов (100 бит) для части числа с основанием 1.

((32-битное двоичное число с основанием 2) x 100) + (100-битный двоичный счетчик с основанием 1)

Максимальное количество будет (((2 ^ 32)-1) * 100) + 100) = 429 496 729 700

Этот метод должен получить максимальное время жизни от EEPROM или FLASH-памяти, для FLASH-памяти число по основанию 1 должно храниться инвертированным, потому что стертое состояние - это логическая 1.

EEPROM может читать, увеличивать, записывать число на 2 порядка больше, достигая счета в 1 миллион вместо десяти тысяч.

Отправьте мне письмо, и я могу дать вам программу, она работает в консоли MVS 2013.

[email protected]

/* решение www.goatelectronics.com */

/* Эта программа предназначена для проверки жизни eeprom, записывая в одну и ту же страницу и ячейки */

/* 32-битное двоичное число с основанием 2 + 100-битное двоичное число с основанием 1 составляют число*/

/* байт 0 — старший байт, двоичное число с основанием 2 */

/* байт 1 - */

/* байт 2 - */

/* байт 3 — младший байт, двоичное число с основанием 2 */

/* байт 4 - 8-битный суффикс CRC для 32-битного числа, будет сделано позже */

/* байт 5 - считать от 0 до 8 двоичного числа с основанием 1 */

/* байт 6 - считать от 9 до 16 двоичного числа с основанием 1*/

/* байт 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++;
}