Zilog - Usando os pinos de I/Os dos Microcontroladores Z8 encore XP - exemplo.

Zilog - (PS0199) - Aprenda a usar as IOs desse microcontrolador. Exemplo de código.

     Finalidade :

      Neste trabalho vamos mostrar como é fácil e rápido usar a IDE da ZILOG na programação de microcontroladores Zilog. usaremos os exemplos que já constam na documentação do programa e as formas de trabalhar com o mesmo. Este trabalho possui muita informação importante a respeito de como ler e escrever nos registros e nas entradas e saídas do microcontrolador em diferentes modos de operação.

     Exemplo de código para a linha Z8 encore.
          Os microcontroladores da Zilog com core Z8 encore XP são muito fáceis de serem programados e usados em diversos projetos de uso geral. Aqui vamos nos ater ao fato de mostrar como podemos criar nosso código, compilar e descarregar dentro dos microcontroladores de maneira rápida e fácil.
          Primeiro de tudo, devemos ir no site www.zilog.com e baixar a ultima versão do software ZDSII, que é uma IDE completa e sem limites em C e asm para programação e debugagem. Se você perdeu os ultimos posts sobre como montar um gravador serial para esta linha, procure no blog em http://cleapseletroeletronica.blogspot.com.br/2012_10_01_archive.html e fazer o seu.
          Vou imaginar que você fez o download e a instalação. Agora vamos abrir o programa ZDSII para a linha Z8 ENCORE XP e para tal ou abrimos no menu iniciar ou na área de trabalho, isso pode ser  tanto no windows quanto no Linux. Essa é a sacada boa do compilador da Zilog, pode ser usado em duas plataformas de sistemas operacionais diferentes e sem estresse.
          Clique no menu iniciar e ache a pasta do programa, abra-o.
       

           
          Teremos o programa aberto em poucos segundos com a aparência como se segue na figura a seguir e é a partir daí que poderemos realizar nosso trabalho de projetos.

          A partir daí é só ir em FILE e, se for criar um projeto novo, em NEW Project, ou abrir um existente, em Open Project. No nosso caso, abriremos um projeto já existente, pois o espaço aqui não permite aprofundar nessa parte agora, que ficará para um outro momento, que é mostrar como começar do zero.

          Abre-se a janela a seguir e vamos em C:\ Arquivos de programa\ZiLOG\ZDSII_Z8Encore!5.0\samples\XP_F0822\XP_F0822_ledBlink_asm\src,  clicamos no arquivo de projeto que se segue.

          E temos a figura a seguir com o programa pronto para ser compilado e enviado ao microcontrolador e não podemos antes de configurar o hardware de gravação e escolha do microcontrolador exato e para isso vamos em project em em settings.

          Abre-se a figura seguinte e em Debuger Tool selecionamos SerialSmartCable e em setup, escolhemos a configuração de nossa porta serial no computador. Em Target e clicando em SETUP é possível alterar o valor do cristal que será usado no microcontrolador. Como se vê na figura abaixo.

          Clicamos em compilar :

       

          E, se tivermos como resposta, a figura que mostra no rodapé do programa, como succeed, então o programa não tem erros e podemos gravar no microcontrolador.

Agora é clicar em  e conectar ao microcontrolador para debuggar e gravar seu programa compilado. Se tivermos a figura a seguinte é por que, ou o hardware está com problemas ou não está conectado adequadamente e por isso é bom verificar o que possa estar acontecendo. 

          Agora, se a mensagem for diferente e como é mostrado na figura abaixo, tudo certo, é só programar o microcontrolador e começar a fuçar no programa e ir modificando os parâmetros para ver o que acontece no microcontrolador e o que muda nos registradores no canto direito do programa, isso é debugar e verificar o interior do microcontrolador e acertar o que esteja fora do desejado. 

Depois de tudo isso, é só clicar em  Download code e baixar seu arquivo .hex no microcontrolador e começar a brincar ou fazer seus projetos. 

           Espero que com esse tutorial de como usar o programa ZDSII da Zilog, tenhamos alcançado seus objetivos, apesar de o texto do título falar de exemplo, é isso mesmo o nosso proposto, ou seja usar um exemplo pronto de programa e deixar o leitor fazer suas modificações e verificações, com isso queremos incitar a criatividade e a curiosidade. 

          Os microcontroladores da Zilog são robustos e com uma gama muito grande de periféricos que permitem um desenvolvimento de projetos e protótipos. 

          Caso tenham dúvidas, sugestões e reclamações, nosso site www.cleapseletroeletronica.com e nosso email andrepereira@ig.com.br estão abertos aos nossos leitores. 

          Tentaremos fazer mais exemplos e projetos com os microcontroladores da Zilog e aguardamos suas sugestões. Até a próxima. 

