Расчет Оборотов. "глюки?" В Протеусе.

[AS7ti6K]

Ну по поводу указателя, я имел в виду что структура лежит по тому же адресу что и переменная TurnsTime

volatile struct vremia
{
unsigned int tamerL;
unsigned int tamerH;
} TurnsTimes @0x041;
volatile unsigned long int TurnsTime @0x041;

Т.е. получается как бы TurnsTime это указатель на структуру TurnsTimes

PS: Кстати, убрав этот вычет MksTurns +=65536-TMR1. На самом деле изменилось. Стало вроде даже как-то стабильнее(не с таким размахом прыгает значение TurnsTime)... Просто я столько раз все меняю, оптимизирую, что в один момент "это" становится (псевдо)лекарством, а потом превращается в опухоль. Хорошо что хоть удаляются без проблем такие опухли

Изменено 31 марта, 2014 пользователем AS7ti6K

[Реклама]

Реклама: ООО ТД Промэлектроника, ИНН: 6659197470, Тел: 8 (800) 1000-321

[Alex]

структура лежит по тому же адресу что и переменная TurnsTime

А, ну да, не обратил внимание.

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

Тогда уж лучше сделать так:

volatile struct vremia
{
unsigned int tamerL;
unsigned int tamerH;
} TurnsTimes;
unsigned long *p_TurnsTime = (unsigned long *) &TurnsTimes;

Или вообще через union.

Изменено 31 марта, 2014 пользователем Alex

[Реклама]

20% скидка на весь каталог электронных компонентов в ТМ Электроникс!

Акция "Лето ближе - цены ниже", успей сделать выгодные покупки!

Плюс весь апрель действует скидка 10% по промокоду APREL24 + 15% кэшбэк и бесплатная доставка!

Перейти на страницу акции

Реклама: ООО ТМ ЭЛЕКТРОНИКС, ИНН: 7806548420, info@tmelectronics.ru, +7(812)4094849

[AS7ti6K]

У меня используются для подсчета мкс две переменные long типа.

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

а если использовать сдвиг, то можно съекономить 2 байта, верно?

т.е. использовать одну long и одну int (Обе беззнака)....

и в int считать не мкс, а переполнения.... По сути целое кол-во 65536 микросекунд.

Затем это каким-то чудесным сдвигом сдвигается в long переменную с додвигом оставшегося времени.

Я вот только никак не могу уловить логику как кол-во 65536мкс сдвигами становятся в нормально кол-во мкс....

Извиняюсь, а без структуры это разве не тоже самое, в данном конкретном случае?

Имею в виду использование long переменной без структуры...

[Реклама]

Выбираем схему BMS для корректной работы литий-железофосфатных (LiFePO4) аккумуляторов

 Обязательным условием долгой и стабильной работы Li-FePO4-аккумуляторов, в том числе и производства EVE Energy, является применение специализированных BMS-микросхем. Литий-железофосфатные АКБ отличаются такими характеристиками, как высокая многократность циклов заряда-разряда, безопасность, возможность быстрой зарядки, устойчивость к буферному режиму работы и приемлемая стоимость. Но для этих АКБ, также как и для других, очень важен контроль процесса заряда и разряда, а специализированных микросхем для этого вида аккумуляторов не так много. Инженеры КОМПЭЛ подготовили список имеющихся микросхем и возможных решений от разных производителей. Подробнее>>

Реклама: АО КОМПЭЛ, ИНН: 7713005406, ОГРН: 1027700032161

[Alex]

Да тоже самое, только со структурой переменные гарантировано идут "друг за другом" по адресам. По этому можно смело создавать указатель на long с адресом этой структуры.

[AS7ti6K]

я так понимаю, что

long a;

int b;

a = 00000000 00000000 00000000 00000000;

b = 11111111 11111111;

a = b;

a = a<<16;

в а 11111111 11111111 0000000 00000000

как-то так или нет?

Изменено 31 марта, 2014 пользователем AS7ti6K

[Alex]

long a;
int b;
int c;
a = (long)b << 16L;
a + = c;

В переменной a будут 2 переменные b и c. Точнее их значения.

Это обычные операции с переменными. Но можно создать одну переменную long и в неё сразу же укладывать значения - инкрементировать старшие байты, переносить значение из таймера в младшие байты, ...

[IMXO]

Можно несколько вопросов по Вашему коду?

volatile struct vremia
{
unsigned int tamerL;
unsigned int tamerH;
} TurnsTimes @0x041;
volatile unsigned long int TurnsTime @0x041;

Это отличается от volatile unsigned long TurnsTime;

? Т.е. вместо структуры использовать long переменную

отличается тем, что для обращение к TurnsTime:

TurnsTime=0xAAAABBBB

а к TurnsTimes

TurnsTimes.tamerL=0xBBBB

TurnsTimes.tamerH=0xAAAA

переменная TurnsTimes со структурой vremia наложил специально на TurnsTime совместив их явным указанием адреса

, чтобы показать изменение последней...

Алекс прав указание явного адреса ОЧЕНЬ опасный ход, компилятор к примеру первые адреса регистров общих для всех банков

помешает темповские переменные сохранения контента, и использование таких адресов приводит к непредсказуемым последствиям....

Тогда уж лучше сделать так:

