CodeVision AVR в вопросах и ответах

[COKPOWEHEU]

в Си возможна только единственная форма записи выражения, в котором используется знак присваивания '=' - это когда левее этого знака находится только переменная, и ничего больше. поэтому оба варианта, которые вы "помните" принципиально неверны.

Не совсем так. Хотя это, конечно, экзотика и не имеет отношения к данной теме.

[ARV]

Не совсем так. Хотя это, конечно, экзотика и не имеет отношения к данной теме.

главное сумничать, да?
расскажите нам, что означает это самое ваше (a , b)? по своей сути оно эквивалентно одной из двух переменных, только записано с переподвыподвертом, как может Си.
и что с того?

[COKPOWEHEU]

Повторяю: вы написали "левее знака присвоения находится переменная и ничего больше". Я поправил, что это не всегда так. Не говоря о более распространенных случаях вроде while(++dst** = ++src**) где слева от присвоения еще и условие цикла помимо переменной.
Так что вам надо не пытаться опровергнуть высказывание, а либо промолчать (что самое разумное, поскольку мое высказывание лишь уточняет ваше, а не противоречит), либо исправить собственную формулировку.

[kotriks]

"шифровать" вы собираетесь, как я понимаю, операцией битового XOR... вангую: каждый очередной байт, отправляемый в i2c, надо проXORить с очередным символом из массива Key - так или нет? если так, то ваш код должен быть примерно таким

Код: Выделить всё

char crypt(char data){
   static char i;
   char result = data ^ Key[i++];
   if(i >= SIZE_OF_KEY) i = 0;
   return result;
}

это, возможно, не совсем то, что хотите вы, но это однозначно будет компилироваться и на самом деле будет XORить данные... SIZE_OF_KEY - это константа, задающая размер вашего "ключа".

спасибо сделал так, теперь шифруется. но! мне кажется, символ ключа берётся из первой яйчеки памяти например если ключ 1234567890 то берёт 1 и только 1 кой шифрует.

Код: Выделить всё

volatile unsigned int addr;
volatile unsigned char pageSize;                                 
volatile bit page_stop_status;
eeprom unsigned char Key[10]; 
volatile unsigned char crypt_bit;

unsigned char crypt(){
unsigned char  b=0, i=0;
b = b ^ Key[i++]; 
return b;
}

void page_stop() 
 {
i2c_stop(); 
delay_ms(30);
page_stop_status=1; 
}

void writeData(unsigned char c1){ 
if (page_stop_status==1)  {
i2c_start(); 
i2c_write(0xa0);
i2c_write(addr>>8); 
i2c_write(addr & 0x00FF); 
page_stop_status=0;     }

if(crypt_bit==1){
i2c_write(c1^crypt());
}
if(crypt_bit==0){
i2c_write(c1); 
}
 
addr++; 
pageSize++;  
if (pageSize==128) {
pageSize=0; 
page_stop();
 }   
} 

void addr_save(){      // запись счетчиа байт

   i2c_start(); 
   i2c_write(0xa0);
   i2c_write(0); 
   i2c_write(0 & 0x00FF); 
                           
   i2c_write((addr>>8) & 0xFF);
   i2c_write((addr & 0xFF));   // адрес байта
   i2c_write(pageSize);        // номер байта в странице
   page_stop();
} 

void readaddr()        {      // чтение счетчиа байт

unsigned char hi_addr,lo_addr;

i2c_start();               // I2C start signal
i2c_write(0xA0);              // send byte via I2C  (device address + W)
i2c_write(0>>8); 
i2c_write(0 & 0x00FF); 

i2c_start();               // I2C signal repeated start
i2c_write(0xA1);             // send byte (device address + R)
hi_addr = i2c_read(0); // Read the data (NO acknowledge)   


i2c_start();               // I2C signal repeated start
i2c_write(0xA1);             // send byte (device address + R)
lo_addr = i2c_read(0); // Read the data (NO acknowledge)   

i2c_start();               // I2C signal repeated start
i2c_write(0xA1);             // send byte (device address + R)
pageSize = i2c_read(0); // Read the data (NO acknowledge)   

addr=hi_addr;
addr=(addr<<8);           // собираем млатший и старший байт
addr=(addr | lo_addr); 

 page_stop();
 
}