Zilog - Usando os pinos de I/Os dos Microcontroladores Z8 encore XP - parte 2

Zilog - (PS0199) - Aprenda a usar as I/Os desse microcontrolador. Parte 2

         
Continuação : 

          Dando continuidade com o nosso trabalho sobre o uso e configuração das I/Os dos microcontroladores da Zilog linha Z8 Encore, vamos falar mais um pouco dos periféricos e outras particularidades do microcontrolador e desenvolver algum exemplo prático. 
         
Configurando os I/Os para operação de funções alternativas.

          Quando os pinos de I/Os são configurados para operação de funções alternativas, é dado acesso a funções especiais do microcontrolador como os TIMERS, Comunicação serial e demais periféricos. Para definir as I/Os para operação de funções alternativas, o registro de endereço do port em questão, deve ser definido como tipo de função alternativa que se queira naquele pino ou port e o registro de controle deve ser preenchido com valores pertinentes aos pinos do port específico envolvido com a função que se deseja usar nesse pino. A tabela a seguir lista as funções alternativas associadas com cada pino do port dos microcontroladores Z8 Encore XP.


Tabela – Mapeamento de funções alternativas dos PORTS

PORT	Pino	Mnemônico	Descrição da função alternativa
PORTA	PA0	T0IN	Entrada do timer 0
	PA1	T0OUT	Saída do timer 0
	PA2	N/A	Sem função alternativa
	PA3	CTS0 (Ativo EM 0)	UART 0 limpa antes de enviar
	PA4	RXD0/IRRX0	UART 0/IrDA 0 recebe dados
	PA5	TXD0/IRTX0	UART 0/IrDA 0 transmite dados
	PA6	SCL	I²C clock ( OPEN-DRAIN automaticamente)
	PA7	SDA	I²C Data ( Open-drain automaticamente )
PORTB	PB0	ANA0	Entrada analógica do ADC
	PB1	ANA1	Entrada analógica do ADC
	PB2	ANA2	Entrada analógica do ADC
	PB3	ANA3	Entrada analógica do ADC
	PB4	ANA4	Entrada analógica do ADC
	PB5	ANA5	Entrada analógica do ADC
	PB6	ANA6	Entrada analógica do ADC
	PB7	ANA7	Entrada analógica do ADC
PORTC	PC0	T1IN	Entrada do Timer 1
	PC1	T1OUT	Saída do Timer 1
	PC2	SS (ATIVO EM 0 )	SPI seletor de escravo
	PC3	SCK	SPI serial clock
	PC4	MOSI	SPI saída mestre, entrada escravo
	PC5	MISO	SPI entrada mestre, saída escravo
	PC6	T2IN	entrada do Timer 2
	PC7	T2OUT	Saída do Timer 2
PORTD	PD0	T3IN	Entrada do Timer 3
	PD1	T3OUT	Saída do Timer 3
	PD2	N/A	Sem função alternativa
	PD3	N/A	Sem função alternativa
	PD4	RXD1/IRRX1	UART 1/ IrDA 1 recebe dados
	PD5	TXD1/IRTX1	UART 1/ IrDA 1 transmite dados
	PD6	CTS1 (Ativo em 0 )	UART 1 limpa para enviar
	PD7	RCOUT	Saída do oscilador RC do timer watch-dog
PORTE	PE[7:0]	N/A	Sem função alternativa
PORTF	PF[7:0]	N/A	Sem função alternativa
PORTG	PG[7:0]	N/A	Sem função alternativa
PORTH	PH0	ANA8	Entrada analógica do ADC
	PH1	ANA9	Entrada analógica do ADC
	PH2	ANA10	Entrada analógica do ADC
	PH3	ANA11	Entrada analógica do ADC

          Por exemplo, digamos que se decida usar o periférico Timer 0 do microcontrolador Z8 Encore XP, configurando ou definindo o pino do PORTA para operação de função alternativa. Só e somente a função de saída no pino é considerado nesse exemplo.
          O  código do exemplo 1, mostra como é configurado ou definido o pino PA1 do PORTA para operação de função alternativa configurando os bits apropriados no registradores adequados.

Exemplo 1 :

  /***************************************************/
 //      inicialização                                                          //
 /***************************************************/

