Поскольку у вас два канала измерения, то логично будет установить делитель для АЦП на 128, таким образом на канал у вас будет примерно по 6кГц. Заводите АЦП на непрерывный режим работы в прерывании вычисляете скользящее среднее, для начала сделайте это.

когда Вы пишите в EEPROM Вы можете делать все что угодно кроме
второй записи/чтения в EEPROM, запрещать прерывания нужно только на 2 команды запуска
записи в EEPROM.
Ваша основная проблема в том что Вы не можете правильно спроектировать прогу так
что бы все операции работали параллельно, поэтому я и предложил Вам написать тестовую
прогу с чтением/рассчетом данных с АЦП и параллельной записью в EEPROM,
Вам это просто необходимо для того чтобы понять основы проектирования прог в реалтайме,
когда много разных процессов должны работать одновременно(почти одновременно).

Ну а по Вашему коду можно тоже слегка пройтись, раз уж Вы настаиваете...
Это конечно здорово запрещать прерывания перед записью в EEPROM,
НО, учитывая то что запись в EEPROM у Вас вызывается только из прерывания,
очень интересным является #asm("sei"); в конце функции который просто разрешает
нам вложенные прерывания....
Обычно в начале критической части сохраняют текущий статус разрешения прерываний а
потом его восстанавливают, те если было запрещенно то так и должно остаться.

как Вы думаете, успеет отработать эта запись 4 байтов (по 8,5мс) до прихода следующего
переднего фронта(20мс)?
А что будет происходить если в функции EEPROM_write мы разрешили вложенные прерывания ?
Вы хотя бы примерно представляете сколько времени занимает 1 оперция деления
просто целочисленных 32бит/32бит ? А деление float ?

Ну и в остальных частях проги тоже много чего можно нарыть
- чтение кнопок без фильтрации
- 3 прерывания вместо 1-2 достаточных для такой проги
- все рассчеты только в прерываниях вместо основного цикла
....................

Начинайте с чего-нить попроще, потратите куда как меньше времени на освоение в целом (с)

Когда я запрещал или разрешал прерывания, я подразумевал, что эти 2 команды разрешают/запрещают глобальное разрешение прерываний (то есть изменение флага I в регистре SREG). Посмотрел в книге - там команда sei, например, означает общее разрешение прерываний. Это ведь ассемблерные вставки. А вы говорите про разрешение/запрешение вложеных прерываний... Что это значит?




Это уже не важно, что будет потом. Запись в ЕЕPROM будет происходить лишь при пропадании питания. Сейчас я записывал в EEPROM лишь чтобы узнать правильно ли считается мощность. То есть периодической записи в EEPROM происходить не будет.



Нет, а где можно почитать?



Получается вложеные прерывания будут разрешины, а общие запрещины? И тогда устройство не сможет нормально работать из-за общего запрета прерываний?



А что за фильтрация? Вы имеете ввиду антидребезг? Или возможность ложного срабатывания в случае помехи?


1 прерывание для синхронизации (INT0)
1 прерывание для таймера0 (для измерения значений)
1 прерывание для таймера1 (для отсчёта угла отпирания)

Кака же можно обойтись одним-двумя?



Если вызвана подпрограмма обработки прерывания, она будет выполняться до конца или её в любой момент может прервать другое прерывание или только прерывание с более высоким приоритетом?



Да, наверное так и есть. Значит буду начинать с более простого(то, что вы предложили).

Но я так и не понял сути, что мне нужно сделать. Нужно паралельно мерять значения напряжения, их каким-то образом обрабатывать (так называемое скольжение) и паралельно со всем этим записывать результат в EEPROM?

Уффф... бум отвечать по пунктам:
когда я говорил про 2 команды я имел в виду вот это:
EECR |= (1<<EEMWE);
EECR |= (1<<EEWE);

только эта спецпоследовательность должна выполняться при запрещенных прерываниях,
когда Вы в своей функции EEPROM_write в конце ставите #asm("sei"); Вы разрешаете ВСЕ прерывания...
Про потом это конечно хорошо, но при таком коде Вы никогда не перейдете
к этой самой стадии "потом", Ваш код записи в EEPROM просто мешает фунициклировать правильно
всем прерываниям....
Ну и уже чисто мое ИМХО, это неправильно уповать только на то что Вы успеете записать
многобайтовую переменную в случае пропадания питания, должно быть 2 механизма записи,
1 это привязанное ко времени(типа раз в XXX) второе при пропадании питания, ну
и механизм который разруливает это при старте...
Можно не прочитать а посчитать/просимулировать.
Ваша проблема в том что Вы пытаетесь сразу все посчитать в float и сразу все поделить,
а это нужно делать в самый последний момент, те пока можем, считаем все в целых и
желательно без делений, перевод в float или деления только перед выдачей на экран или
сохранением, хотя если еще чуть подумать, для сохранения это тоже не нужно,
какая разница в каких единицах будет все храниться в EEPROM ?
выше ответил, будут разрешены ВСЕ прерывания и вложенные в том числе,
и при рассчетах с float прямо в прерывании АЦП Вы явно не всегда будете успевать...

