Хочется программно инициировать прерывание, Но не INT0/INT1, как бы погламурнее Опции

[Rst7]

Тут задача возникла следующего характера. Как бы инициировать прерывание программным путем?

Самый простой способ - использовать INT0, например, и сконфигурировать прерывание по изменению состояния ноги (нога на вывод), в результате - достаточно шевельнуть ножкой (изменив ее, скажем OUT'ом в PINx) и флаг прерывания установится; соответственно, когда будет разрешено прерывание INT0 - оно и произойдет. Но, к сожалению, INT0 и INT1 заняты, надо изобретать что-то другое.

Вот мысль появилась использовать прерывание от компаратора, причем следующим образом:

Компаратор штатно выключен (он не нужен в проекте), для установки флага прерывания от него использовать последовательность

Код

ACSR=(1<<ACD)|(1<<ACIS1)|(1<<ACIS0); //Comparator Interrupt on Rising Output Edge.
ACSR=(1<<ACD)|(1<<ACIS1); //Comparator Interrupt on Falling Output Edge.

Т.е. переключить туда-сюда "по фронту/по спаду". На идею натолкнула фраза

When changing the ACIS1/ACIS0 bits, the Analog Comparator Interrupt must be disabled by clearing its Interrupt Enable bit in the ACSR Register. Otherwise an interrupt can occur when the bits are changed.

в даташите.

К сожалению, сейчас негде попробовать этот чит. Посему пара вопросов:

1. Может кто делал такое и уже знает результат?
2. Может у кого есть под рукой макеточка, проверить бы?
3. А может кто гламурнее способ знает?

[Rst7]

Давайте я попробую все-таки подробностей добавить.

Есть 4 задачи. В порядке возрастания приоритетов:

1. Основной поток (тот который main()). На данный момент там банальный for(;;). Чего там будет, я пока не знаю, и поэтому, этот поток трогать мне нельзя.
2. Задача обработки. Длительная, выполняется намного дольше, чем промежуток между вызовами задач 3,4. Во время выполнения должны уметь получать управление задачи 3,4, причем с минимальным временем отклика (особенно 4). Запуск задачи происходит от события. По окончанию обработки задача засыпает до следующего события.
3. Задача - не самое приоритетное прерывание. От таймера, но вызывается часто - 256/512 тактов. В задаче - по быстренькому опрос периферии и по результатам - возможна генерация события для задачи 2. Во время выполнения этой задачи необходимо обеспечить возможность быстрого реагирования на прерывание для задачи 4.
4. Самое приоритетное прерывание. Входит, выполняет дело, по результатам дела генерирует или не генерирует событие, выходит.

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

Для такого менеджмента задач идеально использовать RTOS, но есть одно но - пока переключаются контексты поезд задачи 4 уходит далеко - в смысле, время реакции не устраивает. Значит, надо делать подобие RTOS, но с минимальными временами нахождения в состояниях c запретом прерываний.

План у меня таков - задача 2 - это обработчик прерывания, запрос на выполнение которого я могу создать в любой момент (это генерация события), а вот обработать - только тогда, когда не выполняются задачи 3 или 4 (и не находимся внутри задачи 2, дабы не допустить вложенности). Для этого мне и необходимо раздельное управление флагом запроса и битом разрешения прерывания.

Вариант со счетчиком плохо проходит в связи с тем, что увеличение/уменьшение счетчика требует сохранения SREG (с последующим восстановлением) и работу с самим счетчиком до разрешения прерываний.


Вот примерно такой код

Код

#define TASK2_LOCK GPIOR0_Bit0
#define TASK3_LOCK GPIOR0_Bit1

#define DISABLE_TASK2() {asm("PUSH R16");ACSR=(1<<ACD)|(1<<ACIS1);asm("POP R16");}
#define ENABLE_TASK2() {asm("PUSH R16");ACSR=(1<<ACD)|(1<<ACIS1)|(1<<ACIE);asm("POP R16");}
#define WAKEUP_TASK2() {ACSR=(1<<ACD)|(1<<ACIS1)|(1<<ACIS0);}

#pragma diag_suppress=Ta006
__interrupt void TASK2(void)
{
  __no_operation();
  //....
  //....много всякой долгой каки...
  main(); //Например так
  //....
  __no_operation();
}
#pragma diag_default=Ta006


#pragma vector=ANA_COMP_vect
__interrupt __raw void TASK2dispatch(void)
{
  DISABLE_TASK2();
  TASK2_LOCK=1;
  __enable_interrupt();
  ((void(*)(void))TASK2)();  
  __disable_interrupt();
  TASK2_LOCK=0;
  ENABLE_TASK2();
}

#pragma diag_suppress=Ta006
__interrupt void TASK3(void)
{
  __no_operation();
  //....
  //....не очень много всякой долгой каки...
  if (PINB_Bit0) WAKEUP_TASK2(); //К примеру
  //....
  __no_operation();
}
#pragma diag_default=Ta006

#pragma vector=TIMER0_OVF_vect
__interrupt __raw void TASK3dispatch(void)
{
  if (TASK3_LOCK) return;
  TASK3_LOCK=1;
  DISABLE_TASK2();
  __enable_interrupt();
  ((void(*)(void))TASK3)();  
  __disable_interrupt();
  TASK3_LOCK=0;
  if (!TASK2_LOCK) ENABLE_TASK2();
}

#pragma vector=INT0_vect
__interrupt void TASK4(void)
{
  //Тут тоже колдовство, запрещаем все прерывания, например
  TIMSK0=0;
  //Запрещаем и TASK2
  DISABLE_TASK2();
  __enable_interrupt();
  //Чего-то делаем, тут еще бывает INT1, но это уже не суть
  __disable_interrupt();
  if (PINB_Bit1) WAKEUP_TASK2(); //К примеру
  TIMSK0=1<<TOV0;
  if (!TASK2_LOCK) ENABLE_TASK2();
}

А вот чего выходит после компилятора

Код

        RSEG CODE:CODE:NOROOT(1)
//  176 __interrupt void TASK2(void)
TASK2:
//  177 {
        ST      -Y, R24
        ST      -Y, R31
        ST      -Y, R30
        ST      -Y, R3
        ST      -Y, R2
        ST      -Y, R1
        ST      -Y, R0
        ST      -Y, R23
        ST      -Y, R22
        ST      -Y, R21
        ST      -Y, R20
        ST      -Y, R19
        ST      -Y, R18
        ST      -Y, R17
        ST      -Y, R16
        IN      R24, 0x3F
//  178   __no_operation();
        NOP
//  179   //....
//  180   //....много всякой долгой каки...
//  181   main(); //Например так
        RCALL   main
//  182   //....
//  183   __no_operation();
        NOP
//  184 }
        OUT     0x3F, R24
        LD      R16, Y+
        LD      R17, Y+
        LD      R18, Y+
        LD      R19, Y+
        LD      R20, Y+
        LD      R21, Y+
        LD      R22, Y+
        LD      R23, Y+
        LD      R0, Y+
        LD      R1, Y+
        LD      R2, Y+
        LD      R3, Y+
        LD      R30, Y+
        LD      R31, Y+
        LD      R24, Y+
        RETI
//  185 #pragma diag_default=Ta006
//  186
//  187
//  188 #pragma vector=ANA_COMP_vect

        RSEG CODE:CODE:NOROOT(1)
//  189 __interrupt __raw void TASK2dispatch(void)
TASK2dispatch:
//  190 {
//  191   DISABLE_TASK2();
        PUSH R16
        LDI     R16, 130
        OUT     0x30, R16
        POP R16
//  192   TASK2_LOCK=1;
        SBI     0x1E, 0x00
//  193   __enable_interrupt();
        SEI
//  194   ((void(*)(void))TASK2)();  
        RCALL   TASK2
//  195   __disable_interrupt();
        CLI
//  196   TASK2_LOCK=0;
        CBI     0x1E, 0x00
//  197   ENABLE_TASK2();
        PUSH R16
        LDI     R16, 138
        OUT     0x30, R16
        POP R16
//  198 }
        RETI
        REQUIRE _A_ACSR
        REQUIRE _A_GPIOR0
//  199
//  200 #pragma diag_suppress=Ta006

        RSEG CODE:CODE:NOROOT(1)
//  201 __interrupt void TASK3(void)
TASK3:
//  202 {
        ST      -Y, R16
//  203   __no_operation();
        NOP
//  204   //....
//  205   //....не очень много всякой долгой каки...
//  206   if (PINB_Bit0) WAKEUP_TASK2(); //К примеру
        SBIS    0x03, 0x00
        RJMP    ??TASK3_0
        LDI     R16, 131
        OUT     0x30, R16
//  207   //....
//  208   __no_operation();
??TASK3_0:
        NOP
//  209 }
        LD      R16, Y+
        RETI
        REQUIRE _A_ACSR
        REQUIRE _A_PINB
//  210 #pragma diag_default=Ta006
//  211
//  212 #pragma vector=TIMER0_OVF_vect

        RSEG CODE:CODE:NOROOT(1)
//  213 __interrupt __raw void TASK3dispatch(void)
TASK3dispatch:
//  214 {
//  215   if (TASK3_LOCK) return;
        SBIC    0x1E, 0x01
        RJMP    ??TASK3dispatch_0
//  216   TASK3_LOCK=1;
        SBI     0x1E, 0x01
//  217   DISABLE_TASK2();
        PUSH R16
        LDI     R16, 130
        OUT     0x30, R16
        POP R16
//  218   __enable_interrupt();
        SEI
//  219   ((void(*)(void))TASK3)();  
        RCALL   TASK3
//  220   __disable_interrupt();
        CLI
//  221   TASK3_LOCK=0;
        CBI     0x1E, 0x01
//  221   if (!TASK2_LOCK) ENABLE_TASK2();
        SBIC    0x1E, 0x00
        RJMP    ??TASK3dispatch_0
        PUSH R16
        LDI     R16, 138
        OUT     0x30, R16
        POP R16
??TASK3dispatch_0:
        RETI
        REQUIRE _A_ACSR
        REQUIRE _A_GPIOR0
//  222 }
//  223
//  224 #pragma vector=INT0_vect

        RSEG CODE:CODE:NOROOT(1)
//  225 __interrupt void TASK4(void)
TASK4:
//  226 {
        ST      -Y, R17
        ST      -Y, R16
        IN      R17, 0x3F
//  227   //Тут тоже колдовство, запрещаем все прерывания, например
//  228   TIMSK0=0;
        LDI     R16, 0
        STS     110, R16
//  229   //Запрещаем и TASK2
//  230   DISABLE_TASK2();
        PUSH R16
        LDI     R16, 130
        OUT     0x30, R16
        POP R16
//  231   __enable_interrupt();
        SEI
//  232   //Чего-то делаем, тут еще бывает INT1, но это уже не суть
//  233   __disable_interrupt();
        CLI
//  234   if (PINB_Bit1) WAKEUP_TASK2(); //К примеру
        SBIS    0x03, 0x01
        RJMP    ??TASK4_0
        LDI     R16, 131
        OUT     0x30, R16
//  235   TIMSK0=1<<TOV0;
??TASK4_0:
        LDI     R16, 1
        STS     110, R16
//  236   if (!TASK2_LOCK) ENABLE_TASK2();
        SBIC    0x1E, 0x00
        RJMP    ??TASK4_1
        PUSH R16
        LDI     R16, 138
        OUT     0x30, R16
        POP R16
//  237 }
??TASK4_1:
        OUT     0x3F, R17
        LD      R16, Y+
        LD      R17, Y+
        RETI

Вариант с прерываниями хорош еще и тем, что в задаче 1 я могу выполнить WAKEUP_TASK2();ENABLE_TASK2() - и сразу полетит выполять задачу 2. Все приоритеты красиво соблюдаются.