void ClerMem(){          // чистит память

unsigned int cnt;
unsigned int temp_addr;

readaddr(); 

if (addr==3) {putchar('E'); putchar('m'); putchar('t'); putchar('y');putchar(' '); putchar('M'); putchar('e'); putchar('m'); putchar('o');putchar('r'); putchar('y'); 
putchar(13);
putchar(10);
putchar(13);
putchar(10);}


else {
putchar('C'); putchar('l'); putchar('e'); putchar('a');putchar('r'); putchar('i');  putchar('n');putchar('g');  
putchar(13);
putchar(10);
putchar('W'); putchar('a'); putchar('i'); putchar('t'); 
putchar(13);
putchar(10);

temp_addr=addr+255;
addr=pageSize=0;
for(cnt=0;cnt<=temp_addr;cnt++)    {  writeData(255);   }    
page_stop();                     
putchar('O'); putchar('k'); 
putchar(13);
putchar(10);
putchar('M'); putchar('e'); putchar('m'); putchar('o');putchar('r'); putchar('y');  putchar(' ');putchar('e'); putchar('r'); putchar('a'); putchar('s'); putchar('e'); 
putchar(13);
putchar(10);

putchar(13);
putchar(10);
addr=pageSize=3;
addr_save();
}  
 page_stop();        
  }
 
 
void ReadMem(){          // читать память

unsigned int cnt;
unsigned int temp_addr;

readaddr(); 

if (addr==3) {putchar('E'); putchar('m'); putchar('t'); putchar('y');putchar(' '); putchar('M'); putchar('e'); putchar('m'); putchar('o');putchar('r'); putchar('y'); 
putchar(13);
putchar(10);
putchar(13);
putchar(10);}


else {
crypt_bit=0;
putchar('R'); putchar('e'); putchar('a'); putchar('d');putchar('i'); putchar('n');  putchar('g');
putchar(13);
putchar(10);


temp_addr=3;
while (temp_addr<addr) {
i2c_start(); 
i2c_write(0xa0);
i2c_write(temp_addr>>8); 
i2c_write(temp_addr & 0x00FF);   

for(cnt=0;cnt<128;cnt++)    {  
i2c_start();              
i2c_write(0xA1);           
putchar(i2c_read(0)); 
temp_addr++;
if (temp_addr==addr) 
 break;                 
} 
                            
page_stop();        
 }
                                       
                      
page_stop();
crypt_bit=1;

putchar(13);
putchar(10);
putchar('O'); putchar('k'); 
                            } 
putchar(13);
putchar(10);       

} 

void pass() {

unsigned char pas[10]; 
 
if  (Key[6]==255) {
Key[0]='z';
Key[1]='z';
Key[2]='z';
Key[3]='z';
Key[4]='z';
Key[5]='z';
Key[6]='z'; 
Key[7]='z';
Key[8]='z';
Key[9]='z'; 

}

putchar('E'); putchar('n'); putchar('t'); putchar('e');  putchar('r'); putchar(' '); 
putchar('l'); putchar('a'); putchar('s'); putchar('t');  putchar(' ');
putchar('k'); putchar('e'); putchar('y');
putchar(13);
putchar(10);

pas[0]=getchar(); putchar('*');
pas[1]=getchar(); putchar('*');
pas[2]=getchar(); putchar('*');
pas[3]=getchar(); putchar('*');
pas[4]=getchar(); putchar('*');
pas[5]=getchar(); putchar('*');
pas[6]=getchar(); putchar('*');
pas[7]=getchar(); putchar('*');
pas[8]=getchar(); putchar('*');
pas[9]=getchar(); putchar('*');
putchar(13);
putchar(10);


if  (
pas[0]==Key[0]&&
pas[1]==Key[1]&&
pas[2]==Key[2]&& 
pas[3]==Key[3]&& 
pas[4]==Key[4]&& 
pas[5]==Key[5]&& 
pas[6]==Key[6]&& 
pas[7]==Key[7]&& 
pas[8]==Key[8]&&
pas[9]==Key[9])  

{

putchar('E'); putchar('n'); putchar('t'); putchar('e');  putchar('r'); putchar(' '); 
putchar('n'); putchar('e'); putchar('w'); putchar(' ');
putchar('k'); putchar('e'); putchar('y');
putchar(13);
putchar(10);


Key[0]=getchar(); putchar(Key[0]);
Key[1]=getchar(); putchar(Key[1]);
Key[2]=getchar(); putchar(Key[2]);
Key[3]=getchar(); putchar(Key[3]);
Key[4]=getchar(); putchar(Key[4]);
Key[5]=getchar(); putchar(Key[5]);
Key[6]=getchar(); putchar(Key[6]);
Key[7]=getchar(); putchar(Key[7]);
Key[8]=getchar(); putchar(Key[8]);
Key[9]=getchar(); putchar(Key[9]);



putchar(13);
putchar(10);

putchar('n'); putchar('e'); putchar('w'); putchar(' ');
putchar('k'); putchar('e'); putchar('y'); putchar(' ');
putchar(Key[0]);
putchar(Key[1]);
putchar(Key[2]);
putchar(Key[3]);
putchar(Key[4]);
putchar(Key[5]);
putchar(Key[6]);
putchar(Key[7]);
putchar(Key[8]);
putchar(Key[9]);
putchar(13);
putchar(10);
putchar(13);
putchar(10);
reboot();

} else {
putchar('I'); putchar('n'); putchar('c'); putchar('o'); putchar('r'); putchar('e'); putchar('c'); putchar('t'); putchar(13);putchar(10);
  }

}

