Download - Guia de Uso - DSP28335 - R1
UNIVERSIDADE DO ESTADO DE SANTA CATARINA – UDESC
CENTRO DE CIÊNCIAS TECNOLÓGICAS – CCT
DEPARTAMENTO DE ENGENHARIA ELÉTRICA – DEE
GUIA DE USUÁRIO DSP F28335
JEAN CARLO CUNHA
WENDEL DE OLIVEIRA ROSSI
JOINVILLE 2014
SUMÁRIO
1 INTRODUÇÃO ........................................................................................................................................ 3
2 INSTALAÇÃO ......................................................................................................................................... 3
3 CONFIGURAÇÃO ................................................................................................................................... 6
4 GUIA DE USO ATRAVÉS DO PSIM .......................................................................................................... 8
4.1 BIBLIOTECA TF28335 NO PSIM ................................................................................................................. 8
4.2 GERAÇÃO DE CÓDIGO EM PSIM ............................................................................................................ 10
4.3 COMPILANDO O PROJETO PARA O CODE COMPOSER STUDIO (CCS) ..................................................... 11
4.4 CARREGANDO O CÓDIGO NO DSP (VERSÃO RAM DEBUG) ..................................................................... 13
4.4.1 Conexão entre DSP e a porta USB. ................................................................................................ 13
4.4.2 Métodos de carregamento do código ao DSP ............................................................................... 14
4.5 EXECUTANDO O CÓDIGO NO DSP .......................................................................................................... 16
4.6 CARREGANDO O CÓDIGO PARA O DSP (VERSÃO RAM RELEASE) ............................................................ 17
4.7 CARREGANDO O CÓDIGO PARA O DSP (VERSÃO FLASH RELEASE) ......................................................... 18
4.8 CARREGANDO O CÓDIGO PARA O DSP (VERSÃO FLASH RAM RELEASE) ................................................. 19
5 PROGRAMAÇÃO EM C DSP.................................................................................................................. 22
5.1 CRIANDO UM PROJETO .......................................................................................................................... 22
5.1.1 A Pilha ........................................................................................................................................... 23
5.1.2 Compilação.................................................................................................................................... 23
5.1.3 Executando o Programa ................................................................................................................ 23
5.2 WATCH WINDOW .................................................................................................................................. 24
5.2.1 Single Step ..................................................................................................................................... 25
5.2.2 Breakpoint e Probepoint ............................................................................................................... 25
5.3 WATCH DOG TIMER ............................................................................................................................... 25
1 INTRODUÇÃO
O DSP (Digital Processing Signal) é um dispositivo específico desenvolvido em torno da solução de
operações matemáticas típicas para manipular dados digitais medidos por sensores de sinais. Seu
objetivo principal é processar esses dados digitais o mais rápido possível, para ser capaz de gerar dados
de saída em resposta ás entradas em tempo real.
O guia visa apresentar conhecimentos sobre o DSP, demonstrando passo a passo de como deve se
proceder o uso do mesmo, desde a instalação, à utilização. O mesmo possui exemplos no qual vai
auxiliar os usuários a entender os procedimentos necessários para executar um projeto.
2 INSTALAÇÃO
Para Instalar o Software C2000 Code Composer Studio 3.3, é necessário seguir alguns passos:
1. Inicialmente, execultamos o arquivo setup.exe.
2. Prossiga os passos normalmente pressionando next, e pressione a opção Custom Install, como
demonstrado na Figura 2.1.
Figura 2.1 - Custom Install.
3. Após clicar em Custom Install, selecione a opção DSP/BIOS e escolha a opção Entire feature will be
unavailable como mostrado na Figura 2.2. A maioria das aplicações com o C2000 não necessitam do
DSP/BIOS, por isso ele é desabilitado. Logo após isso, clique em next, e finalize a instalação. No caso de
falhas na permissão da instalação de alguns drivers selecionar a opção ignore e aguarde o final da
instalação.
Figura 2.2 - Desabilitar DSP/BIOS.
Ao final uma mensagem pode aparescer:
Click ‘OK’ e a instalação irá prosseguir.
Então há a mensagem:
Click OK e prossiga.
Finalizando a instalação
3 CONFIGURAÇÃO
Após realização da Instalação, é necessário configurar o Code Composer Studio (CCS) para um
microcontrolador C2000, deve-se seguir os seguintes passos:
1. Executar o arquivo criado no desktop Setup CCStudio v3.3.
2. Em Family, selecione a opção C28xx, como demonstra a Figura 3.1.
Figura 3.1 - Tipo de Dsp a ser utilizado.
3. Em Plataform selecione a opção xds100usb como demonstra a Figura 3.2.
Figura 3.2 - Tipo de Plataforma Utilizada.
4. Agora, todas as configurações que não são de C28x e as plataformas que não são xds100usb, foram
eliminados. Com isso, as configurações do C2000 MCU são mais faceis de ser encontradas. Nesse
tutorial, o MCU utilizado será o Piccolo F28335, logo deve-se selecionar a configuração a ser empregada,
neste caso, o Emulador F28335 xds100usb, como mostrado na Figura 3.3.
Figura 3.3 - Configuração a Ser utilizada.
5. Clique em “<<Add” para adicionar a configuração na tela esquerda.
6. Clique em Save & Quit e logo após em Yes para abrir o CCS.
7. Para os próximos passos, deve-se conectar o dispositivo para que o mesmo seja localizado e
configurado.
8. Se estiver com o quite DSP, um driver será instalado. E é perguntado se é desejado abrir o CCS.
9. Caso o driver do Kit não foi corretamente instalado. É necessário atualizar o driver. Na atualização pode-
se procurar o driver na pasta onde o CCS foi instalado. “C:\CCStudio_v3.3MCU” por exemplo.
4 GUIA DE USO ATRAVÉS DO PSIM
Através do SimCoder, o PSIM pode gerar automaticamente um código genérico do esquema de
controle. Este tutorial descreve, passo a passo, como gerar um código do PSIM, copilando e enviando o
código no Code Composer Studio, e rodando no DSP.
Para Ilustrar o processo, usa-se um exemplo localizado no diretório “examples\SimCoder\TI 1-Ch
DC-DC” na pasta do PSIM.
4.1 BIBLIOTECA TF28335 NO PSIM
Primeiramente, deve-se fazer uma cópia da pasta TI 1-Ch DC-DC em outro diretório, para que
arquivo original não seja modificado. Nesse tutorial, utiliza-se o diretório “C:\ TI 1-Ch DC-DC”. Após
realizar esse passo, pode-se abrir o esquemático com o nome de “1-ch dc-dc buck.psimsch”, presente
dentro da pasta que foi copiada. O mesmo é ilustrado na Figura 4.1.
Figura 4.1 -Esquemático 1-ch dc-dc buck.
O esquemático presente na Figura 4.1, possui dois elementos da biblioteca do hardware F28335:
Um Conversor A/D de 16 canais e um gerador de 1-fase PWM. É possível visualizar toda a biblioteca do
F28335 no PSIM, acessando Elements -> SimCoder -> TI F28335 Target. A mesma é apresentada na
Figura 4.2.
Figura 4.2 - Biblioteca completa F28335.
4.2 GERAÇÃO DE CÓDIGO EM PSIM
Primeiramente, antes de realizar a geração do código, deve-se referir a configuração do projeto para
o Code Composer Studio. Para realizar essa tarefa, basta dar um duplo click no “Simulation Control
Block” (Relógio presente na Figura 4.1), e configurar o Hardware Target para TI F28335. No bloco ao
lado do Hardware Target, para este caso, deve-se optar pela opção Ram Debug , como é apresentado na
Figura 4.3.
Figura 4.3 - Configuração do Simulation Control.
Com esse passo realizado, é possível gerar o código selecionando no PSIM na barra superior
Simulate -> Genarate Code. O código obtido encontra-se na Figura 4.4.
O PSIM não apenas gera o código, mas também gera todos os arquivos do projeto necessário para
as configurações: RAM Debug, Ram Realease, Flash Release e Flash Ram Release. Estes arquivos, e os
demais arquivos dependentes, são armazenados em uma sub-pasta no diretório “C:\TI 1-Ch DC-DC\1-ch
dc-dc buck (C code)”.
Figura 4.4 - Código gerado do esquemático da figura 6.
4.3 COMPILANDO O PROJETO PARA O CODE COMPOSER STUDIO (CCS)
Para realizar a compilação do projeto, a versão do Code Composer Studio (CCS) deve ser 3.3 ou
superior. Na hora de compilar, é possível que apareça uma mensagem “Unknown compiler option ‘--
float_support=fpu32’”, se caso ocorrer isso, é necessário atualizar o software. Tal procedimento
encontra-se no Apendice A.
Abra o CCS, vá em Project -> Open. Navegue até a pasta “C:\TI 1-Ch DC-DC\1-ch dc-dc buck (C
code)”, e selecione o projeto denominado “1_ch_dc_dc_buck.pjt”, como é mostrado na Figura 4.5.
Figura 4.5 - Projeto a ser aberto.
Clique em Open para continuar, e o CCS irá ser apresentado como na Figura 4.6.
Figura 4.6 - CCS ao abrir o Projeto.
Note que o CCS já está configurado para a opção RAM Debug, com isso todos os programas e dados
podem ser carregados pela memória RAM.
Para compilar o projeto, clique no icone na barra de ferramentas, ou vá em Project -> Build ou
F7 para construir o projeto (Ou clique em ou vá em Project -> Rebuild All para reconstruir o projeto
inteiro). Após completar a compilação, o CCS irá mostrar um aviso que é apresentado na Figura 4.7.
Figura 4.7 - Aviso do CCS após a compilação.
A mensagem warning, pode ser ignorada. Essa mensagem aparece quando o programa não é salvo
na memória flash.
4.4 CARREGANDO O CÓDIGO NO DSP (VERSÃO RAM DEBUG)
Para que seja carregado o código para o DSP, é necessário que a conexão entre o computador e o
mesmo seja adequada. Após isso, é possível carregar os códigos para o DSP de forma funcional.
4.4.1 Conexão entre DSP e a porta USB.
Inicialmente, conecte o cartão TM320F28335 no Canal 2 do Kit do Conversor Buck DC/DC, como
mostra a Figura 4.8.
Figura 4.8 - Conexão do Cartão no Kit.
Feito isso, deve-se conectar o cabo no DSP, e do DSP na porta USB do computador. Então, ligue os
interruptores SW1 e SW2 da placa. O interruptor SW3 serve para mostrar a saída do Canal 1 ou do Canal
2. Para esse caso, deve-se usar o SW3 para visualizar a saída do Canal 2.
No CCS, selecione Debug -> Connect ou (Alt+C) para conectar o computador ao DSP. Se a conexão
for feita com sucesso, na parte inferior esqueda do CCS irá mudar de Desconectado para Conectado,
como é demonstrado na Figura 4.9.
Figura 4.9 - Exibição de Conexão.
Caso a conexão não seja bem sucedida, uma mensagem irá aparecer avisando. Para resolver essa
situação, é simples, basta retirar o cabo da porta USB, desligar o interruptor SW1 do Kit. Feito isso,
reconecte o cabo novamente na porta USB, e re-ligue o interruptor SW1. Logo após esse passo,
selecione Debug -> Reset Emulator ou (Ctrl + Shift + R) e selecione Debug -> Connect novamente. Se a
conexão ainda não for estabilizada, verifique a se o driver que está sendo utilizado é o correto.
4.4.2 Métodos de carregamento do código ao DSP
Após a conexão ser estabilizada, há duas maneiras diferentes para carregar o código no DSP. Uma
delas é utilizando o “Load Program Function”. Vá até File -> Load Program, e especifique o arquivo. out,
onde nesse exemplo esta presente no diretório “C:\TI 1-Ch DC-DC\1-ch dc-dc buck (C
code)\RamDebug\1_ch_dc_dc_buck.out”. Com isso o CCS irá automaticamente carregar o código para a
memória RAM. Noque que o “Load Program Function”, trabalha apenas com as versões RAM Debug ou
RAM Release.
Outro método que permite trabalhar com ambas as funções, RAM e Flash, é através da função
“On-Chip Flash Programmer”, presente na barra de ferramentas em Tools->F28xx On-Chip Flash
Programmer, ou através do ícone . Ao realizar esse passo, uma janela é aberta denominada “Clock
Configuration”, que pode ser visualizado na Figura 4.10.
Figura 4.10 - Clock Configuration.
Note que a frequência denominada no DSP para o catão TM320F28335 é 25MHz, e os parâmetros
DIVSEL e PLLCR são /2 e 12 respectivamente para esse Kit. Eles podem ser diferentes para outro tipo de
Hardware.
Clique em no botão OK, e irá aparecer as configurações do Flash Programmer, como mostra a Figura
4.11.
Figura 4.11 - Flash Programmer Settings.
Mantenha as configurações presente na Figura 4.11, e clique em OK novamente, e uma nova janela
irá aparecer, como mostra a Figura 4.12.
Figura 4.12 - Configurações do On-Chip Flash Programmer para RAM Debug.
Já que o projeto foi configurado para “RAM Debug”, logo deve-se ter certeza que a opção “Load
RAM Only” esteja selecionada, como é demonstrado na Figura 4.12. Feito isso, deve-se clicar no botão
Execute Operation para carregar o código no DSP. Após o término, feche a janela.
4.5 EXECUTANDO O CÓDIGO NO DSP
Para rodar o programa no DSP, selecione na barra de ferramentas do CCS Debug -> Reset CPU. Feito
isso, selecione Debug -> Restart. Nesses dois procedimentos, irá abrir uma janela em cada um, que
poderá ser fechado momentaneamente. Selecionando Debug -> Go Main, onde outra janela irá se abrir,
demonstrando o programa principal, onde pode ser visualizado na Figura 4.13.
Figura 4.13 - Início do programa principal.
Feito esses passos, clique no ícone ou F5 para rodar o programa. Caso queira parar o programa,
vá na barra de ferramentas e clique em Debug -> Halt (Shift +F5) ou através do ícone , presente no
canto esquerdo do CCS. Para desconectar o Kit, selecione Debug -> Disconnect, e então desligue o
interruptor SW1.
4.6 CARREGANDO O CÓDIGO PARA O DSP (VERSÃO RAM RELEASE)
O procedimento para essa versão para compilar e carregar o código é o mesmo que na versão do
RAM Debug, apresentado anteriormente, exceto que na parte da configuração do projeto presente no
CCS, deve-se optar pela opção RamRelease, como demonstra a Figura 4.14.
Figura 4.14 - Versão RAM Release.
Comparando está versão com a RAM Debug, está é consideravelmente mais rápida, porem algumas
informações não estarão disponíveis.
4.7 CARREGANDO O CÓDIGO PARA O DSP (VERSÃO FLASH RELEASE)
Para carregar o código para a memória flash do DSP, deve-se trocar a opção da Figura 4.14 para a
terceira, FlashRelease. Nessa opção, o código irá ser salvo e executado na memória flash.
Alternativamente, selecione Project -> Configurations. E então selecione a opção 3_FlashRelease, e
então clique em Set Active e logo após em Done, como é ilustrado na Figura 4.15.
Figura 4.15 - Opção alternativa para configurar o projeto.
O processo de conexão e compilação é o mesmo do RAM Debug, presentes nas seções 4.3 e 4.4.
Uma vez que o DSP já esteja conectado ao computador, vá na barra de ferramentas do CCS e selecione
Tools -> F28xx On-Chip Flash Programmer para carregar o programa para o DSP. Ao abrir a janela,
certifique-se que a opção “Erase, Program, Verify” esteja selecionada, como demonstra a Figura 4.16.
Feito isso, agora basta clicar em Execute Operation.
Figura 4.16 – Configuração do On-Chip Flash Programmer para versão Flash Release.
Depois que o programa foi copiado, retire o cabo da porta USB, e desligue e logo em seguida ligue o
interruptor SW1 para que rodar o código. O led presente no kit irá ficar aceso, e o LCD do mesmo irá
demonstrar a tensão de saída.
4.8 CARREGANDO O CÓDIGO PARA O DSP (VERSÃO FLASH RAM RELEASE)
O processo de compilar e carregar dessa versão é a mesma que a da Flash Release, exceto que na
configuração do projeto no CCS, deve-se mudar para a opção FlashRamRelease (Figura 4.14). Com a
versão Flash RAM Release, o código será automaticamente copiado da memória flash para a memória
RAM, e então o mesmo irá rodar na memória RAM. A velocidade do código é consideravelmente mais
rápido comparada a versão citada na seção 4.7.
4.9 EXEMPLO - LED PISCAR NO PSIM
No ambiente do PSIM, monte o circuito presente na Figura 4.17.
Figura 4.17 – Circuito para piscar o Led (incluir configuração do oscilador).
Os elementos presentes na Figura 4.17 são:
Digital output – Presente em Elements-> SimCoder -> TI F28335 Target -> Digital output.
Unit Delay – Presente em Elements -> Control -> Digital Control Module -> Unit Delay.
Hardware Configuration – Presente em Elements-> SimCoder -> TI F28335 Target ->
Hardware Configuration.
Clock
As configurações do Simulation Control mantem-se as mesmas que a da seção 4.2.
Montado o circuito, deve-se configurar os elementos. Iniciando pelo Digital Output, abra ele
clicando duas vezes no mesmo, com isso uma janela irá se abrir e pode ser vista na Figura 4.18. Nessa
janela é necessário escolher as saídas do controlador que irá ser utilizada, onde nesse exemplo irá ser
utilizada a GPIO31, que é o LED 1 do nosso DSP F28335.
Figura 4.18 - Configuração Digital Output.
Feito isso, deve-se configurar o Unit Delay, que é a frequência em que o LED irá piscar. Nesse
exemplo a frequência utilizada é 𝑓 = 3𝐻𝑧, presente na Figura 4.19 , isso fará com que o LED pisque 3
vezes em 1 segundo.
Figura 4.19 - Configuração Unit Delay.
Agora o mais importante, que é a configuração do nosso Hardware. Abra ele com um duplo click em
cima do elemento. Ao abrir, nota-se que o datasheet inteiro está presente. Nele deve-se marcar apenas
o que irá ser utilizado, nesse caso, a saída digital do GPIO31 que nada mais é que o nosso LED 1 como
mostra a Figura 4.20, feito isso, aperte em Lock. Um ponto importante na configuração, é que todas as
vezes em que for configurar o hardware novamente deve-se apertar em Unlock, e após terminar a
configuração, apertar em Lock novamente.
Figura 4.20 - Configuração do Hardware.
Agora basta realizar os passos presentes nas seções 4.3, 4.4 e 4.5 novamente para realizar a
execução do projeto.
5 PROGRAMAÇÃO EM C DSP
5.1 CRIANDO UM PROJETO
Inicialmente deve-se abrir o CCS. Após isso, vá na barra de ferramentas em Project -> New. Essa
ação irá criar um projeto em branco, com a extensão “.pjt”, e irá abrir uma janela que é ilustrada na
Figura 5.1.
Figura 5.1 - Criando um programa.
Deve-se selecionar um diretório. Nele ficará a pasta com os arquivos criados no projeto e o arquivo
“.out” para download no DSP. Realizado esses passos, o projeto irá ser criado.
Nesta seção, será abordado a programação em linguagem C. Para escrever o código, deve-se
adicionar um arquivo .C, em branco, que será o arquivo fonte onde irá ser inserido a função principal,
“main”, do tipo void. Para isso, vá na barra de ferramentas em File -> New -> Source File. Esse arquivo
deve-se ser salvo na mesma pasta onde o arquivo “.pjt” foi salvo. Para isso, deve-se ir na barra de
ferramentas em File -> Save as -> Nome.c.
Com isso, o arquivo fonte foi criado, mas não relacionado ao seu projeto. Para que o mesmo ocorra,
vá em Project -> Add files to Project, escolhendo o arquivo .c nomeado anteriormente.
5.1.1 A Pilha
A pilha, denominada no software como “Stack Size”, deve ser configurada. O “Stack Size” é uma
área da memória RAM reservada para trabalhar com informações temporárias. Quando programa-se o
DSP com a linguagem C, não tomamos conhecimento da pilha. Ela é utilizada mais em operações
programadas em assembly.
Para configurar a pilha, basta ir em Project -> Build Options -> Linker -> Stack Size. A Texas
Instruments indica o tamanho padrão 0x400, portanto, deve-se inserir o valor “400” no campo indicado.
5.1.2 Compilação
O processo de compilação é o mesmo que o da programação em PSIM. Basta ir em clique no icone
na barra de ferramentas, ou vá em Project -> Build (F7) para construir o projeto (Ou clique em
ou vá em Project -> Rebuild All para reconstruir o projeto inteiro). Na primeira vez recomenda-se utilizar
o comando “Rebuild All”. Feito isso, o programa gera um arquivo com a extensão .out, e o mesmo é
gravado na memória do DSP.
Não havendo erros na compilação, deve-se carregar o código para o DSP, indo em file -> Load
Program -> Debug -> Arquivo.out.
5.1.3 Executando o Programa
Agora com o arquivo já gravado, deve-se executar o programa. Na barra de ferramentas vá em
Debug -> Go Main (Ctrl+M), isso faz o programa esperar no início da rotina principal, “Main”. Percebe-
se um indicador amarelo neste ponto, ao lado do código, como mostra a Figura 5.2. Com o botão direito
do mouse pode-se forçar que o programa comece de qualquer ponto arbitrariamente desejado.
Figura 5.2 - Após o comando Go Main.
Para iniciar a execução do programa no DSP, selecione Debug -> Run (F5), ou através do ícone ,
presente no canto esquerdo do CCS. Como dito anteriormente na seção 4.5, o usuário tem a opção de
pausar a execução a qualquer momento indo em Debug -> Halt (Shift +F5) ou selecionando o ícone ,
também presente no canto esquerdo do CCS.
É possível reiniciar o código em Debug -> Restart ou encerrar definitivamente a execução em
Debug -> Reset CPU, provocando reset no DSP, diferentemente do comando “Halt”.
5.2 WATCH WINDOW
Para o acompanhamento do conteúdo das variáveis utilizadas no programa em tempo real, utiliza-se
a ferramenta “Watch Window”. Está ferramenta nada mais é do que uma janela onde ficam dispostas as
variáveis utilizadas no programa que o usuário desejar incluir. Este recurso pode ser adicionado pelo
caminho View -> Watch Window.
Ao realizar esse passo, uma janela no canto inferior direito do ambiente de programação irá
aparecer, na qual é possível acompanhar as variáveis. Nela também é possível adicionar uma variável
clicando com o botão direito do mouse e selecionando “Add to watch window”.
Para atualizar o valor da variável, é necessário clicar com o botar direito sobre a janela e selecionar a
opção “Refresh”.
5.2.1 Single Step
Se for necessário um acompanhamento minucioso das variáveis, existe a possibilidade de executar o
programa passo a passo, através do recurso “Single step”, encontrado em Debug -> Single Step (F8).
5.2.2 Breakpoint e Probepoint
É possível adicionar em todos os programas pontos de parada, “Breakpoint” e “Probepoint”. Isto
permite que o usuário acompanhe o que o programa efetuou até o ponto escolhido. Os dados podem
ser visualizados no “Watch Window”.
A diferença entre essas duas opções é que, no “breakpoint” o programa atualiza parando
literalmente o mesmo, onde para retornar a execução deve-se utilizar o comando “run” novamente. O
“probepoint” atua da mesma maneira, mas sem causar a pausa total da execução, promovendo uma
breve parada, suficiente para colher as informações, voltando assim à execução automaticamente.
Para inserir um “breakpoint”, basta clicar com o botão direito do mouse na coluna ao lado do código
sobre a linha na qual se deseja que o código seja parado. Para isto escolha a opção “toggle breakpoint”,
note que a linha é marcada com um indicador vermelho. Para a opção de “breakpoint” faça o mesmo
caminho, mas dessa vez clique em “toggle probe point”, na linha em que deseja fazer a verificação. Note
que a linha escolhida é marcada com um indicador azul. Feito isso, em ambos os passos, é necessário
então adicionar as variáveis ao “watch window”, como ensinado na seção 5.2.
5.3 WATCH DOG TIMER
O “Watch dog timer” é um contador que trabalha independentemente da CPU e dispara um reset na
CPU se não for zerado periodicamente. É literalmente um cão de guarda. Esta unidade existe para inibir
o programa de possíveis travamentos. Se o programa ficar trancado em algum ponto da execução,
devido à algum erro de execução ou devido à erro de programação, passado algum tempo o “watch dog
timer” ira “resetar” a CPU, fazendo o programa recomeçar do início da função “main”. Utilizando um
clock externo de 30MHz – que internamente é multiplicado para 150MHz – o período de contagem
do“watch dog timer” é de aproximadamente 4,3 ms. Utiliza-se está referência para, de tempos em
tempos, cuidar para zerar este contador.
Em geral, quando se confia no programa escrito uma alternativa seria simplesmente desabilitá-lo e
esquecê-lo. Mas a Texas aconselha deixá-lo sempre ativo, pois em um projeto sempre se deve incluir o
quanto for possível de segurança. Sendo assim, para zerar sua contagem deve-se escrever um valor
definido, uma chave, no registrador watch dog key “WDKEY”, da seguinte forma: escreva o valor 0x55,
para liberar o contador para um reset na contagem; escreva o valor 0xAA, assim a contagem é resetada
e reinicia de 0x0000.
Outro registrador de controle do WD é o “WDCR”, onde se ajusta o “prescale” do contador e é
possível desabilitar a contagem, desabilitando o watch Dog.
É possível encontrar o comando do watch dog em Gel -> Watch WatchDog Timer Registers.