Антидребезг конечно, фильтрация это просто общее название.

Ну как минимум 2 из этих задач можно совместить,
ну и еще, подумайте, может чего-нить из этого можно делать и в основной проге ?
про прерывания Вы неправильно поняли, Вы сами разрешаете им быть вложенными,
НО, если Вы им запретите быть вложенными при том софте который есть, станет тока хуже...

Скользящее среднее это очень простая штука, это просто сумма
последних N отсчетов какой-нить меняющейся величины(например показаний АЦП) поделенная на
количество отсчетов N. То есть при получении каждого нового отсчета, мы просто суммируем
последние N отсчетов и делим сумму на N. Нужно просто грамотно организовать хранение
отсчетов и иметь это скользящее среднее в любой момент времени.
Так же нужно раз в секунду записать текущее значение скользящего среднего в EEPROM при этом
не прерывая рассчет скользящего среднего...

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

P.S. про кольцевые буферы Вам уже намекнули, ну и делить не всегда необходимо(для хранения)...

И каждый раз суммировать тоже не обязательно, достаточно при поступлении нового отсчета вычесть из результата скользящего среднего элемент, на который указывает указатель кольцевого буфера, затем записать в буфер новый отсчет и прибавить его к результату. А потом передвинуть указатель. В начальный момент времени у Вас все будет ==0, поэтому до заполнения буфера ничего эдакого делать не надо - все само устаканится.

По поводу прерываний:

Так как функция записи в EEPROM вызывается из прерывания EXT_INT0, то на момент вызова функции EEPROM_write(...); флаг I будет сброшен. То есть глобально будут запрещены все прерывания. Тогда зачем их запрещать на 2 команды -
EECR |= (1<<EEMWE);
EECR |= (1<<EEWE);
???


Я так понял, что ошибка была в том, что я глобально разрешал прерывания внутри подпрограммы обработки прерываний INT0, чего не должно было быть. Все прерывания должны были быть разрешены (автоматически) только после завершения подпрограммы обработки INT0. Так?

Для тех кто в танке, еще раз повторяю, нужно не запретить прерывания на эти
2 команды, нужно запомнить были ли запрещены/разрешены прерывания в момент когда
мы добрались до этих команд, если были запрещены так и оставить, если были разрешены,
запретить их только на эти 2 команды.
В Вашем конкретном случае, когда вся запись осуществляется только из прерываний,
запрещение/разрешение прерываний вобще не нужно.
В первом приближении так, тока это Вам не поможет сделать Ваш код рабочим...
У Вас принципиально неправильно спланированна программа,
я Вам уже советовал поупрожняться в этом деле, но похоже Вы решили править Ваш код,
ну чтож, пожелаем Вам удачи...

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

Есть уточняющие вопросы:

- скользящее среднее считать для моей схемы? При 100% мощности? Т.е. мерять "идеальную" синусоиду?
- с какой частотой?
- какое количество отсчётов?
- вы писали, что раз в секунду нужно писать скользящее среднее в EEPROM. Время равное 1 секунде можно считать по количеству внешних прерываний INT0 (периодов сетевого напряжения) или нужно использовать таймер, например?
- как организовать хранение последних N отсчётов? Т.е. этот самый кольцевой буфер. Понятно, что значения будут храниться где-то в ROM. Но где именно? В массиве, в памяти?

Считайте это пока просто абстрактной задачкой, к Вашим синусойдам это
пока отношения не имеет. Самое главное для Вас сейчас научиться планировать задачку,
и в частности сделать так чтобы несколько независимых функций работали "одновременно".
Иначе у Вас получается что функции которые должны работать в реалтайме (чтение показаний АЦП,
ловля перехода через 0, итд) постоянно прерываются функциями которые делаются
очень неспешно(запись в EEPROM, рассчет результатов в флоат, итд)

то есть я Вам предлагаю написать относительно простую задачку:
- опрос АЦП с какой-то частотой (лучше кстати сразу по нескольким каналам)
- рассчет среднего по каждому каналу(ну это типа просто для тренировки и понимания как нужно
хранить и делать предварительные вычисления побыстрому когда данных много)
- запись посcчитанных значений в EEPROM с некоторой переодичностью

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

кольцевой. не в ROM а в RAM. в массиве.

Ну а для уточнения задачки, ну пусть будет 2 делителя напряжения с переменными резисторами
в одном из плечей, частоту АЦП выберите сами, по максимуму но с запасом на обработку.

ахахахахахахаха)))))