volatile struct vremia
{
unsigned int tamerL;
unsigned int tamerH;
} TurnsTimes;
unsigned long *p_TurnsTime = (unsigned long *) &TurnsTimes;

Или вообще через union.

а вот с этого места по подробней....

что значит эта запись

unsigned long *p_TurnsTime = (unsigned long *) &TurnsTimes;

как это работает в смысле как обращатся....

и как выглядит через union.

если чесно читал Карнеги но так и не понял....

[Alex]

а вот с этого места по подробней....

Если взять за основу твой пример, то так :

*p_TurnsTime |= *p_TurnsTime<<16;
*p_TurnsTime = *p_TurnsTime + (TMR1H<<8)+ TMR1L; //Собираем микросекунды

И по указателю, значения будут укладываться в структуру.

и как выглядит через union.

union{
struct
{
 unsigned int tamerL;
 unsigned int tamerH;
};
unsigned long lTime;
}TurnsTimes;

TurnsTimes.lTime = TurnsTimes.lTime<<16;
TurnsTimes.lTime = TurnsTimes.lTime + (TMR1H<<8)+ TMR1L; //Собираем микросекунды

[IMXO]

магия какая-то :wall:

[Alex]

Никакой магии

/**************************************************************************/
struct{
int a;
int b;
}mStruct;
long* const pStruct= (long*)&mStruct;
/**************************************************************************/



/**************************************************************************/
void main(void){

mStruct.a = mStruct.b = 0;
*pStruct = 0x12345678;
// Теперь в a=0x5678, b=0x1234

while(1);
}
/**************************************************************************/

18:			    mStruct.a = mStruct.b = 0;
  3F1    01A2	 CLRF 0x22
  3F2    01A3	 CLRF 0x23
  3F3    01A0	 CLRF mStruct
  3F4    01A1	 CLRF 0x21
19:			    *pStruct = 0x12345678;
  3F5    00A3	 MOVWF 0x23
  3F6    3034	 MOVLW 0x34
  3F7    00A2	 MOVWF 0x22
  3F8    3056	 MOVLW 0x56
  3F9    00A1	 MOVWF 0x21
  3FA    3078	 MOVLW 0x78
  3FB    00A0	 MOVWF mStruct

C union:

/**************************************************************************/
union{
   struct{
    int a;
    int b;
   };
   long    c;
}mUnion;
/**************************************************************************/

/**************************************************************************/
void main(void){
mUnion.a = mUnion.b = 0;
mUnion.c = 0x12345678;
// Теперь  mUnion.a=0x5678, mUnion.b=0x1234
while(1);
}
/**************************************************************************/

20:			    mUnion.a = mUnion.b = 0;
  3F1    01A2	 CLRF 0x22
  3F2    01A3	 CLRF 0x23
  3F3    01A0	 CLRF mUnion
  3F4    01A1	 CLRF 0x21
21:			    mUnion.c = 0x12345678;
  3F5    00A3	 MOVWF 0x23
  3F6    3034	 MOVLW 0x34
  3F7    00A2	 MOVWF 0x22
  3F8    3056	 MOVLW 0x56
  3F9    00A1	 MOVWF 0x21
  3FA    3078	 MOVLW 0x78
  3FB    00A0	 MOVWF mUnion

[IMXO]

если

union{
struct
{
unsigned char tamerL;
unsigned char tamerH;
unsigned int tamerHH;
};
unsigned long lTime;
}TurnsTimes;

тогда

if (TMR1IF) { // Таймер переполнился
TurnsTimes.tamerHH++; // Считаем микросекунды
TMR1IF = 0; // Сбрасываем флаг таймера

и сборка:

TurnsTimes.tamerH = TMR1H;
TurnsTimes.tamerL = TMR1L;

чтение как :

tmpTT=TurnsTime.lTime;

правильно?

[Alex]

чтение как :

tmpTT=TurnsTime.lTime;

правильно?

Ага.

Я пример с union чуть выше привёл, он простенький и по нему понятно что происходит.

union - это объединение нескольких объектов в одну область памяти.

[Alex]

Кстати, в union имя структуры необязательно. Если задавать структуре имя, то к её полям придётся обращаться через это имя

/**************************************************************************/
union{
   struct{
    int a;
    int b;
   }mStruct;
   long    c;
}mUnion;
/**************************************************************************/

/**************************************************************************/
void main(void){
mUnion.mStruct.a = mUnion.mStruct.b = 0;
mUnion.c = 0x12345678;
// Теперь  mUnion.mStruct.a=0x5678, mUnion.mStruct.b=0x1234
while(1);
}
/**************************************************************************/

[IMXO]

/**************************************************************************/
union{
struct{
int a;
int b;
}mStruct;
long c;
}mUnion;
/**************************************************************************/

/**************************************************************************/
void main(void){
mUnion.mStruct.a = mUnion.mStruct.b = 0;
mUnion.c = 0x12345678;
// Теперь mUnion..mStructa=0x5678, mUnion..mStructb=0x1234
while(1);
}
/**************************************************************************/

взрыв моска....

[Alex]

Я там с точками в комменте напутал, исправил

Грубо говоря, union - та же структура, только все её поля находятся по одному адресу. А памяти выделяется столько, сколько занимает максимальное поле.

Всё просто