PAADDR = 0x02 ;    // Registro do endereço do PORTA seleciona sub-registro de função alternativa.
PACTL |= 0X02 ;      // Registro de controle do PORTA seta saída do TIMER0.
PAADDR = 0X01 ;   // Registro de endereço do PORTA sub-registro de direção de dados.
PACTL &= 0Xfd ;    // Registro de controle do PORTA define bit 1 como saída, se Timer 0 selecionado.
PAADDR = 0X03 ;   // Registro de endereço do PORTA seleciona o sub-registro de controle de saída.
PACTL &= 0Xfd ;    // Registro de  controle do PORTA define o bit 1 como push-pull.
PAADDR = 0X00 ;   // Permite bloquear os sub-registros contra alterações inadvertidas depois de
                                     configurados.

Exemplo 2 :

/*****************************************************/
// Inicialização                                                                    //
/*****************************************************/

PAADDR = 0X02 ;  // Registro de endereço do PORTA seleciona sub-registro de função alternativa.
PACTL  |= 0X01 ;   // Registro de controle do PORTA define entrada do Timer0.
PAADDR = 0X01 ; // Registro de endereço do PORTA seleciona sub-registro de direção de dados.
PACTL |= 0X01 ;   // Registro de controle do PORTA define bit 0 como entrada, se Timer 0 selecionado.
PAADDR = 0X00 ; // Permite bloquear os sub-registros contra alterações inadvertidas depois de
                                   configurados.

NOTA: Os registros dos ports de A~H selecionam as funcionalidades dos I/Os acessíveis através dos registros de controle dos ports de A~H. Definindo os pinos dos ports como 1 nos registros dos endereços dos ports de A~H, através dos registros de controle dos ports, habilita o port correspondente para operação de função alternativa.

Definindo as I/Os como operação de modo misto.

          Agora que aprendemos como definir os pinos dos microcontroladores Z8 Encore como entrada, saída e operação de função alternativa, temos, aqui, um exemplo de como usar, simultaneamente, pinos diferentes no mesmo PORT como entrada, saída e operação de função alternativa. 
          Por exemplo, assuma que você queira usar o pino do Timer 0 como saída definindo isso no pino PA1 do PORTA. Deseja-se usar os pinos PA4 e PA5 como entrada, deseja-se, também, usar os pinos PA6 e PA7 como saídas dreno aberto. Depois de definir isso nos registradores, você deseja ler dados dos pinos [4,5] e escrever dados nos pinos [6,7] com lógica [1,0].
          O código a seguir ilustra melhor como configurar o PORTA para operação mista. 

/******************************************************************************/
// Inicialização                                                             //
/*****************************************************************************/ 

PAADDR = 0x02 ;  // Registro de endereço do PORTA seleciona sub-registro de função alternativa.
PACTL |= 0x02 ;  // Registro de controle do PORTA define saída do Timer 0, demais pinos livres como I/O. 
PAADDR = 0x01 ; // Registro de endereço do PORTA seleciona sub-registro de direção de dados.
PACTL &= 0x3d ; //3d = 00111101 define os bits 1,6 e 7 como saída e os pinos 4 e 5, como entrada.

PAADDR = 0X03 ;   // Registro de endereço do PORTA seleciona o sub-registro de controle de saída.
PACTL &= 0Xfd ;    // Registro de  controle do PORTA define o bit 1 como push-pull.
PAADDR = 0X00 ;   // Permite bloquear os sub-registros contra alterações inadvertidas depois de configurados.  

data = code ; // Lê os dados do registro de entrada do PORTA para dentro da variável 'data'.

data = data & 0x03 ; // Faz uma operação lógica AND com 00110000 para mascarar os valores dos bits 4 e 5.

PAOUT = data | 0x40 ; //Faz uma operação lógica OR do valor em data com 01000000 e escreve no registro de saída do PORTA para setar os bits [6,7] para [1,0].

Conclusão :

       Os pinos de I/Os são facilmente configuráveis usando os registros de endereços de ports junto com os registros de controle dos ports e seus respectivos sub-registros como explicado nesse documento. 

          O pino de qualquer I/O pode ser usado como fonte de interrupção externa quando configurados, somente, como entrada.

          A tabela neste documento, acima descrita, demonstra que as funções de periféricos on-chip dos microcontroladores Z8 Encore XP depende de posição de bitsnos ports. 

          O acesso aos I/Os dos ports é feito através do registro de dados de entrada e de saída. 

          Nesse ponto, finalizamos a parte de ensinar a acessar, configurar e usar os recursos de pinos e periféricos dos microcontroladores da Zilog para quem tivesse alguma dúvida. Nos posts seguintes, estarei procurando implementar algumas aplicações de exemplos para que o que foi ensinado possa ser visto no mundo real e ajudar aos demais a entenderem o fascinante mundo dos microcontroladores, em especial, os da zilog, a projetarem seus circuitos e projetos. Espero que tenham gostado e até a terceira parte dessa série.

