Замена обработчика прерывания в WinAVR Опции

[PhX]

Нужно использовать различные обработчики прерывания в зависимости от случая. Например в начале программы
обработчик_пр = функция 1

Код

ISR(INT1_vect)
{
обработчик_пр
}

а затем где-то по далее необходимо заменить его на
обработчик_пр = функция 2
Как это грамотно сделать в WinAVR?

[733259]

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

С __attribute__((interrupt)) прерывания будут разрешены сразу после входа в INT0_vect (INT0_vect), первой командой будет sei. C __attribute__((signal)) такого не будет, ИМХО правильнее __attribute__((signal,used)). К тому же вариант singlskv не универсален - переключаются векторы INT0, INT1, а если они нужны? В случае "просто" функций - компилятор выдаст предупреждение "misspelled interrupt handler" - из-за этого данный вариант мне показался не подходящим.
ИМХО в реале накладные расходы на if будут меньше push r30, icall и т.д.

Как приятно иногда сказать: знатоки, блин.

Не совсем понял иронию.

[_Pasha]

правильнее __attribute__((signal,used)). К тому же вариант singlskv не универсален - переключаются векторы INT0, INT1, а если они нужны?

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

Код

void foo(void)
{
{
   block 1
}
//........
{
   block N
}
}

Сделаем необходимый инструментарий

Код

typedef uint16_t pc_type; // пока обошел указатели стороной

uint8_t wherePC(void* pcreg) __attribute__((naked));
void setPC(pc_type newPC) __attribute__((naked));
/*Обертка для субвекторов*/
#define SubVector(t_name) if(wherePC(&t_name))

WherePC заточено таким образом, чтобы возвращать 0 при вызове, а в параметре - адрес, с которого ее вызывали, исключая обработку возвращаемого значения.

Код

void setPC(pc_type newPC)
{
asm volatile("ijmp" : : "z" (newPC));
}

uint8_t wherePC(void* pcreg)                      
{
asm volatile (
          "pop        r25"    "\n\t"
        "pop        r24"    "\n\t"
        "adiw    r24,2"    "\n\t"
        "st        Z,    r24"    "\n\t"
        "std    Z+1,r25"    "\n\t"
        "movw    r30,r24"    "\n\t"
        "sbiw    r30,2"    "\n\t"
        "clr r24"    "\n\t"
        "ijmp"                "\n\t"
    ::"z" (pcreg));
}

Используя SubVector(имя_переменной_указателя_на_блок)

Код

void foo(void)
{
static pc_type sv[3];
static uint8_t work = 0;
if(work)
{// код, использующий косв. переход на sv[n]
  set_PC(sv[1]);
}
else
{
  SubVector(sv[0])
  {
    block 1
  }
  SubVector(sv[1])
  {
    block 2
  }
  SubVector(sv[2])
  {
   block 3
  }
  work = 1;
}
return;
}

В итоге при первом вызове получаем адреса блоков кода в переменных sv[], но сами блоки не выполняем, по аналогии с setjmp, а при последующих вызовах - переходим в кратчайшие сроки к независимому блоку. В данном контексте это должно обеспечить выигрыш по сравнению со switch()

Просьба потестить эти примитивы и высказать мнения о применимости. Заранее спасибо.

[ReAl]

Есть у меня еще в стадии тестирования субвекторизация.

Есть несколько менее переносимый, зато более эффективный способ. В том смысле, что переписать эту субвекторизацию на другой асм другого процессора+компилятора можно, как можно и посмотреть реализацию структуры jump_buf и сделать переключатель, как у Rst7, привязанный к процессору+компилятору, но переписываемый под любую другую компбинацию. А тут - привязка к конкретному инструменту. Но раз в примере всё равно использован gcc, то... в нём можно взять адрес метки.
Во-первых, при этом можно WherePC сделать макросом, адрес вычисляется линкером:

Код

#define glue2(a,b) a##b
#define WPC_LABEL(a,b) glue2(a,b)

#define WherePC(a) { a = &&WPC_LABEL(WPC,__LINE__); WPC_LABEL(WPC,__LINE__):; }

volatile unsigned char a;

void *p1;
void *p2;

void foo() {
    ++a;
    WherePC(p1);
    ++a;
    WherePC(p2);
    ++a;
}

И результат компиляции:

Код

foo:
    lds r24,a
    subi r24,lo8(-(1))
    sts a,r24
    ldi r24,lo8(gs(.L2))
    ldi r25,hi8(gs(.L2))
    sts (p1)+1,r25
    sts p1,r24
.L2:
    lds r24,a
    subi r24,lo8(-(1))
    sts a,r24
    ldi r24,lo8(gs(.L3))
    ldi r25,hi8(gs(.L3))
    sts (p2)+1,r25
    sts p2,r24
.L3:
    lds r24,a
    subi r24,lo8(-(1))
    sts a,r24
    ret

Во вторых, этот макрос при такой постановке вопроса не нужен вообще:
http://forum.sources.ru/index.php?showtopi...p;#entry1929594

В переводе на AVR-ский язык

Код

ISR(INT0_vect)
{
    static void *next_state = &&start;

    goto *next_state;

  start:
    next_state = &&idle;
    return;

  idle:
    if (PINB & 0x01) {
        PORTB |= 0x80;
        next_state = &&drain;
    }
    return;

  drain:
    if (PINB & 0x02) {
        PORTB &= ~0x80;
        next_state = &&idle;
    }
    return;
}

И результат:

Код

    .text
    .size    foo, .-foo
.global    __vector_1
__vector_1:
    push __zero_reg__
    push __tmp_reg__
    in __tmp_reg__,__SREG__
    push __tmp_reg__
    clr __zero_reg__
    push r24
    push r25
    push r30
    push r31

    lds r30,next_state.1519
    lds r31,(next_state.1519)+1
    ijmp
.L6:
.L13:
    ldi r24,lo8(gs(.L7))
    ldi r25,hi8(gs(.L7))
    sts (next_state.1519)+1,r25
    sts next_state.1519,r24
    rjmp .L12
.L7:
    sbis 35-0x20,0
    rjmp .L12
    sbi 37-0x20,7
    ldi r24,lo8(gs(.L10))
    ldi r25,hi8(gs(.L10))
    sts (next_state.1519)+1,r25
    sts next_state.1519,r24
    rjmp .L12
.L10:
    sbis 35-0x20,1
    rjmp .L12
    cbi 37-0x20,7
    rjmp .L13
.L12:

    pop r31
    pop r30
    pop r25
    pop r24
    pop __tmp_reg__
    out __SREG__,__tmp_reg__
    pop __tmp_reg__
    pop __zero_reg__
    reti

    .data
next_state.1519:
    .word    gs(.L6)