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.