Zilog - Usando os pinos de I/Os dos Microcontroladores Z8 encore XP

Zilog - (PS0199) - Aprenda a usar as IOs desse microcontrolador.

     Finalidade :

      Este trabalho visa a mostrar como inicializar e a usar os pinos de entrada e saída dos microcontroladores da Zilog séries Z8 encore XP e na utilização de periféricos do mesmo. Este trabalho possui muita informação importante a respeito de como ler e escrever nos registros e nas entradas e saídas do microcontrolador em diferentes modos de operação.

     Resumo de uso geral dos pinos de I/Os.
          Os microcontroladores da Zilog com core Z8 encore XP suportam sete portas de 8 bits (portas de A~G) e uma de 4 bits (porta H) para operações de entrada e saída. Cada port possui ou está associada a um registro específico de controle e dados. O registro de controle é usado para determinar a direção dos dados, se dreno aberto, saída de sinal ou entrada e funções especiais dos periféricos. Na figura abaixo é mostrado um diagrama simplificado dos pinos dos ports do microcontrolador.

          Quando qualquer pino do microcontrolador for configurado ou definido como entrada, o microcontrolador lê os dados desses pinos para dentro dos registros específicos, guarda-os e  os disponibiliza para futuros processamentos. Para facilitar, vamos chamar os pinos do microcontrolador de GPIO que ajuda a entender melhor o que são. Neste contexto, quando um pino de GPIO pode ser usado como fonte de interrupção externa se definido como operação de pino de entrada., assim como definido como pino de saída, dados de dentro do microcontrolador são enviados nestes pinos para circuitos ou dispositivos externos.Se definidos como pinos alternativos para periféricos internos sua finalidade vai depender de qual função o periférico tem para ser setado ou configurado.

          Nem todos os microcontroladores da linha Z8 encore possuem acesso aos 8 ports da linha, como estamos focando em microcontroladores de 80 pinos, isso não é problema, mas para micros de 20 pinos ou menos, sim. Para uma lista mais completa de pinos acessíveis de acordo com o modelo do microcontrolador acesse o datasheet "Z8 Encore! XP 64K Series Flash Microcontrollers Product Specification (PS0199) " em http://www.zilog.com/docs/z8encore/ps0199.pdf disponível do site da zilog em www.zilog.com.

          A maneira mais comum de configurar o uso dos pinos do microcontrolador para entrada, saída ou alternativo, que é o uso dos periféricos é usando as funções dos registros internos e sub registros associados alista a seguir mostra melhor como isso funciona.

• Endereço do port (PxADDR)
• Controle do port (PxCTL)

          O estado dos pinos após um reset ou início de alimentação do micro é o seguinte :

• Os pinos do port estão em modo normal - periféricos desativados.
• Todos os pinos estão configurados como entrada. 
• O conteúdo do registro de dados de entrada (PxIN)  é desconhecido.
• O conteúdo do registro de dados de saída (PxOUT) é 0X00. 
• Os pinos dos ports estão com o driver em tri-state.  

          Os valores dos registros dos ports e sub registros no modo reset estão nas tabelas a seguir. 

       
          Todos os pinos GPIOs devem ser inicializados a um valor de estado referente ao que se deseja antes de serem usados. O trabalho aqui descrito se foca em uma parte desse processo de descrição dos registros da linha Z8 Encore! XP que serve para guiar os usuários a definirem bem os pinos do microcontrolador de forma organizada e desejada.

Z8 Encore! XP descrição breve dos registros.

          São quatro registros do microcontrolador Z8 Encore! XP que permitem o acesso aos pinos do mesmo no que se refere a controle do GPIO, dadoa de entrada e dados de saída. Os endereços dos ports de A-H e registro de controle juntos, são usados para se ter acesso aos sub registros para configuração e controle dos ports.
          Esses quatro registros do microcontrolador Z8 Encore! XP são brevemente explicados a seguir:

