ASM51

Estava procurando na net algum AN a respeio disso.

Como cofigurar o timer, setar a interrupção para deteçao de mudança de borda (LO to HI).

Alguém tem algo a nível dos blocos?

Para configurar essa interrupção é preciso selecionar a interrupção no arquivo boot template, GPIO interrupt.

Ola Alessandro, eu estou tentando usar um pino como int, mas estou apanhando um pouco.

Bom ele gerou um arquivo "psocgpioint.h" e nele está as definições de todos os pinos usados no sistema, no caso um deles é o botão que chamei de "SW".

segue o código:

Código: Selecionar todos

// SW address and mask defines
#pragma   ioport   SW_Data_ADDR:   0x4
BYTE         SW_Data_ADDR;
#pragma   ioport   SW_DriveMode_0_ADDR:   0x104
BYTE         SW_DriveMode_0_ADDR;
#pragma   ioport   SW_DriveMode_1_ADDR:   0x105
BYTE         SW_DriveMode_1_ADDR;
#pragma   ioport   SW_DriveMode_2_ADDR:   0x7
BYTE         SW_DriveMode_2_ADDR;
#pragma   ioport   SW_GlobalSelect_ADDR:   0x6
BYTE         SW_GlobalSelect_ADDR;
#pragma   ioport   SW_IntCtrl_0_ADDR:   0x106
BYTE         SW_IntCtrl_0_ADDR;
#pragma   ioport   SW_IntCtrl_1_ADDR:   0x107
BYTE         SW_IntCtrl_1_ADDR;
#pragma   ioport   SW_IntEn_ADDR:   0x5
BYTE         SW_IntEn_ADDR;
#define SW_MASK 0x1


Minha dúvida é como eu uso isso no main, se voçe já fez isso pode me ajudar.

obrigado.

A interrupção esta no arquivo boot.asm. Não sou perito nisso ainda, estou aprendendo também.

Neste aquivo tem os vetores de interrupção, para meu caso onde o P0_0 é o pino de interrupçao, ficou:

org 1Ch ;GPIO Interrupt Vector
ljmp _rasingedge ;PSoC_GPIO_ISR
reti

O resto é o corpo do programa:

#pragma interrupt_handler rasingedge

void rasingedge(void)
{
seu codigo aqui....
}

Foram dois dias o dia inteiro para descobrir isso.....

Estou tentando configurar o pino P1_0 para gerar uma interrupção na borda de subida. No Editor de dispositivos a única configuração que tem de ser feita é: ?

Name Port Select Drive Interrupt

Port_1_0 P1[0] StdCPU HighZAnalog RisingEdge

Ao se fazer isso o bit GIE já fica setado ? Se não, me parece que se habilita globalmente interrupção fazendo:

M8C_EnableGInt; // Habilita globalmente interrupções

Quanto ao bit 5 do registrador Int_Msk0, fica setado ? Como se faz para seta-lo ?

No código abaixo o que precisa ser feito para se gerar uma interrupção na transição de subida no pino P1_0

//----------------------------------------------------------------------------
// C main line
//----------------------------------------------------------------------------

#include <m8c.h> // part specific constants and macros
#include "PSoCAPI.h" // PSoC API definitions for all User Modules

unsigned char digitos[4]= {'0','0','0',0x00};
unsigned char num = 0;
unsigned char dig;

void main()
{

INT_MSK0 = 0x20;
M8C_EnableGInt; // Habilita globalmente interrupções
LCD_Start(); // Inicializa o display
LCD_Position(0,1); // Posiciona o cursor na primeira linha coluna 1
LCD_PrCString("TESTE - PSoC"); // Escreve TESTE - PSoC na primeira linha
LCD_Position(1,6); // Posiciona o cursor na segunda linha coluna 6
LCD_PrString(digitos); // Escreve o valor inicial da contagem 000
while(1); // Espera interupção
}

#pragma interrupt_handler PSoC_GPIO_ISR

void PSoC_GPIO_ISR(void)
{
num++; // Incrementa o contador
dig = num / 100 + '0'; // Calcula o digito das centenas
digitos[0] = dig; // Põe a centena na string
dig = (num % 100) / 10 + '0'; // Calcula o digito das dezenas
digitos[1] = dig; // Põe a dezena na string
dig = (num % 10) + '0'; // Calcula o digito das unidades
digitos[2] = dig; // Põe a unidade na string
LCD_Position(1,6); // Posiciona o cursor na segunda linha coluna 6
LCD_PrString(digitos); // Escreve o valor atual da contagem
}


Grato por qq ajuda.
Zé Iran

Ola Senhores.
Zé Iran.
Esta quase certo, mas o driver da porta deve ser diferente.

HighZAnalogic = Desconecta completamente os pinos de qualquer barramento, inclusive do próprio buffer de registrador da porta, ou seja o núcleo não conseguira enxergar essa mudança de borda.
Utilize outro driver qualquer.

Quanto ao registrador Int_Msk0, eu não sei ao certo tenho que dar uma espiada no datasheet, mas eu fiz uma vez a interrupção funcionar e não me lembro de telo utilizado.

Boa sorte

É, não deu certo, mudei o drive para pull down, strong, open drain low e nada de funcionar.

Imagino que o problema deve estar na habilitação da interrupção, não sei se as instruções:

INT_MSK0 = 0x20;
M8C_EnableGInt;

Habilitam a interupção por GPIO e global respectivamente.

