Caro leitor, no último artigo abordamos sobre como compilar a biblioteca CMSIS DSPLIB para os microcontroladores ARM Cortex-M4 da Texas instruments, mais especificamente para a linha MSP432 que une as características de baixo consumo da já consagrada linha MSP430 com o poder de processamento compatível com o dos núcleos ARM Cortex-M (podendo ser empregado também nas linhas Stellaris e Tiva). Esse microcontrolador é bem interessante para os desenvolvedores que já utilizam a linha MSP430 já que apesar do núcleo ARM Cortex-M, os periféricos são herdados da linha MSP430.
Para testar nossa biblioteca utilizaremos um exemplo fornecido junto à própria, entretanto, por ser um exemplo para a linha Tiva/Stellaris, serão necessários alguns pequenos ajustes.
De antemão, indico que o leitor crie alguns templates facilitando sua vida em novos projetos, visto que o processo de configuração é semelhante ao apresentado no artigo passado, com exceção da compilação da biblioteca. Desta maneira você pode apenas criar cópias dos templates e ir modificando os nomes de acordo com a necessidade.
Iniciando a configuração
Para começar, iremos importar um template com a MSP432WARE DriverLib já configurada. Após devidamente configurado, este formará a base para nosso teste e seus próximos projetos.
Dentro do Code Composer Studio (estou utilizando a versão 6.2 do CCS) acesse o “Resource Explorer”, um recurso bastante interessante que permite acessar exemplos. documentação e drivers dos microcontrolares. Neste ponto você já deve ter a “MSP432WARE” instalada (neste momento estou utilizando a versão 3.50.00.02), caso não tiver, realize o procedimento para intala-la.
Os Melhores Treinamentos sobre Sistemas embarcados e IoT
Cursos com professores qualificados para acelerar sua carreira e projetos
Expanda a MSP432WARE e depois “Libraries >> Driver library >> MSP432P4xx >> Example Projects”. Você tem duas opções, uma que linka os arquivos da biblioteca com a pasta padrão em seu computador, inclusive com a biblioteca pre-compilada, o que acelera bastante a compilação do projeto (empty_project), e uma segunda opção que já traz dentro do próprio projeto os arquivos necessários (empty_project_from_source), algo interessante quando você não quer ficar dependente da versão de biblioteca instalada no computador (facilitando o compartilhamento do projeto). Importe a que achar mais interessante, ao final renomeie o projeto para torná-lo simples de ser identificado como um template no futuro.
Com o projeto renomeado, iremos criar um novo PATH VARIABLE, assim como realizamos no artigo anterior. Este servirá para apontar para a pasta da CMSIS que contém tanto os headers como a biblioteca que você já compilou anteriormente. Clique em “Resource >> Linked Resource” e então adicione um novo “Path variable”, este deverá apontar para a pasta da CMSIS.
Clique com o botão direito sobre o projeto e selecione “Properties”. Vá até ao submenu “Build >> MSP432 Compiler >> Processor Options” (para o Stellaris ou Tiva estes serão diferentes, mas a sequência é a mesma). Verifique se o “Target processor” está como “7M4”, se o “Designate code state” está em “16” e se o “floating point support” está em “FPv4SPD16”.
Agora em “Optimization”, em “Optimization level” selecione “off”, e em “speed vs size” selecione a opção que melhor se adequar, eu tenho preferido manter no nível “2”, mantendo um bom equilíbrio entre tamanho e desempenho. Neste ponto prefiro manter a otimização desativada para não interferir no processo de debug.
Expanda “Advanced options” e selecione “Assembler options”. Marque o ítem “Use unified assembly language (–ual)”.
Em “Advanced Options >> Predefined Symbols”, Adicione os seguintes valores “ARM_MATH_CM4” e “__FPU_PRESENT=1” (ambos sem as aspas).
Agora em “Include Options” adicione um “#include search path”, clique em adicionar, após isso clique em “Variables” e busque pela PATH VARIABLE que você criou. Após isso clique em “Extend” e selecione a pasta “Include”.
Em “Runtime Model Options” selecione “On” em “Place each function in a separate subsections”.
Agora fica faltando apenas linkar a biblioteca CMSIS já compilada, o arquivo “.lib” que você gerou anteriormente. Vá em “MSP432 Linker >> File Search Path”, clique em adicionar em “include library file or… (–library, -l)” e depois em “Variables”. busque pela PATH VARIABLE que você criou. Após isso clique em “Extend”. Na árvore procure pela pasta “lib” até encontrar a subpasta onde você salvou o “.lib” (neste ponto vem a importância de salvar o lib junto da pasta da CMSIS).
Após clicar em OK o projeto já estará praticamente pronto, mas para usufruir da DSPLIB é necessário incluir seu header. Utilize o código a seguir como referência para o “main.c”
/* Based in:
* -------------------------------------------
* MSP432 DriverLib - v3_21_00_05
* -------------------------------------------
*
* --COPYRIGHT--,BSD,BSD
* Copyright (c) 2016, Texas Instruments Incorporated
* All rights reserved.
*
* -------------------------------------------
* MSP432 Empty Project
*
* Description: An empty project prepared to use
* the driverlib and cmsis dsplib
*
* MSP432P401
* ------------------
* /|\| |
* | | |
* --|RST |
* | |
* | |
* | |
* | |
* | |
*
* Base in the example from TI: MSP432 DriverLib - v3_21_00_05
* Updated by: Haroldo Amaral - agaelema@gmail.com
* 2017/02/21
*/
/* DriverLib Includes */
#include "driverlib.h"
/* ARM CMSIS DSPLIB */
#include "arm_math.h"
/* Standard Includes */
#include <stdint.h>
#include <stdbool.h>
void main(void)
{
// Stop watchdog timer
MAP_WDT_A_holdTimer();
// WDT_A_hold(WDT_A_BASE);
/*
* Loop
*/
while(1)
{
}
}
Neste ponto você pode tentar realizar um “Build” para ver se não surgiu nenhum problema (e ele não deve surgir).
Testando a CMSIS
Com base neste nosso template executaremos nosso exemplo da CMSIS DSPLIB. Escolhi o exemplo de filtro FIR por ter um resultado bastante “visual”, mas o mesmo processo pode ser empregue nos outros exemplos para que possa avaliar outras funcionalidades da biblioteca.
Para um microcontrolador das linhas Stellaris ou Tiva seria apenas um processo de copiar os arquivos necessários e compilar, mas no MSP432 surge a necessidade de realizarmos uma pequena modificação. O watchdog herdado dos MSP430 precisa ser desabilitado logo no início do “main”. Caso este procedimento não for realizado, o cão-de-guarda será disparado e irá resetar o microcontrolador.
Além disso, para já incluir alguma funcionalidade da DRIVERLIB iremos acionar o led presente no GPIO P1.0 durante a execução do processamento, tornando possível verificar o tempo de processamento com um analisador lógico ou mesmo com um osciloscópio.
Para o teste crie uma cópia do template e renomeie como desejado. Agora iremos importar os arquivos referentes ao exemplo. Clique com o botão direito sobre o nome do projeto e selecione “Add Files…”. Na janela seguinte navegue até a pasta da CMSIS, então “DSP_Lib >> Examples >> arm_fir_example >> ARM”. Selecione os arquivos “arm_fir_data.c”, “arm_fir_example_f32.c”, “math_helper.c”, “math_helper.h” e “Abstract.txt” (este opcional), conforme a figura a seguir. Selecione “Copy Files” para evitar de modificar os arquivos originais dentro da pasta da CMSIS.
Neste ponto é necessário realizar um mix entre o código do arquivo “arm_fir_example_f32.c” e do “main.c”, introduzindo no arquivo do exemplo o #include referente a DRIVERLIB e também a função para desabilitar o Watchdog. Não é um processo complicado e você pode realizá-lo sem problemas, mas para facilitar sua vida você poderá copiar todo o código a seguir e substituir o código do arquivo “arm_fir_example_f32.c”. Lembre-se de ao final excluir o arquivo “main.c” para não gerar duplicidade e erros de compilação. Isto pode ser feito excluindo o arquivo do build ou então deletando-o (o que pode gerar menos problemas no futuro).
/* Based in: "arm_fir_example" from the CMSIS DSPLIB, by ARM
* ----------------------------------------------------------------------
* Copyright (C) 2010-2012 ARM Limited. All rights reserved.
*
* $Date: 17. January 2013
* $Revision: V1.4.0
*
* Project: CMSIS DSP Library
* Title: arm_fir_example_f32.c
*
* Description: Example code demonstrating how an FIR filter can be used
* as a low pass filter.
*
* Target Processor: Cortex-M4/Cortex-M3
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* - Neither the name of ARM LIMITED nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* ----------------------------------------------------------------------
*
* Modified/Updated by: Haroldo Amaral - agaelema@gmail.com
* 2017/02/21
*/
/* ----------------------------------------------------------------------
* Include Files
* ------------------------------------------------------------------- */
/* DriverLib Includes */
#include "driverlib.h"
#include "arm_math.h"
#include "math_helper.h"
/* ----------------------------------------------------------------------
* Macro Defines
* ------------------------------------------------------------------- */
#define TEST_LENGTH_SAMPLES 320
#define SNR_THRESHOLD_F32 140.0f
#define BLOCK_SIZE 32
#define NUM_TAPS 29
/* -------------------------------------------------------------------
* The input signal and reference output (computed with MATLAB)
* are defined externally in arm_fir_lpf_data.c.
* ------------------------------------------------------------------- */
extern float32_t testInput_f32_1kHz_15kHz[TEST_LENGTH_SAMPLES];
extern float32_t refOutput[TEST_LENGTH_SAMPLES];
/* -------------------------------------------------------------------
* Declare Test output buffer
* ------------------------------------------------------------------- */
static float32_t testOutput[TEST_LENGTH_SAMPLES];
/* -------------------------------------------------------------------
* Declare State buffer of size (numTaps + blockSize - 1)
* ------------------------------------------------------------------- */
static float32_t firStateF32[BLOCK_SIZE + NUM_TAPS - 1];
/* ----------------------------------------------------------------------
** FIR Coefficients buffer generated using fir1() MATLAB function.
** fir1(28, 6/24)
** ------------------------------------------------------------------- */
const float32_t firCoeffs32[NUM_TAPS] = { -0.0018225230f, -0.0015879294f,
+0.0000000000f, +0.0036977508f, +0.0080754303f, +0.0085302217f,
-0.0000000000f, -0.0173976984f, -0.0341458607f, -0.0333591565f,
+0.0000000000f, +0.0676308395f, +0.1522061835f, +0.2229246956f,
+0.2504960933f, +0.2229246956f, +0.1522061835f, +0.0676308395f,
+0.0000000000f, -0.0333591565f, -0.0341458607f, -0.0173976984f,
-0.0000000000f, +0.0085302217f, +0.0080754303f, +0.0036977508f,
+0.0000000000f, -0.0015879294f, -0.0018225230f };
/* ------------------------------------------------------------------
* Global variables for FIR LPF Example
* ------------------------------------------------------------------- */
uint32_t blockSize = BLOCK_SIZE;
uint32_t numBlocks = TEST_LENGTH_SAMPLES / BLOCK_SIZE;
float32_t snr;
/* ----------------------------------------------------------------------
* FIR LPF Example
* ------------------------------------------------------------------- */
int32_t main(void)
{
// Stop watchdog timer
MAP_WDT_A_holdTimer();
// WDT_A_hold(WDT_A_BASE);
// Set P1.0 to output direction - RED LED in the launchpad MSP432
ROM_GPIO_setAsOutputPin(
GPIO_PORT_P1,
GPIO_PIN0
);
// Set pin in low state
ROM_GPIO_setOutputLowOnPin(
GPIO_PORT_P1,
GPIO_PIN0
);
// Set P2.0 and P2.1 to output direction -
// Red and Green led in the launchpad MSP432
ROM_GPIO_setAsOutputPin(
GPIO_PORT_P2,
GPIO_PIN0|GPIO_PIN1
);
// Set pin in low state
ROM_GPIO_setOutputLowOnPin(
GPIO_PORT_P2,
GPIO_PIN0|GPIO_PIN1
);
uint32_t i;
arm_fir_instance_f32 S;
arm_status status;
float32_t *inputF32, *outputF32;
/* Initialize input and output buffer pointers */
inputF32 = &testInput_f32_1kHz_15kHz[0];
outputF32 = &testOutput[0];
/* Call FIR init function to initialize the instance structure. */
arm_fir_init_f32(&S, NUM_TAPS, (float32_t *) &firCoeffs32[0],
&firStateF32[0], blockSize);
/* ----------------------------------------------------------------------
** Call the FIR process function for every blockSize samples
** ------------------------------------------------------------------- */
// Toggle P2.0 output
ROM_GPIO_toggleOutputOnPin(
GPIO_PORT_P2,
GPIO_PIN0
);
for (i = 0; i < numBlocks; i++) {
arm_fir_f32(&S, inputF32 + (i * blockSize), outputF32 + (i * blockSize),
blockSize);
}
// Toggle P2.0 output
ROM_GPIO_toggleOutputOnPin(
GPIO_PORT_P2,
GPIO_PIN0
);
/* ----------------------------------------------------------------------
** Compare the generated output against the reference output computed
** in MATLAB.
** ------------------------------------------------------------------- */
snr = arm_snr_f32(&refOutput[0], &testOutput[0], TEST_LENGTH_SAMPLES);
if (snr < SNR_THRESHOLD_F32) {
status = ARM_MATH_TEST_FAILURE;
// If wrong - Toggle P1.0 output - second red led
ROM_GPIO_toggleOutputOnPin(
GPIO_PORT_P1,
GPIO_PIN0
);
}else{
status = ARM_MATH_SUCCESS;
// If OK - Toggle P2.1 output - Green Led
ROM_GPIO_toggleOutputOnPin(
GPIO_PORT_P2,
GPIO_PIN1
);
}
/* ----------------------------------------------------------------------
** Loop here if the signal does not match the reference output.
** ------------------------------------------------------------------- */
if (status != ARM_MATH_SUCCESS)
{
while (1);
}
while (1); /* main function does not return */
}
O resultado do exemplo é apresentado na figura a seguir, onde um sinal senoidal é sobreposto a outro de maior frequência e com o filtro FIR é possível isolar apenas a fundamental. Na launchpad, caso ocorra algum erro na verificação dos resultados será aceso o led vermelho (P1.0), caso tudo corra corretamente será aceso o led verde (P2.1).
Caro leitor, chegamos ao final deste artigo. Espero que seja útil nos seus próximos projetos. Para dúvidas e comentários utilize o campo abaixo.
Até a próxima.
