Conhecendo Hardware Parte 2

Document Sample
Conhecendo Hardware Parte 2 Powered By Docstoc
					        Interrupções

        Ivan Saraiva Silva
Sistemas de Tempo Real Embutidos
              O Problema
• Nem sempre é possível garantir que o
  sistema (embutido) vai reagir rapidamente a
  eventos externos.
• Exemplo
  – Em um sistems automatizados de controle de
    trem elétrico
  – O trem está desenvolvendo sua velocidade
    máxima quando um sensor avisa da presença de
    um obstáculo na linha.
              Uma solução
• Interrupção
• Uma interrupção deve causar a suspensão
  da atividade em execução para que a
  interrupção seja tratada
• Interrupção pode introduzir novos
  problemas
  – Programabilidade
  – Imprevisibilidade
           Conceitos básicos
• Em sistemas embutidos baseados em micro-
  controladores
  – Aplicações desenvolvidas em linguagens de
    alto nível são traduzidas para código assembly
  – A maioria dos comandos da linguagem C, por
    exemplo, são traduzidos em uma série de
    instruções assembly
          Conceitos básicos
• A maioria dos micro-controlador possuem
  pinos de interrupção (IRQ – Interrupt
  Request)
• Quando um destes pinos é ativado o micro-
  controlador para a seqüência de execução
  apontada pelo PC e salta para uma rotina de
  tratamento da interrupção
             Conceitos básicos
• Tarefas da rotina de tratamento
   – Salvar contexto
   – Tratar a interrupção
   – Restaurar contexto
• Para a maioria dos microcontroladores é possível
  desabilitar interrupções
• A maioria dos microcontroladores dispões de
  interrupções não macaráveis (não podem ser
  desabilitadas)
          Conceitos básicos
• Sobre interrupções e microntroladores é
  necessário conhecer
  – Onde encontrar a rotina de tratamento da
    interrupção
  – Se duas interrupções ocorrem ao mesmo tempo
    qual é trataDa primeiro
  – O que acontece se uma interrupção ocorre
    quando interrupções estão desabilitadas
          Conceitos básicos
– O que acontece se o programador esquece de reabilitar
  as interrupções depois elas foram desabilitadas?
– O que acontece se o programador desabilita as
  interrupções quando elas já estão desabilitadas?
– O que acontece se o programador habilita as
  interrupções quando elas já estão habilitadas?
– As interrupções estão habilitadas ou desabilitadas
  quando o microcontrolador é inicializado?
– Rotinas de interrupçào podem ser escritas em C?
     Variáveis Compartilhadas
• Um problema comum ocorre devido a
  necessidade de comunicação entre as tarefas
  do sistema e as rotinas de interrupção
• Normalmente esta comunicação é feita por
  intermédio do compartilhamento de
  variávies.

               EXEMPLO
                         Exemplo
void main (void)                    Hardware de leitura da
{                                   temperatura interrompe:
  int iTemp0, iTemp1;               • se uma temperatura muda
  whilw (TRUE)                      • periodicamente
    {
      iTemp[0] = iTemperature[0];
      iTemp[1] = iTemperature[1];   void interrupt vReadTemp (void)
      if (iTemp0 != iTemp1)         {
         !!! ALARME;                  iTemperature[0] = !! Lê temp;
   }                                  iTemperature[1] = !! Lê temp;
}                                   }
                     Alarme Falso
void main (void)
{
  int iTemp0, iTemp1;               E se uma interrupção
  whilw (TRUE)                         acontecer aqui?
    {
      iTemp[0] = iTemperature[0];
      iTemp[1] = iTemperature[1];
      if (iTemp0 != iTemp1)
         !!! ALARME
   }                                     Alarme falso
}
                   Uma Solução (?)
void main (void)           Hardware de leitura da
{                          temperatura interrompe:
                           • se uma temperatura muda
  whilw (TRUE)             • periodicamente
    {
if (iTemperature[0] !=
        iTemperature[1])   void interrupt vReadTemp (void)
       !!! ALARME          {
   }                         iTemperature[0] = !! Lê temp.
}                            iTemperature[0] = !! Lê temp.
                           }
                 Alarme Falso