• Registro de endereço de PORT (PxADDR) seleciona o sub registro adequado a funcionalidade do port e do GPIO. É usado em conjunto com o registro de controle de portas e ter acesso a todos os controles de pinos do GPIO.
• Registro de controle de port (PxCTL)  define o controle do port GPIO permitindo acesso aos sub registros.
• Registro de entrada de dados (PxIN) retorna um valor no pino do port associado para ser processado.
• Registro de dados de saída (PxOUT) escreve os dados de dentro do microcontrolador nos pinos correspondentes a fim de controlar cargas ou circuitos.

          NOTA: Os quatro registros mencionados acima estão definido no arquivo de cabeçalho ez8.h.    

                              Para usar as definições de código inclua o arquivo no seu programa como "#include 

                               '<ez8 .h>', no seu código C para microcontroladores zilog. 

          Uma breve descrição do sub registro de port usado com o registro de endereço de port é dado a seguir.

• Sub registro de direção de dados (DATA_DIR) contem defino o valor de acesso a dados como sendo 0x01 e é usado para definir pinos do port tanto como entrada como saída. Definindo valores de 1 para setar o pino como entrada e 0 como saída.
• Sub registro de função alternativa (ALT_FUN) é usado para ativar as funções internas dos periféricos do microcontrolador e é definido como valor de dado de 0x02. Definindo valores de 1 para acionar as funções alternativas dos periféricos.
• Sub registro de controle de saída (OUT_CTL) define o pino de saída como push-pull se valor for 0 e dreno aberto, se valor for 1. Este sub registro contem valores de dado de 0x03 e afeta on pinos diretamente.
• Sub registro de habilitar alta corrente de saída (HDR_EN) é usado para habilitar e desabilitar operações em pinos em operação de alto consumo de corrente (como em LEDs). Este sub registro contem valor de dado de 0x04 e afeta diretamente os pinos do microcontrolador. 
• Sub registro de habilitar fonte de recuperação em modo STOP (SMRS_EN) configura o pino como fonte de modo recuperação de dados e é definido como valor de dado de 0x05.

          Os valores dos sub registros são definidos como se segue em todos os exemplos citados neste trabalho.:

          

           #define DATA_DIR            0x01           // direção dos dados nos pinos.

           #define ALT_FUN              0x02           // função alternativa.

           #define OUT_CTL              0x03           // Controle de saída de sinal/bit/bite.

           #define HDR_EN                0x04           // Habilita controle de corrente no pino.

           #define SMRS_EN             0x05            // Habilita/desabilita fonte de recuperação em modo STOP.

          NOTA:

          Para salvaguardar os valores nos sub registros de serem sobre escritos acidentalmente, defina valor de 0x00 no registro PxADDR antes de modificar os outros sub registros para uso particular conforme se deseja. 

          Para uma lista mais completa de sub registros acessíveis de acordo com o modelo do microcontrolador acesse o datasheet "Z8 Encore! XP 64K Series Flash Microcontrollers Product Specification (PS0199) " em http://www.zilog.com/docs/z8encore/ps0199.pdf disponível do site da zilog em www.zilog.com.

 Definindo os pinos GPIOs como entrada.

           Para configurar ou definir os pinos do port GPIO como entrada, use o registro de endereço do port apropriado juntamente com o registro de controle de port e o sub registro de direção de dados. Para evitar alguma interferência em outras funções do port, o sub registro de função alternativa é colocado um valor padrão de 0x00. Para acessar dados do pino do port, use o registro de dados de entrada do port em questão. 

          Por exemplo, assuma que você queira usar o pino 6 do port F (PF6) como pino de entrada, o pedaço de código a seguir ilustra bem como você pode fazer para usar o pino 6 do port F como entrada.

/**********************************************************************************************************/

//                               exemplo de inicialização de pino 6 do port F usado como entrada            //

/**********************************************************************************************************/

PFADDR = 0x02;                                                   // Selecionamos port F e sub registro função       

                                                                                 //  alternativa.

PFCTL &= 0x00;                                                    // O registro de controle do port F é colocado 

                                                                       //valor padrão pois este não possui função alternativa

PFADDR = 0x01;                                                // Registro de endereço do port F habilita sub  

                                                                               //registro de direção de dados.

PFCTL |= 0x40;                                                    // registro de controle do port F seleciona bit 6  

                                                                                //como entrada.

                                                                                //Não é necessário selecionar o sub registro de  

                                                                               //saída desde que a configuração desejada seja  

                                                                               //de entrada. 

/**********************************************************************************************************/

//                               lendo dados do pino 6 port F                                                                            //

