Я как всегда встряну))
Почему-то мне кажется, что вот эта строка в прерывании ADC
TIFR0 |= (1<<OCF0A); // Clear Output Compare Flag 0 A
сбросит вместе с OCF0A также и неожиданно вставший флаг TOV0.
Соответственно, прерывание по переполнению пропадет.
Не слишком внимательно посмотрел код, но вот пару вещей сразу можно улучшить.
Макрос установки/сброса бит для Long переписал бы как:
#define SetBitValLong(reg, bit, val) do{if (val==0) (reg) &= (~(1UL<<(bit)));\
else (reg) |= (1UL<<(bit));}while(0)
То есть вместо long применить unsigned long, потому что при изменении бита 31 некоторые компиляторы ругаются на смену знака числа.
В функции OutLED — ну не стоило бы использовать макро
SetBitVal(PORTB, DI, (BitIsSet(cmd, i)?1:0));
для переменных в цикле for. Код огромный генерится, он же каждый проход вычисляет бит в разной позиции. Лучше в цикле всегда выплевывать младший бит, и затем сдвигать вправо выводимое число. т.е.:
SetBitVal(PORTB, DI, ((cmd&1)?1:0));
cmd >>= 1;
Чуть выше писал: «это же не AVR где [b]может[/b] и пронесёт нелёгкая))».
Кто спорит?)) Наколоться можно и на AVR.
Атомарность не связана с RTOS. Достаточно прерывания.
Акцент на ARM сделан чтобы подчеркнуть его производительность.
Да особенностей доступа нет. И к данным, и к таким общим ресурсам как AFIO->EXTICR[i], или к RCC->чего-то там. То есть надо всё это защищать от совместного использования.
Говорю же — не одному процессу! Нескольким процессам. Это же ARM! Там запросто может быть RTOS. Одна задача работает с EXTI0, а другая c EXTI1.
Ну, например: В проекте пара внешних ADC (не заставляйте меня придумывать чтО именно они меряют — ну пусть напряжение и ускорение)). Каждая задача, запускаясь, проводит калибровку, измерение, накопление, линеаризацию, архивирование. Каждое ADC выдаёт свою готовность на EXTI0/1. Задачи совершенно независимые. Они могут создаваться или уничтожаться так, как Главной Задаче будет удобно. А вместе с задачами, сами понимаете, и прерывания EXTI0/1 то разрешаются, то запрещаются.
EXTICR[i] может быть прочитано и изменено в любой момент.
Когда система рухнет — дело Вашего везения))
Только при настройке? Да это ж ARM, здесь задачи появляются и удаляются в процессе работы. Где гарантия что инициализовать AFIO->EXTICR не понадобится какой-то задаче в самый неприятный момент?
Есть несколько способов сделать атомарность. Это может быть критические секции с помощью жесткой триады: save_interrupt(); disable_interrupt(); <работа> restore_interrupt(); с помощью средств, которые есть в компиляторах.
Атомарность можно сделать и битбандом (достаточно геморройно для групповых полей).
Главное — безопасность. Я, например, потратил не одну неделю чтобы много небезопасных библиотечных CMSIS-функций для таких глобальных систем систем как RCC, AFIO, и т.п. перевести на битбанд и на критические секции. И для F1xxx и для F4xx. И — забыл про них)) Теперь спокойно работаю.
Мысли. Их всего 2:
1) Операция AFIO->EXTICR[PIN/4] = (AFIO->EXTICR[PIN/4] & ~… неатомарна и чревата глюками — это же не AVR где может и пронесёт нелёгкая)), здесь задач может крутиться ого-го сколько. И каждая может использовать для своих целей регистр EXTICR[PIN/4].
2) Заглядывая в будущее. Раз уж так получается, что макросы «замыливаются», т.е. EXTI_INIT тянет за собой _EXTI_INIT, потом еще __EXTI_INIT… то предлагаю на верхнем уровне оставить EXTI_INIT как есть, но глубже — использовать имена с упоминанием семейства. То есть назвать макрос _EXTI_INIT_F1XX(). Вот почему: инициализация блока EXTI нужна и в семействе F4XX, но там она немножно по-другому, другие регистры. И когда Вы сделаете такую же библиотеку для F4XX, то не будет путаницы в именах. Тогда нужную реализацию инициализации к проекту подключать будет просто: #ifdef STM32F1XX #define EXTI_INIT() _EXTI_INIT_F1XX() #else #define EXTI_INIT() _EXTI_INIT_F4XX() #endif. Главный макрос останется единым, что позволит легко переводить проекты с платформы на платформу.
Что-то не нравится запись BIT_BAND_PER(EXTI->IMR,1<<PIN)=!!(EXTI_MODE). Не проверял, но думаю будут проблемы для значений PIN больше чем 15. Скорее, даже для больше чем 14. Регистр IMR 32-битный, значит, надо писать 1UL<<PIN
Да, полезная штука. «If the data line (SDA) is stuck LOW, the master
should send nine clock pulses. The device that held the bus LOW should release it sometime within those nine clocks. If not, then use the HW reset or cycle power to clear the bus».
Интересует 2 момента:
1. Перед выдачей условия СТАРТ Вы освобождаете линии опрашиваете свободу SDA и подаёте импульсы на SCL. Я как-то обходился без этого, но подивился Вашей прозорливости насчет возможного залипания ACK со стороны Slave)) Понимаю, что подача импульсов даёт возможность прочухаться Slave (правда, вечный цикл как-то не нравится, сделал бы счетчик). Вопрос: то есть кошерно так делать? Это общая практика и только я отстал?
2.Кажется, в функции I2C_Write_Byte Вы после выдачи 8 битов можете остаться в 0 на SDA если последний выдаваемый бит данных=0. Почему Вы перед опросом ACK не освобождаете SDA? (Или я в этих макросах запутался?)
Стыдно сказать — у меня множество таких фобий. Например, перед считыванием состояния бита порта стараюсь по возможности вновь настроить его на приём (было хорошо на MCS51 и AVR — там это быстро. На новых кристаллах типа Xmega и STM32 это уже не везде сделаешь). Перед засыпанием кристалла проверяю настройки и разрешенность «будЯщего» прерывания, включенность таймера. Короче, порой код получается смешным.
Абсолютно правильный ход мысли. Вы становитесь настоящим параноиком — только параноики способны написать надёжный код))
Проверять нужно даже гипотетические опасности, грозящие Вашему коду. Тут хорошо помогает, простите за психологизм, метод эмпатии — понимание состояния наблюдаемого объекта путём сопереживания, проникновения в его субъективный мир. Если Вы конструируете какой-то механизм — представлять себя на месте одной из шестерёнок, как ей хреново крутиться если не будет смазки, как она греется, ломается… Вот так и нам приходится представлять себя байтом, битом.
Да, Вы правы, и для однобайтовых переменных в 8-разрядниках тоже необходимо применять почти те же правила и приёмы. Разница лишь в одном — если ОДНОБАЙТОВАЯ переменная в прерывании только читается — то в теле программы на её атомарность неё можно «забить болт».
Вот поторопился — отвлекает начальник работой)).
Пропустил пару слов в фразе. Надо так: «сохранить текущее состояние прерываний, запретить прерывания, затем спокойно сделать критическое дело и восстановить старое значение бита разрешения прерываний».
Да нет проблем — тут моего-то «авторства» немного. Только мой корявый и бескомпромиссный слог типа «делай атомарность везде в теле программы» — рассчитан, конечно, на человека понимающего, что если в этом месте тела программы прерывания и так явно запрещены, то зачем делать еще критическую секцию))
Теперь серьёзно: Плавно вытекло Правило 4) «Старайся, чтобы при выходе из твоей функции глобальное состояние разрешения прерываний было таким же, как и при входе в нее».
То есть: если в Вашей функции надо манипулировать разрешением прерываний, то надо сохранить текущее состояние прерываний, затем спокойно сделать критическое дело и восстановить старое значение бита разрешения прерываний.
Особенно это важно для отлаженных общеупотребительных библиотеках программиста, которые он будет использовать тыщу раз в нескольких проектах (например, работа с EEPROM, ADC,… ).
Вот почему: Вы не ожидаете подляны от своей старой надёжной функции, которая не раз доказывала свою железобетонность. Когда Вы ее вызывали из места, где прерывания разрешены. Но вот Вашу самописную функцию чтения EEPROM или ADC Вы (или Ваш последователь) вызовет из некого критического места, где прерывания были запрещены. И если в ней вдруг встретится явное enable_interrupt — пиши пропало критической секции.
Ну разумеется здесь этот свирепый прием будет хорошо работать :) Здесь же не критически к дрожанию фронтов импульсов включения и вообще к методу включения/выключения вентилятора. Но представьте себе: бизнес пошел, Ваши изделия нарасхват, и вот на комбинате вентилятор огромный и требует плавного разгона/торможения ШИМом в течение нескольких секунд. И получается что мы затупили на эти секунды — ни на текущее время не прерваться нифига. А тут еще начальник подошел говорит у конкурентов изделие такое же, но по MODBUSу управляется, и в архив пишет время включения-выключения. А у нас прерывания запрещены. Поэтому в принципе можно просто и безопасно локально делать маленькие критические секции. В арсенале у нас есть простые правила для 8-разрядников (простите за повтор из моей недавней писанины): 1) Любые переменные, как-то использующиеся в прерывании — делай их volatile. 2) Многобайтная переменная ИЗМЕНЯЕТСЯ в прерывании — делай атомарность везде в теле программы где она только есть. 3) Многобайтная переменная СЧИТЫВАЕТСЯ в прерывании — делай атомарность везде в теле программы где она будет ИЗМЕНЯТЬСЯ.
В качестве последнего штриха в main надо сравнивать с T_ON и T_OFF не time, а ее копию. То есть в while(1) сразу сделать: disable_interrupt(); copy_time = time; enable interrupt(); и сравнивать copy_time.
Почему это надо сделать? Вот как может получиться: с T_ON у нас равно 300, то есть 0x012c. Пусть наше time = 0x00ff, то есть гораздо меньше чем T_ON.
Поехали. Начинаем сравнивать (time >= T_ON). Сравниваем мл. байты. FF>=2c — конечно! Значит, надо сравнивать старшие байты. Тут бабах — прерывание. time++ стало 0x0100. Возвращаемся из прерывания и сравниваем старшие байты: 01 >= 01? Ну да! То есть у нас time = 256, а оказывается уже пора «сливать воду».
Вечные «платформонезависимые» баги:
— переменные cnt и time не объявлены volatile;(что с ними сделает отпимизатор — остаётся только молиться Богу чтобы вообще не выкинул).
— доступ к двухбайтовой переменной time неатомарен в main. В результате времена могут в один прекрасный момент убежать.
Ванная, конечно, не Байконур, но… :)
Угу. Для версии компилятора 123454321FF это будет так. А уже для версии 23454321AA — Вы можете ручаться что компилятор будет так же?
А когда Вы всё-таки напишете volatile — этот порядок сохранится? :)
Ну, тогда ждите неожиданностей. Могу рассказать примерно как это будет.
Пусть, как Вы и говорите, Ваша MinRepeatTime равно 0. В неатомарном присваивании в функции DoNow есть строка MinRepeatTime = EEPROM_read(EPROM_MinRepeatTime) * 60;
Чему будет равно новое вычисленное значение MinRepeatTime — неважно, пусть 0x0100. Важно, что присваивание произойдет неатомарно, побайтно «за 2 приема»: 01 и 00. Теперь следите за моей рукой: после присваивания старшего
байта 01 произошло прерывание. Поскольку наше «недоприсвоенная» MinRepeatTime теперь якобы равна 0x0100, то в прерывании выполнится строка if(MinRepeatTime) MinRepeatTime--; и MinRepeatTime станет равно 0х0100 — 1 = 0x00FF. После этого прерывание «благополучно» закончится и управление вернётся в DoNow. Там произойдет финал трагедии: к переменной MinRepeatTime присобачится младший байт и она станет равна 0х0000.
Сами понимаете, числа условные и ситуация может быть круче.
PS. Кстати, описанный случай — не единственная неожиданность. Оптимизатор может вообще неаккуратно обойтись с переменной MinRepeatTime — например, вовсе выкинуть ее или заоптимизтровать до неузнаваемости, поскольку оптимизатор и знать не знает что она применяется где-то еще в совершенно другом «потоке» — прерывании(особенно если обработчик будет находиться в другом файле). Вы же не указали компилятору для переменной MinRepeatTime слово volatile: «эту переменную не оптимизируй».
Представите, что TOV0 уже встал. Во время обработчика ADC. Может такое быть? Да запросто!
Тогда операция |= аккуратно прочитает его в рабочий регистр, добавит туда бит OCF0A, и… аккуратно этой же единичкой его же и убьёт!
Вот как.
Почему-то мне кажется, что вот эта строка в прерывании ADC
TIFR0 |= (1<<OCF0A); // Clear Output Compare Flag 0 A
сбросит вместе с OCF0A также и неожиданно вставший флаг TOV0.
Соответственно, прерывание по переполнению пропадет.
Макрос установки/сброса бит для Long переписал бы как:
#define SetBitValLong(reg, bit, val) do{if (val==0) (reg) &= (~(1UL<<(bit)));\
else (reg) |= (1UL<<(bit));}while(0)
То есть вместо long применить unsigned long, потому что при изменении бита 31 некоторые компиляторы ругаются на смену знака числа.
В функции OutLED — ну не стоило бы использовать макро
SetBitVal(PORTB, DI, (BitIsSet(cmd, i)?1:0));
для переменных в цикле for. Код огромный генерится, он же каждый проход вычисляет бит в разной позиции. Лучше в цикле всегда выплевывать младший бит, и затем сдвигать вправо выводимое число. т.е.:
SetBitVal(PORTB, DI, ((cmd&1)?1:0));
cmd >>= 1;
Кто спорит?)) Наколоться можно и на AVR.
Атомарность не связана с RTOS. Достаточно прерывания.
Акцент на ARM сделан чтобы подчеркнуть его производительность.
Ну, например: В проекте пара внешних ADC (не заставляйте меня придумывать чтО именно они меряют — ну пусть напряжение и ускорение)). Каждая задача, запускаясь, проводит калибровку, измерение, накопление, линеаризацию, архивирование. Каждое ADC выдаёт свою готовность на EXTI0/1. Задачи совершенно независимые. Они могут создаваться или уничтожаться так, как Главной Задаче будет удобно. А вместе с задачами, сами понимаете, и прерывания EXTI0/1 то разрешаются, то запрещаются.
EXTICR[i] может быть прочитано и изменено в любой момент.
Когда система рухнет — дело Вашего везения))
Есть несколько способов сделать атомарность. Это может быть критические секции с помощью жесткой триады: save_interrupt(); disable_interrupt(); <работа> restore_interrupt(); с помощью средств, которые есть в компиляторах.
Атомарность можно организовать и с помощью хорошо описанной на этом ресурсе сладкой парочки LDREX/STREX we.easyelectronics.ru/STM32/atomarnye-operacii-v-cortex-m3.html
Атомарность можно сделать и битбандом (достаточно геморройно для групповых полей).
Главное — безопасность. Я, например, потратил не одну неделю чтобы много небезопасных библиотечных CMSIS-функций для таких глобальных систем систем как RCC, AFIO, и т.п. перевести на битбанд и на критические секции. И для F1xxx и для F4xx. И — забыл про них)) Теперь спокойно работаю.
1) Операция AFIO->EXTICR[PIN/4] = (AFIO->EXTICR[PIN/4] & ~… неатомарна и чревата глюками — это же не AVR где может и пронесёт нелёгкая)), здесь задач может крутиться ого-го сколько. И каждая может использовать для своих целей регистр EXTICR[PIN/4].
2) Заглядывая в будущее. Раз уж так получается, что макросы «замыливаются», т.е. EXTI_INIT тянет за собой _EXTI_INIT, потом еще __EXTI_INIT… то предлагаю на верхнем уровне оставить EXTI_INIT как есть, но глубже — использовать имена с упоминанием семейства. То есть назвать макрос _EXTI_INIT_F1XX(). Вот почему: инициализация блока EXTI нужна и в семействе F4XX, но там она немножно по-другому, другие регистры. И когда Вы сделаете такую же библиотеку для F4XX, то не будет путаницы в именах. Тогда нужную реализацию инициализации к проекту подключать будет просто: #ifdef STM32F1XX #define EXTI_INIT() _EXTI_INIT_F1XX() #else #define EXTI_INIT() _EXTI_INIT_F4XX() #endif. Главный макрос останется единым, что позволит легко переводить проекты с платформы на платформу.
should send nine clock pulses. The device that held the bus LOW should release it sometime within those nine clocks. If not, then use the HW reset or cycle power to clear the bus».
1. Перед выдачей условия СТАРТ Вы освобождаете линии опрашиваете свободу SDA и подаёте импульсы на SCL. Я как-то обходился без этого, но подивился Вашей прозорливости насчет возможного залипания ACK со стороны Slave)) Понимаю, что подача импульсов даёт возможность прочухаться Slave (правда, вечный цикл как-то не нравится, сделал бы счетчик). Вопрос: то есть кошерно так делать? Это общая практика и только я отстал?
2.Кажется, в функции I2C_Write_Byte Вы после выдачи 8 битов можете остаться в 0 на SDA если последний выдаваемый бит данных=0. Почему Вы перед опросом ACK не освобождаете SDA? (Или я в этих макросах запутался?)
Проверять нужно даже гипотетические опасности, грозящие Вашему коду. Тут хорошо помогает, простите за психологизм, метод эмпатии — понимание состояния наблюдаемого объекта путём сопереживания, проникновения в его субъективный мир. Если Вы конструируете какой-то механизм — представлять себя на месте одной из шестерёнок, как ей хреново крутиться если не будет смазки, как она греется, ломается… Вот так и нам приходится представлять себя байтом, битом.
Да, Вы правы, и для однобайтовых переменных в 8-разрядниках тоже необходимо применять почти те же правила и приёмы. Разница лишь в одном — если ОДНОБАЙТОВАЯ переменная в прерывании только читается — то в теле программы на её атомарность неё можно «забить болт».
Пропустил пару слов в фразе. Надо так: «сохранить текущее состояние прерываний, запретить прерывания, затем спокойно сделать критическое дело и восстановить старое значение бита разрешения прерываний».
Теперь серьёзно: Плавно вытекло Правило 4) «Старайся, чтобы при выходе из твоей функции глобальное состояние разрешения прерываний было таким же, как и при входе в нее».
То есть: если в Вашей функции надо манипулировать разрешением прерываний, то надо сохранить текущее состояние прерываний, затем спокойно сделать критическое дело и восстановить старое значение бита разрешения прерываний.
Особенно это важно для отлаженных общеупотребительных библиотеках программиста, которые он будет использовать тыщу раз в нескольких проектах (например, работа с EEPROM, ADC,… ).
Вот почему: Вы не ожидаете подляны от своей старой надёжной функции, которая не раз доказывала свою железобетонность. Когда Вы ее вызывали из места, где прерывания разрешены. Но вот Вашу самописную функцию чтения EEPROM или ADC Вы (или Ваш последователь) вызовет из некого критического места, где прерывания были запрещены. И если в ней вдруг встретится явное enable_interrupt — пиши пропало критической секции.
Почему это надо сделать? Вот как может получиться: с T_ON у нас равно 300, то есть 0x012c. Пусть наше time = 0x00ff, то есть гораздо меньше чем T_ON.
Поехали. Начинаем сравнивать (time >= T_ON). Сравниваем мл. байты. FF>=2c — конечно! Значит, надо сравнивать старшие байты. Тут бабах — прерывание. time++ стало 0x0100. Возвращаемся из прерывания и сравниваем старшие байты: 01 >= 01? Ну да! То есть у нас time = 256, а оказывается уже пора «сливать воду».
— переменные cnt и time не объявлены volatile;(что с ними сделает отпимизатор — остаётся только молиться Богу чтобы вообще не выкинул).
— доступ к двухбайтовой переменной time неатомарен в main. В результате времена могут в один прекрасный момент убежать.
Ванная, конечно, не Байконур, но… :)
А когда Вы всё-таки напишете volatile — этот порядок сохранится? :)
Пусть, как Вы и говорите, Ваша MinRepeatTime равно 0. В неатомарном присваивании в функции DoNow есть строка MinRepeatTime = EEPROM_read(EPROM_MinRepeatTime) * 60;
Чему будет равно новое вычисленное значение MinRepeatTime — неважно, пусть 0x0100. Важно, что присваивание произойдет неатомарно, побайтно «за 2 приема»: 01 и 00. Теперь следите за моей рукой: после присваивания старшего
байта 01 произошло прерывание. Поскольку наше «недоприсвоенная» MinRepeatTime теперь якобы равна 0x0100, то в прерывании выполнится строка if(MinRepeatTime) MinRepeatTime--; и MinRepeatTime станет равно 0х0100 — 1 = 0x00FF. После этого прерывание «благополучно» закончится и управление вернётся в DoNow. Там произойдет финал трагедии: к переменной MinRepeatTime присобачится младший байт и она станет равна 0х0000.
Сами понимаете, числа условные и ситуация может быть круче.
PS. Кстати, описанный случай — не единственная неожиданность. Оптимизатор может вообще неаккуратно обойтись с переменной MinRepeatTime — например, вовсе выкинуть ее или заоптимизтровать до неузнаваемости, поскольку оптимизатор и знать не знает что она применяется где-то еще в совершенно другом «потоке» — прерывании(особенно если обработчик будет находиться в другом файле). Вы же не указали компилятору для переменной MinRepeatTime слово volatile: «эту переменную не оптимизируй».