LAB - PIO - DRIVER

_pio_set(...)

Iremos começar com essa função que é uma das mais simples. Crie uma função no main.c com a seguinte estrutura:

/**
 * \brief Set a high output level on all the PIOs defined in ul_mask.
 * This has no immediate effects on PIOs that are not output, but the PIO
 * controller will save the value if they are changed to outputs.
 *
 * \param p_pio Pointer to a PIO instance.
 * \param ul_mask Bitmask of one or more pin(s) to configure.
 */
void _pio_set(Pio *p_pio, const uint32_t ul_mask)
{

}

Na primeira etapa iremos substituir a função que a Microchip já nos disponibiliza por uma criada por nós, em todo lugar no código que você faz o uso da função pio_set(...) substitua a chamada por essa recém criada _pio_set(...).

Agora será necessário entender como o PIO controla os pinos e o que deve ser feito para que ele atue sobre o pino como desejamos. A parte da secção do manual que fala sobre o PIO e suas saídas/entradas é a secção 32 do (manual SAME70), vamos analisar:

Lendo o texto, podemos descobrir que para termos 1 (set) no pino devemos escrever no registrador PIO_SODR, no manual tem mais detalhes sobre tudo do PIO. Vamos analisar a documentação especifica deste registrador (SODR):

Repare que esse registrador é do tipo write-only ou seja ele não pode ser lido, somente escrito. Cada bit desse registrador representa um pino, se pegarmos por exemplo o bit 30 desse registrador (pensando no PIOA) estaríamos nos referindo ao PA30, qualquer alteração ESCRITA nesse bit influenciará SOMENTE esse pino.

Agora que já sabemos o que deve ser feito para colocarmos acionarmos um pino (ativar) e considerando que ele já foi configurado como saída podemos escrever a implementação da função:

void _pio_set(Pio *p_pio, const uint32_t ul_mask)
{
    p_pio->PIO_SODR = ul_mask;
}

• *p_pio: é um endereço recebido do tipo Pio, ele indica o endereço de memória na qual o PIO (periférico) em questão está mapeado (vamos ver isso em detalhes).
• ul_mask: é a máscara na qual iremos aplicar ao registrador que controla os pinos para colocarmos 1 na saída.

O que isso significa? Significa que estamos acessando o periférico passado como referência a função (um dos cinco PIO disponíveis no uc: PIOA, PIOB, PIOC, ...) e estamos aplicando a máscara ul_mask no seu registrador PIO_SODR.