// USART Receiver interrupt service routine
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
status=UCSR0A;
data=UDR0;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0) {
if (data=='1') {ReadMem();}
if (data=='2') {ClerMem();} 
if (data=='3') {pass();} 

}   
}

теперь задача как это дело всё вытащить с памяти конвертнуть программно, скажем пропустить через тот же самый хор только наобород

[WiseLord]

Точно так же. XOR обратим: если X xor D = Y, то Y xor D = X. То есть, если число было проXORено чем-то, то второй раз проXORив результат тем же, получим исходное число.

[kotriks]

Точно так же. XOR обратим: если X xor D = Y, то Y xor D = X. То есть, если число было проXORено чем-то, то второй раз проXORив результат тем же, получим исходное число.

мне это то понятно, только вот я на словах плохо понимаю мне на практике больше понятно, чтобы в код носом ткнули тогда пойму.

[WiseLord]

Код точно такой же. Функция crypt() точно такая же.

Кстати, код ваш ничего не шифрует. Точнее, из-за того, что функция crypt() всегда возвращает Key[0], всё сообщение шифруется не всем кодом Key, а просто xor-ится на одно и то же число - Key[0].

[ARV]

сделал так, теперь шифруется. но! мне кажется, символ ключа берётся из первой яйчеки памяти например если ключ 1234567890 то берёт 1 и только 1 кой шифрует

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

Код: Выделить всё

char crypt(char data){
   static char i;
   char result = data ^ Key[i++];
   if(i >= SIZE_OF_KEY) i = 0;
   return result;
}

Код: Выделить всё

unsigned char crypt(){
unsigned char  b=0, i=0;
b = b ^ Key[i++]; 
return b;
}

и вообще, вот это

Код: Выделить всё

i2c_write(c1^crypt());

надо делать так (в варианте моей функции)

Код: Выделить всё

i2c_write(crypt(с1));

[kotriks]

ребят путём перебора понял, что нужно было сделать так, присвоить переменной

Код: Выделить всё

char ee_key;
eeprom unsigned char Key[10];

в main

Код: Выделить всё

ee_key=Key[0]^Key[1]^Key[2]^Key[3]^Key[4]^Key[5]^Key[6]^Key[7]^Key[8]^Key[9];

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

Код: Выделить всё

unsigned char crypt(){
unsigned char  b=0;
b = b ^ ee_key; 
return b;
}

записываем

Код: Выделить всё

void writeData(unsigned char c1){ 
if (page_stop_status==1)  {
i2c_start(); 
i2c_write(0xa0);
i2c_write(addr>>8); 
i2c_write(addr & 0x00FF); 
page_stop_status=0;     }

i2c_write(c1^crypt());
 
addr++; 
pageSize++;  
if (pageSize==128) {
pageSize=0; 
page_stop();
 }   
}