...
Begin: MOVE R1, (iTemperature[0]
       MOVE R2, (iTemperature[1]
       SUB     R1,R2                E se uma interrupção
       JCOND ZERO, Begin               acontecer aqui?
...
...
...   Código Alarme
...
...                                Alarme falso
      Quando este problema é
           percebido
• As 5 da noite na sexta-feira
• Quando você não estiver prestando atenção
• Quando não se dispões de recursos para
  depuração
• Quando seu sistema foi acionado em Marte
• Durante a demonstração para o Cliente
       FALHA QUANDO NÃO DEVERIA
                    A SOLUÇÃO
void main (void)
{                                   Hardware de leitura da
  int iTemp0, iTemp1;               temperatura interrompe:
  whilw (TRUE)                      • se uma temperatura muda
    {                               • periodicamente
      disable ( );
      iTemp[0] = iTemperature[0];
                                    void interrupt vReadTemp (void)
      iTemp[1] = iTemperature[1];
                                    {
      enable ( );
                                      iTemperature[0] = !! Lê temp.
      if (iTemp0 != iTemp1)
                                      iTemperature[0] = !! Lê temp.
         !!! ALARME;
                                    }
   }
}
                      A Solução
...
Begin: DI (Instrução Disable Interruption)
       MOVE R1, (iTemperature[0])
       MOVE R1, (iTemperature[1])
        EI (Instrução Enable Interruption)
       SUB       R1,R2
       JCOND ZERO, Begin
...
...
...   Código Alarme
...
...
                     Mais Exemplo
void interrupt vUpdateTime (void)
{++iSeconds;                        Obviamente podem ocorrer
  if (iSeconds >=60)                problemas se houver interrupção
    {iSeconds = 0;                  no calculo dos segundos desde
      ++iMinutes;                   meia noite
      if (iMinutes >=60)
        {iMinutes = 0;
                                    long lSencoSinceMidnight (void)
          ++ iHours;
                                    {
          if (iHours >=24)
                                      return ((((iHours*60)+iMinuts)*
            iHours = 0;
                                      60)+iSeconds);
         }
                                    }
     }
}
                          Soluções
long lSencoSinceMidnight (void)    long lSencoSinceMidnight (void)
{                                  {
  disable ( );                       long lReturnVal
  return ((((iHours*60)+iMinuts*     disable ( );
  60)+iSeconds);                     lReturnVal =
  enable ( );                          (((iHours*60)+iMinuts)*60)
}                                     +iSeconds;
      ERRADO                         enable ( );
                                     return (lReturnVal);
                                   }
                                   SE CHAMADO EM SEÇÃO
                                   CRÍTICA?
                          Soluções
long lSencoSinceMidnight (void)
                                     Desable retorna
{                                    TRUE se não
  long lReturnVal                    desabilitado antes
  Bool fInterruptStateOld;
  fInterruptStateOld =disable ( );
  lReturnVal =
    (((iHours*60)+iMinuts)*60)
    +iSeconds;
  if(fInterruptStateOld)
     enable ( );
  return (lReturnVal);
}
                         Soluções
void interrupt vUpdateTime (void)
{
  ++lSecondsToday;
  if (lSecondsToday == 60*60*24)
     lSecondsToday = 0L;            Solução se registradores do
}                                   micro-controlador longos
long lSencoSinceMidnight (void)
                                    MOVE R1, (lSecondsToday)
{
                                    RETURN
  return (lSecondsToday);
}
                          Soluções
void interrupt vUpdateTime (void)
{
  ++lSecondsToday;
  if (lSecondsToday == 60*60*24)
     lSecondsToday = 0L;
}                                 long lSencoSinceMidnight (void)
                                  {
                                    long lReturn;
                                    lReturn = lSecondsToday;
  Se duas leituras são              while (lReturn != lSecondsToday)
  idênticas devem estar                  lReturn = lSecondsToday;
  certas                            return (Return);

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:7
posted:5/27/2012
language:Portuguese
pages:21