/**********************************************************************************************************/

while(1)

             {

               Data = PFIN;                                       // guarda dados do port F para um registro  

                                                                       //temporário ( dados são colhidos do registro de  

                                                                         //dados de entrada).

               if (( Data & 0x40) == 0x00)            // testa se o bit 6 é zero.

                      {

                        user_routine();                          // coloque seu código aqui.

                       }

             }

     

          Todos os pinos do port GPIOs dos microcontroladores Z8 Encore! XP podem ser configurados para receberem interrupções externas com sinais de borda de subida ou borda de descida nas entradas de cada pino. As operações de requisição de inrterrupção só podem ser realizadas com os pinos configurados ou definidos como entrada e com inicialização apropriada para esta função. Para mais informações de como inicializar as interrupções externas, referencie o documento "Z8 Encore! XP 64K Series Flash Microcontrollers Product Specification (PS0199)" disponível em www.zilog.com .

Definindo os port GPIOs como saída.

       Para definir os pinos do port GPIO como saída, o registro do endereço do port e o registro do de controle serão usados com seus respectivos sub registros ( direção dos dados e controle de saída). Exteriorizar os dados de saída para os pinos dos ports, o registro de dados de saída dos ports é também usado. 

          Por exemplo, assuma que você queira usar os ports G e E como saída ( onde os dados são direcionados através dos pinos configurados como saída), dessa forma se escolheu, aleatoriamente, que o port G é ativo em nível alto ou +VCC e o port E, ativo em nível lógico baixo.

          O seguinte trecho de código ilustra melhor como podemos definir o port G e E como pinos de saída e direcionar os dados através desses pinos.

/********************************************************************************/

//           Inicialização dos ports G e E como saída                                                                                      //

/********************************************************************************/

PGADDR = 0x02 ;                                                    // Registro do endereço do port G seleciona sub  

                                                                                  // registro de função alternativa.

PGCTL &= 0x00 ;                                                     // Controle de port G define valor padrão por que    

                                                                                  // port G não tem função alternativa..

PGADDR = 0x01 ;                                                    // Registro de endereço do port G acessa sub registro 

                                                                                  // de direção de dados.

PGCTL &= 0x00 ;                                                     // Registro do port G define todos os pinos desse 

                                                                                   //port como sendo saída.

PGADDR = 0x03 ;                                                     // Registro de endereço do port G seleciona o 

                                                                                   //controle de saída.

PGCTL &= 0x00 ;                                                      // Registro de controle do port G é definido como 

                                                                             //push-pull, ou seja, com os resistores ligados ao +VCC.

PEADDR =0X02 ;                                                        // Registro de endereço do port E seleciona o sub  

                                                                                     //registro de função alternativa.

PECTL &= 0X00 ;                                                       // Registro de controle do port E desabilita as 

                                                                                     //funções alternativas de periféricos.

PEADDR = 0X01 ;                                                       // Registro de endereço do port E seleciona o sub  

                                                                                      //registro de direção de dados.

PECTL &= 0X00 ;                                                         // Registro de controle do port E define todos os  

                                                                                      //pinos como saída.

PEADDR = 0X03 ;                                                       // Registro de endereço do port E acessa sub  

                                                                                     //registro de controle de saída.

PECTL &= 0X00 ;                                                       // Registro de controle do port E define o controle 

                                                                                     //de saída em push-pull. 

/********************************************************************************/

//                    código que permite o pino ou pinos em nível alto                                                                 //

/********************************************************************************/

void Drive_High_to_Port_G(void)

                    {

                       PGOUT = 0X07 ;                             // Define os bits de 0~6 em nível alto.

                       PEOUT  &= 0X00;                           //  Define todos os bits do port E em nível baixo.

                    }

/********************************************************************************/

//                  código que permite colocar os bits de um port ou pinos em nível baixo                                   //

/********************************************************************************/

void Drive_Low_to_Port_G(void)

                     {

                      PGOUT = 0x00 ;                                // define todos os bits em lógica nível baixo.

                      PEOUT = 0x00 ;                                 // define todos os bits em nível lógico baixo.

                     }

          Concluindo, estes são os passos para se conseguir, por exemplo, acender um led com os microcontroladores da Zilog, uma nova abordagem e tradução parcial do documento da empresa que aqui foi idealizado. 

            No próximo post falaremos de como acessar alguns periféricos do microcontrolador e em um terceiro post  do assunto, tentaremos fazer alguns circuitos e usos do mesmo no mundo real.