всё криптуется прекрасно. всем спасибо все очень помогли!!!
вот бы ещё теперь обратную функцию кто помог накатать

[WiseLord]

Ага, криптуется. Однобайтным ключом.
Вы уже тогда сразу ee_key в eeprom пишите, зачем эти сложности с 10 байтами, если всё равно их в один схлопываете.

[kotriks]

сделал так, теперь шифруется. но! мне кажется, символ ключа берётся из первой яйчеки памяти например если ключ 1234567890 то берёт 1 и только 1 кой шифрует

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

Код: Выделить всё

char crypt(char data){
   static char i;
   char result = data ^ Key[i++];
   if(i >= SIZE_OF_KEY) i = 0;
   return result;
}

Код: Выделить всё

unsigned char crypt(){
unsigned char  b=0, i=0;
b = b ^ Key[i++]; 
return b;
}

и вообще, вот это

Код: Выделить всё

i2c_write(c1^crypt());

надо делать так (в варианте моей функции)

Код: Выделить всё

i2c_write(crypt(с1));

чему равен SIZE_OF_KEY ?

[COKPOWEHEU]

SIZE_OF_KEY - это константа, задающая размер вашего "ключа".

[kotriks]

Тоесть если ключ из 10 символов значит константа должна равняться 10?
#define SIZE_OF_KEY 10 ?

[rusl32]

Великие кадавраводы! Ай нид хелп. Есть два куска кода. В железе (atmega 644pa) один работает нормально второй нет. Весь мозг сломал (если он есть).
Это вывод температуры с датчиков ds18b20. В первом коде десятые для первого датчика выводятся рандомно. Для второго всё гуд. Расчет всех значений корректный в обоих случаях. Отличаются куски тем, что в первом коде оператор цикла for инициализируется нулем, во втором единицей. Я что-то упустил? Где косяк?

Спойлер

lcd_clear(); // чистим
for (i=0;i<devices;i++) {
/* формирования машинного представления температуры */

temper_m[i]=rom_dev[i][1]<<8; // старший байт на место
temper_m[i]|=rom_dev[i][0]; //добавляем младший байт
temper_m[i]=temper_m[i]+880; // сдвигаем 0 в -55
/*формирование человеческого вида температуры */

lcd_gotoxy(6,i); // точка начала значения
itoa(temper_m[i],lcd_buffer); // формируем маш темп
lcd_puts (lcd_buffer); // выводим значение */

temper_h[i]=temper_m[i]-880-432; // возвращаем 0 на место




minus=0;
if (temper_h[i]<0) { //если ниже 0 ставим минус
minus=1; // и находим модуль температуры
temper_h[i]=~(unsigned int)temper_h[i]+1;
};



lcd_gotoxy(14,i); // точка начала значения
sprintf(lcd_buffer,"#%u",minus);
lcd_puts (lcd_buffer); // выводим значение


temper_d[i]= temper_h[i] & 0b0000000000001111; // сохраняем младшие биты
temper_h[i]=temper_h[i]>>4; //умножаем на 0.0625
temper_d[i]=temper_d[i]*10; // умножаем десятые на десять



temper_d[i]=temper_d[i]>>4; // умножаем на 0.0625

lcd_gotoxy(11,i); // точка начала значения
sprintf(lcd_buffer,"#%+d",temper_d[i]); // смотрим десятые
lcd_puts (lcd_buffer); // выводим значение чел темп

delay_ms (1800); // пауза на чтение

/* вывод температуры */





lcd_gotoxy(0,i); // место минуса
indent=0;
if (minus) {
lcd_putsf ( "-" );
indent ++;
};

if (temper_h[i] > 9) {
indent ++; // отступ на 1 позицию
};

if (temper_h[i] > 99) {
indent ++; // отступ ещё на 1 позицию
};



lcd_gotoxy(indent,i); // точка начала значения
sprintf(lcd_buffer,"%d.%d",temper_h[i],temper_d[i]); // смотрим темп
lcd_puts (lcd_buffer); // выводим значение



};

delay_ms (1800); // пауза на чтение

Спойлер