Estou usando o push button S1 da placa PSoCEVAL1 para gerar a transição de subida na P1_0. Vou continuar fuçando aqui, qualquer dica será bem vinda.

Grato,
Zé Iran.

Vixi !!! parece que essa questão é meio mística, achei umas quatro receitas diferentes no fórum PSoCDeveloper para fazer essa interrupção funcionar.

Alguém tem aí uma que funcione comprovadamente?

Amanhã vou tentar testar umas.

Zé Iran.

Em seu arquivo boot.tpl o vetor da interrupção GPIO onde era `@INTERRUPT_7` está setado:

org 1Ch ;GPIO Interrupt Vector
ljmp _rasingedge ;PSoC_GPIO_ISR
reti

Grato Alessandro,

Segui sua receita e funcionou, o que fiz foi:

1 - No arquivo boot.asm alterei para:

org 1Ch ;GPIO Interrupt Vector
ljmp _rasingedge ;PSoC_GPIO_ISR
reti

2 - No arquivo boot.tpl alterei para:

org 1Ch ;GPIO Interrupt Vector
ljmp _rasingedge ;PSoC_GPIO_ISR `@INTERRUPT_7`
reti

3 - a rotina de tratamento de interrupção ficou assim:

#pragma interrupt_handler rasingedge

void rasingedge(void)
{
rotina aqui
}

Para habilitar interrupção por GPIO e global respectivamente, fiz:

M8C_EnableIntMask(INT_MSK0, INT_MSK0_GPIO);
M8C_EnableGInt; // Habilita globalmente interrupções
___________________________________________________________

Processo um tanto complicado, onde isso está documentado nos manuais do PSoC ? Será que para outras coisas teremos de seguir uma receita mágica dessas ?

Sei não ...

Zé Iran.

Então Iran,

Pelo pouco que vi, as interrpções precisam ser setadas no arquivo boot, ou nos ASM (se for interrupção TIMER por exemplo) das bibliotecas.

Talvez por falta de costume nosso, achamos um pouco "fora de mão".

No forum PSoCDevelop, verá que um tópico meu sobre essa dúvida rendeu muitas linhas....rs. Sou alcomen lá.

Esse tal de PSoC já me rendeu noites sem dormir, o Ricardo me deu uma grande ajuda também aqui.

Mas acho que compartilhando conhecimentos vamos nos acostumar com esse carinha...

Aos poucos estou trocando o que era em PIC para PSoC, estou agora colocando um display gráfico que rodava em PIC, um 128x64.

Estou gostando, principalmente nos projetos que antes tinham os lm358 (AMPOP), filtros, DA, tudo isso na placa e agora só tem um chip.

Questão de gosto também, mas gostei da idéia de usar ou nem usar apenas um cristal e voce escolhe a divisão dos Prescaler. Parei de ficar atrás de cristais para comprar de "X"MHz...rs. Mas tudo isso é questão de gosto pessoal.

Abraço,



Alessandro

Até que enfim funcionou essa interrupção, o esquema é como o Iran passou, mas não precisa alterar o boot.tpl (passo 2).

Eu alterei apenas o boot.asm.

segue o exemplo com botão, Led e WatchDog.

O programa pisca o led e quando preciona o botão(ligado na int), para de piscar. Voltando a piscar após a próxima int.

Código: Selecionar todos

//----------------------------------------------------------------------------
// C main line
//----------------------------------------------------------------------------

#include <m8c.h>        // part specific constants and macros
#include "PSoCAPI.h"    // PSoC API definitions for all User Modules

//----------------------------------------------------------------------------
// Declarações globais
//----------------------------------------------------------------------------
struct Bits
{
   char SW_Status  : 1;
   char LED_Status : 1;
};
struct Bits Status;

//----------------------------------------------------------------------------
// Rotina de delay para gastar tempo
//----------------------------------------------------------------------------
void delay(void)
{
   int i, j;
   for(i = 0; i < 255; i++)
   {      
      for(j = 0; j < 255; j++)
         M8C_ClearWDT;
   }   
}
//----------------------------------------------------------------------------
// Função da interrupção Pino1_1
// Modo RisingEdge
//----------------------------------------------------------------------------
#pragma interrupt_handler PSoC_GPIO_ISR
void PSoC_GPIO_ISR()
{
   Status.SW_Status = ~Status.SW_Status;
}

//----------------------------------------------------------------------------
// Função principal
//----------------------------------------------------------------------------
void main()
{
   M8C_EnableIntMask(INT_MSK0, INT_MSK0_GPIO);
   M8C_EnableGInt;             // Habilita globalmente interrupções
   M8C_EnableWatchDog;            // Habilita o WatchDog
   LED_1_Start();               // Habilita o Led
   Status.SW_Status = 0;
   Status.LED_Status = 0;
   while(1)
   {
      if(!Status.SW_Status)
      {
         LED_1_On();      
         delay();
         LED_1_Off();
         delay();
      }
      M8C_ClearWDT;   
   }   
}
// Fim


até+

Legal. Eu nem sabia desse negocio de MASK ..
Apenas preguiça de procurar no Datasheet .. Alguém poderia dizer o que o Registrador MASK faz .. ou indicar a fonte .. ?

Ricardo franco

Os registradores MASKx contém os bits de habilitação individual das interrupções.

Esses registros estão definidos no arquivo m8c.h

Dá uma lida da pagina 89 a 96 do PSOC_TRM_210.

at.