#define PIOA ((Pio    *)0x400E0E00U) /**< \brief (PIOA  ) Base Address */

  typedef struct {
__O  uint32_t PIO_PER;       /**< \brief (Pio Offset: 0x0000) PIO Enable Register */
__O  uint32_t PIO_PDR;       /**< \brief (Pio Offset: 0x0004) PIO Disable Register */
__I  uint32_t PIO_PSR;       /**< \brief (Pio Offset: 0x0008) PIO Status Register */
__I  uint32_t Reserved1[1];
__O  uint32_t PIO_OER;       /**< \brief (Pio Offset: 0x0010) Output Enable Register */
__O  uint32_t PIO_ODR;       /**< \brief (Pio Offset: 0x0014) Output Disable Register */
__I  uint32_t PIO_OSR;       /**< \brief (Pio Offset: 0x0018) Output Status Register */
__I  uint32_t Reserved2[1];
__O  uint32_t PIO_IFER;      /**< \brief (Pio Offset: 0x0020) Glitch Input Filter Enable Register */
__O  uint32_t PIO_IFDR;      /**< \brief (Pio Offset: 0x0024) Glitch Input Filter Disable Register */

#ifdef __cplusplus
  #define   __I     volatile        /*!< Defines 'read only' permissions                 */
#else
  #define   __I     volatile const  /*!< Defines 'read only' permissions                 */
#endif
  #define   __O     volatile        /*!< Defines 'write only' permissions                */
  #define   __IO    volatile        /*!< Defines 'read / write' permissions              */

_pio_clear(...)

Faça o mesmo para a função clear:

/**
 * \brief Set a low output level on all the PIOs defined in ul_mask.
 * This has no immediate effects on PIOs that are not output, but the PIO
 * controller will save the value if they are changed to outputs.
 *
 * \param p_pio Pointer to a PIO instance.
 * \param ul_mask Bitmask of one or more pin(s) to configure.
 */
void _pio_clear(Pio *p_pio, const uint32_t ul_mask)
{

}

_pio_pull_up(...)

Vamos implementar uma função que faz a configuração do pullup nos pinos do PIO, esse pullup é utilizado no botão da placa. Para isso declare a função a seguir:

/**
 * \brief Configure PIO internal pull-up.
 *
 * \param p_pio Pointer to a PIO instance.
 * \param ul_mask Bitmask of one or more pin(s) to configure.
 * \param ul_pull_up_enable Indicates if the pin(s) internal pull-up shall be
 * configured.
 */
void _pio_pull_up(Pio *p_pio, const uint32_t ul_mask,
        const uint32_t ul_pull_up_enable){

 }

Essa função recebe o PIO que irá configurar, os pinos que serão configurados e como último parâmetro se o pullup estará ativado (1) ou desativado (0).

_pio_set_input(...)

Agora vamos criar uma nova função para configurar um pino como entrada, para isso inclua os seguintes defines que serão utilizados como forma de configuração da função:

/*  Default pin configuration (no attribute). */
#define _PIO_DEFAULT             (0u << 0)
/*  The internal pin pull-up is active. */
#define _PIO_PULLUP              (1u << 0)
/*  The internal glitch filter is active. */
#define _PIO_DEGLITCH            (1u << 1)
/*  The internal debouncing filter is active. */
#define _PIO_DEBOUNCE            (1u << 3)

Esses defines serão passados como configuração da função _pio_set_input() no parâmetro ul_attribute. Declare no seu código a seguinte função:

/**
 * \brief Configure one or more pin(s) or a PIO controller as inputs.
 * Optionally, the corresponding internal pull-up(s) and glitch filter(s) can
 * be enabled.
 *
 * \param p_pio Pointer to a PIO instance.
 * \param ul_mask Bitmask indicating which pin(s) to configure as input(s).
 * \param ul_attribute PIO attribute(s).
 */
void _pio_set_input(Pio *p_pio, const uint32_t ul_mask,
        const uint32_t ul_attribute)
{

}

Para testar essa função substitua o seguinte trecho de código que configura um pino como entrada + o pull-up

pio_set_input(BUT_PIO, BUT_PIO_IDX_MASK, _PIO_DEFAULT);
_pio_pull_up(BUT_PIO, BUT_PIO_IDX_MASK, 1);

Para:

_pio_set_input(BUT_PIO, BUT_PIO_IDX_MASK, _PIO_PULLUP | _PIO_DEBOUNCE);

_pio_set_output(...)

Na aula passada utilizamos a função pio_set_output para configurarmos que o pino é uma saída. Iremos aqui definir uma nova função chamada de _pio_set_output() que implementa essa função.

Defina no seu código a função a seguir:

/**
 * \brief Configure one or more pin(s) of a PIO controller as outputs, with
 * the given default value. Optionally, the multi-drive feature can be enabled
 * on the pin(s).
 *
 * \param p_pio Pointer to a PIO instance.
 * \param ul_mask Bitmask indicating which pin(s) to configure.
 * \param ul_default_level Default level on the pin(s).
 * \param ul_multidrive_enable Indicates if the pin(s) shall be configured as
 * open-drain.
 * \param ul_pull_up_enable Indicates if the pin shall have its pull-up
 * activated.
 */
void _pio_set_output(Pio *p_pio, const uint32_t ul_mask,
        const uint32_t ul_default_level,
        const uint32_t ul_multidrive_enable,
        const uint32_t ul_pull_up_enable)
{

}

Essa função é um pouco mais complexa, e deve executar as seguintes configurações:

1. Configurar o PIO para controlar o pino

   • secção 32.5.2

     When a pin is multiplexed with one or two peripheral functions, the selection is controlled with the Enable Register (PIO_PER) and the Disable Register (PIO_PDR). The Status Register (PIO_PSR) is the result of the set and clear registers and indicates whether the pin is controlled by the corresponding peripheral or by the PIO Controller.

2. Configurar o pino em modo saída

   • secção 32.5.4

3. Definir a saída inicial do pino (1 ou 0)

   • aqui você pode fazer uso das duas funções recentes implementadas.

4. Ativar ou não o multidrive :

   • Leia a secção 32.5.6

5. Ativar ou não o pull-up :

   • utilize a função _pio_pull_up() recém declarada.

     Uma vez implementada a função, utilize ela no seu código substituindo a função pio_set_output() por essa função _pio_set_output(). Teste se o LED continua funcionando, se continuar quer dizer que sua função foi executada com sucesso.

Conceito B: _pio_get(...)

Implemente a função _pio_get():

/**
 * \brief Return 1 if one or more PIOs of the given Pin instance currently have
 * a high level; otherwise returns 0. This method returns the actual value that
 * is being read on the pin. To return the supposed output value of a pin, use
 * pio_get_output_data_status() instead.
 *
 * \param p_pio Pointer to a PIO instance.
 * \param ul_type PIO type.
 * \param ul_mask Bitmask of one or more pin(s) to configure.
 *
 * \retval 1 at least one PIO currently has a high level.
 * \retval 0 all PIOs have a low level.
 */
uint32_t pio_get(Pio *p_pio, const pio_type_t ul_type,
        const uint32_t ul_mask)
{}

Conceito A: _delay_ms(...)

Crie sua Própria função de delay_ms