lcd_clear(); // чистим
for (i=1;i<devices+1;i++) {
/* формирования машинного представления температуры */

temper_m[i]=rom_dev[i-1][1]<<8; // старший байт на место
temper_m[i]|=rom_dev[i-1][0]; //добавляем младший байт
temper_m[i]=temper_m[i]+880; // сдвигаем 0 в -55
/*формирование человеческого вида температуры */

lcd_gotoxy(6,i-1); // точка начала значения
itoa(temper_m[i],lcd_buffer); // формируем маш темп
lcd_puts (lcd_buffer); // выводим значение */

temper_h[i]=temper_m[i]-880-432; // возвращаем 0 на место




minus=0;
if (temper_h[i]<0) { //если ниже 0 ставим минус
minus=1; // и находим модуль температуры
temper_h[i]=~(unsigned int)temper_h[i]+1;
};



lcd_gotoxy(14,i-1); // точка начала значения
sprintf(lcd_buffer,"#%u",minus);
lcd_puts (lcd_buffer); // выводим значение


temper_d[i]= temper_h[i] & 0b0000000000001111; // сохраняем младшие биты
temper_h[i]=temper_h[i]>>4; //умножаем на 0.0625 или делим на 16
temper_d[i]=temper_d[i]*10; // умножаем десятые на десять



temper_d[i]=temper_d[i]>>4; // умножаем на 0.0625

lcd_gotoxy(11,i-1); // точка начала значения
sprintf(lcd_buffer,"#%+d",temper_d[i]); // смотрим десятые
lcd_puts (lcd_buffer); // выводим значение чел темп

delay_ms (1800); // пауза на чтение

/* вывод температуры */





lcd_gotoxy(0,i-1); // место минуса
indent=0;
if (minus) {
lcd_putsf ( "-" );
indent ++;
};

if (temper_h[i] > 9) {
indent ++; // отступ на 1 позицию
};

if (temper_h[i] > 99) {
indent ++; // отступ ещё на 1 позицию
};



lcd_gotoxy(indent,i-1); // точка начала значения
sprintf(lcd_buffer,"%d.%d",temper_h[i],temper_d[i]); // смотрим темп
lcd_puts (lcd_buffer); // выводим значение



};

delay_ms (1800); // пауза на чтение

[WiseLord]

Подозреваю, что в первом случае в temper_m[0] что-то пишет помимо этого кода, при выводе получается ерунда.
В втором случае temper_m[0] не задействован вообще, индексы датчиков сдвинуты вверх на единицу, эффекта не наблюдается.

Кстати, все эти манипуляции вроде

Код: Выделить всё

temper_m[i]=temper_m[i]+880; // сдвигаем 0 в -55
temper_h[i]=temper_m[i]-880-432; // возвращаем 0 на место

, которые вы называете "человеческим видом температуры" абслютно не нужны и даже вредны. В датчике температура хранится уже в идеальном, "человеческом" виде: <число_в_датчике> = <число_в_градусах> * 16. (или * 2 в DS18S20), максимально удобном для работы с ним.

[rusl32]

Подозреваю, что в первом случае в temper_m[0] что-то пишет помимо этого кода, при выводе получается ерунда.
В втором случае temper_m[0] не задействован вообще, индексы датчиков сдвинуты вверх на единицу, эффекта не наблюдается.

Кстати, все эти манипуляции вроде

Код: Выделить всё

temper_m[i]=temper_m[i]+880; // сдвигаем 0 в -55
temper_h[i]=temper_m[i]-880-432; // возвращаем 0 на место

, которые вы называете "человеческим видом температуры" абслютно не нужны и даже вредны. В датчике температура хранится уже в идеальном, "человеческом" виде: <число_в_датчике> = <число_в_градусах> * 16. (или * 2 в DS18S20), максимально удобном для работы с ним.

В temper_m[0] все как надо (видно на картинках), многократно проверено. манипуляции с представление температуры нужны для других целей, не очевидных в этом куске. Проблема в том, что в одном месте значение выводится правильно, в другом отсебятина. Я то могу жить и со вторым вариантом. Но хочется разобраться, чтоб не поймать грабли снова.

Спойлер

Спойлер

[WiseLord]

В temper_m[0] все как надо (видно на картинках)

Во втором случае temper_m[0] и прочие temper_X[0] вы вообще не выводите. Как можно говорить, что там всё в порядке и это видно на картинках.

Моё мнение - в temper_X[0] что-то пишет ещё помимо этого кода. В первом случае выводится [0] и [1] и это заметно, во втором - выводится [1] и [2] и это незаметно.

И опять же, кто знает, как там эти Ваши манипуляции с некими магическими числами 880 и 432 сказываются на результате, тем более, что никто кроме Вас не знает, какой тип у temper_X, как он себя ведёт при этих манипуляциях.
Далее, в коде[i] temper_m[i]=rom_dev[i][1]<<8; // старший байт на место - потенциально опасное место, в результате, вполне возможно, что там всегда 0 в результате.

Я бы делал так:

Код: Выделить всё

int16_t temper[devices];

for (i = 0; i < devices; i++) {
    temper[i] = rom_dev[i][1];
    temper[i] <<= 8;
    temper[i] |= rom_dev[i][0];
}

В результате в temper[i] лежит то что надо, никаких манипуляций больше не надо

Теперь выводим:

Код: Выделить всё

// Разбираемся со знаком
minus = 0;
if (temper[i] < 0) {
    minus = 1;
    temper[i] = -temper[i];
}

// Выводим
lcd_gotoxy(0,i);
lcd_putc(minus ? '-' : ' ');
sprintf(lcd_buffer, "%d.%d" ,temper[i] >> 4, ((temper[i] & 0x000F) * 10) >> 4);
lcd_puts(lcd_buffer);

[rusl32]

В temper_m[0] все как надо (видно на картинках)

Во втором случае temper_m[0] и прочие temper_X[0] вы вообще не выводите. Как можно говорить, что там всё в порядке и это видно на картинках.

Моё мнение - в temper_X[0] что-то пишет ещё помимо этого кода. В первом случае выводится [0] и [1] и это заметно, во втором - выводится [1] и [2] и это незаметно.

И опять же, кто знает, как там эти Ваши манипуляции с некими магическими числами 880 и 432 сказываются на результате, тем более, что никто кроме Вас не знает, какой тип у temper_X[i], как он себя ведёт при этих манипуляциях.

Проблема с выводом temper_d[i]. Манипуляция с числами и там и там одинакова, тип переменных одинаков. Как это может влиять на вывод?
Когда в цикле начатом i=0 десятые градуса складываются в temper_d[0] и temper_d[1] для первого и второго датчика соответственно. Во втором варианте тоже самое идет в temper_d[1] и temper_d[2]. В коде1 temper_d[0] в первый (там где #) раз выводится правильно, второй раз, на своем месте в значении после точки -- уже ерунда. Между выводами с temper_d[0] никаких манипуляций.В чем причина?
temper_h[]- signed int; temper_m[] - unsigned int; temper_d[] - unsigned char; - хотя не пойму как это может повлиять.

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

[WiseLord]

В чем причина?

Я же говорю - где-то ещё, помимо этого кода, что-то может в [0] данные портить.

[rusl32]

В чем причина?

Я же говорю - где-то ещё, помимо этого кода, что-то может в [0] данные портить.

lcd_gotoxy(11,i); // точка начала значения
sprintf(lcd_buffer,"#%+d",temper_d[i]); // смотрим десятые здесь выводит одно из temper_d[i]
lcd_puts (lcd_buffer); // выводим значение чел темп

delay_ms (1800); // пауза на чтение

/* вывод температуры */





lcd_gotoxy(0,i); // место минуса
indent=0;
if (minus) {
lcd_putsf ( "-" );
indent ++;
};

if (temper_h[i] > 9) {
indent ++; // отступ на 1 позицию
};

if (temper_h[i] > 99) {
indent ++; // отступ ещё на 1 позицию
};



lcd_gotoxy(indent,i); // точка начала значения
sprintf(lcd_buffer,"%d.%d",temper_h[i],temper_d[i]); // смотрим темп здесь уже выводит другое из temper_d[i]
lcd_puts (lcd_buffer); // выводим значение

видно что по пути ничего с temper_d[i] не происходит. Как так? Прерывания и прочее отключено.