Tratado Da Linguagem c

THE RED BOOK

Computadores Pessoais Microcontroladores Intel 8051 e Microchip PIC

Tratado da Linguagem

C Engenharia Elétrica Engenharia Eletrônica Engenharia de Computadores Engenharia de Automação e Controle

COCIAN, L.F.E BRUSAMARELLO, V.J. LORENZI, C.R.

LUIS FERNANDO ESPINOSA COCIAN Engenheiro Eletricista, ME.. – Professor do Curso de Engenharia Elétrica da Universidade Luterana do Brasil

VALNER JOÃO BRUSAMARELLO Engenheiro Eletricista , Dr... - Professor do Curso de Engenharia Elétrica da Universidade Luterana do Brasil

CÍCERO RENATO LORENZI Engenheiro Eletricista , Esp... – Diretor de Tecnologia da Mater Matris Technae Ltda..

LEONICE LESINA ESPINOSA Licenciada em Letras. Revisão Lingüística

Tratado da Linguagem C Engenharia Elétrica Engenharia Eletrônica Engenharia de Computadores Engenharia de Automação e Controle

LUIS FERNANDO ESPINOSA COCIAN VALNER JOAO BRUSAMARELLO CÍCERO RENATO LORENZI

Tratado da Linguagem C E a ca éttrriic Ellé aE arriia ha nh en ge ng En E a ca niic ôn ettrrô Elle aE arriia ha nh en ge ng En E s es orre do ad utta pu mp om Co eC de ad arriia ha nh en ge ng En E e olle nttrro on Co eC oe ão çã aç ma om utto Au eA de ad arriia ha nh en ge ng En

 Tratado da Linguagem C - Engenharia Eletrônica Miguel Tostes, 101 • Canoas, RS. Brasil Telefone (51) 477 4000 • Fax (51) 477 1313 www.ulbra.br

Prefácio A maioria dos livros de programação em linguagem C, enfoca os temas dos seus capítulos, no conhecimento básico da linguagem, as palavras chaves e em exemplos simples de processamento da informação. Estes livros têm como público alvo, pessoas que desejam obter somente uma noção básica da linguagem. Por causa disto são muito deficientes no que se refere à especificação e planejamento de projetos de software e ao acesso ao hardware, temas de conhecimento indispensável para engenheiros e técnicos da área eletroeletrônica, que trabalham no desenvolvimento de sistemas de aquisição de dados, de controle automático, de comunicação de dados e de processamento digital de sinais. Esta grande lacuna existente de livros de programação que enfatizem o controle do hardware, motivou a recopilação de idéias e projetos elaborados ao longo dos anos nas salas de aula, de forma a repassar esta informação aos técnicos e engenheiros que estão iniciando a aprendizagem da linguagem. A linguagem de programação C é padronizada, mas pode diferir em alguns pontos quando for utilizada em compiladores para plataformas diferentes de software e hardware. Nestes casos deverão ser estudadas as modificações a serem efetuadas, no código fonte gerado por cada compilador. Este livro aborda a programação utilizando como hardware um PC IBM compatível com sistema operacional MSDOS® e Windows®, compiladores TurboC® da Borland Inc.(Inprise Inc.) e Microsoft Visual C++® da Microsoft Inc. Também são mostrados alguns exemplos utilizando os compiladores Franklin C® (Keil para a família de microcontroladores 8051) e PCW (CCS para microcontroladores PIC da Microchip). Os exemplos de programação foram escolhidos de forma que estejam adequados ao escopo deste livro. Nos anexos foi colocada a informação referente às portas de comunicação do PC, chips de suporte e outras informações consideradas relevantes. Alguns problemas requerem pequenas montagens em hardware, cuja implementação também é mostrada através de diagramas esquemáticos. Este livro contém informação suficiente para uma disciplina de um semestre, apresentando exercícios de programação no final de cada capítulo.

Sumário 1.

INTRODUCÃO ..................................................................................................................................1 1.1. 1.2. 1.3.

2.

POR QUE ESTUDAR A LINGUAGEM C ? ...........................................................................................1 QUANDO ESTA LINGUAGEM FICARÁ OBSOLETA ? ..........................................................................2 BREVE HISTÓRIA DA LINGUAGEM C ..............................................................................................2

OS COMPUTADORES .....................................................................................................................4 2.1. O QUE SÃO OS COMPUTADORES ? ..................................................................................................4 2.2. COMO OS COMPUTADORES FUNCIONAM ?......................................................................................4 2.3. TIPOS DE COMPUTADORES ............................................................................................................4 2.4. SOFTWARE BÁSICO E O SISTEMA OPERACIONAL ...........................................................................5 2.4.1. A Memória ............................................................................................................................6 2.4.2. Os Barramentos....................................................................................................................7 2.5. A UNIDADE CENTRAL DE PROCESSAMENTO - CPU.......................................................................7 2.6. PROGRAMAS DE COMPUTADOR .....................................................................................................9 2.7. LINGUAGENS DE PROGRAMAÇÃO ................................................................................................10 2.7.1. A Linguagem de Máquina...................................................................................................10 2.7.2. A Linguagem Assembly.......................................................................................................11 2.7.3. Linguagens de Alto-Nível ...................................................................................................11 2.7.4. Linguagens Orientadas a Objetos ......................................................................................12 2.7.5. Algoritmos ..........................................................................................................................12 2.7.6. Exemplos de Codificação de Instruções .............................................................................13 2.8. CONCLUSÕES...............................................................................................................................14

3.

A CODIFICAÇÃO DA INFORMAÇÃO .......................................................................................15 3.1. SISTEMAS DE NUMERAÇÃO .........................................................................................................16 3.1.1. Valores de acordo com a Posição ......................................................................................17 3.1.2. Sistema Binário ..................................................................................................................18 3.1.3. Formatos Binários..............................................................................................................20 3.2. ORGANIZAÇÃO DOS DADOS .........................................................................................................20 3.2.1. Bits......................................................................................................................................21 3.2.2. Nibbles................................................................................................................................21 3.2.3. Bytes ...................................................................................................................................22 3.2.4. Words..................................................................................................................................22 3.2.5. Double Words .....................................................................................................................22 3.2.6. Números com Ponto Flutuante ...........................................................................................22 3.3. O SISTEMA DE NUMERAÇÃO HEXADECIMAL...............................................................................23 3.4. OPERAÇÕES LÓGICAS ..................................................................................................................25 3.5. OPERAÇÕES LÓGICAS EM NÚMEROS BINÁRIOS E CADEIAS DE BITS ............................................28 3.6. NÚMEROS COM SINAL E SEM SINAL.............................................................................................28 3.7. EXTENSÃO DE SINAL E DE ZEROS ................................................................................................30 3.8. A CODIFICAÇÃO ASCII...............................................................................................................32 3.8.1. O Grupo Padrão de Caracteres .........................................................................................32

4.

PROJETO DE SISTEMAS DE SOFTWARE ...............................................................................38 4.1. TOP DOWN ..................................................................................................................................39 4.1.1. Estilo...................................................................................................................................39 4.1.2. Abstração............................................................................................................................39 4.1.3. Formalismo.........................................................................................................................40 4.1.4. O Projeto em Top-Down.....................................................................................................40 4.2. ALGORITMOS...............................................................................................................................41 4.3. FLUXOGRAMAS ...........................................................................................................................41 4.4. COMPONENTES BÁSICOS DE UM PROGRAMA ...............................................................................42

4.5. PROCEDIMENTO GERAL...............................................................................................................43 4.5.1. Compilação.........................................................................................................................43 5.

FUNDAMENTOS DA LINGUAGEM C........................................................................................45 5.1. CARACTERÍSTICAS DA LINGUAGEM C .........................................................................................45 5.2. PONTOS POSITIVOS DA LINGUAGEM ............................................................................................45 5.3. PONTOS NEGATIVOS....................................................................................................................46 5.4. O PADRÃO ANSI C.....................................................................................................................47 5.5. PALAVRAS RESERVADAS DA LINGUAGEM C ...............................................................................47 5.6. ESTRUTURA DE UM PROGRAMA EM C..........................................................................................47 5.7. CONJUNTO DE CARACTERES ........................................................................................................48 5.8. COMENTÁRIOS ............................................................................................................................48 5.9. DIRETIVAS DE COMPILAÇÃO .......................................................................................................49 5.10. DECLARAÇÃO DE VARIÁVEIS ..................................................................................................49 5.11. UMA INTRODUÇÃO ÀS ENTRADA E SAÍDA DE DADOS..............................................................50 5.11.1. Caracteres ..........................................................................................................................50 5.11.2. As Strings............................................................................................................................51 5.11.3. printf ...................................................................................................................................53 5.11.4. scanf....................................................................................................................................53 5.12. UMA INTRODUÇÃO AOS COMANDOS DE CONTROLE DE FLUXO ...............................................54 5.12.1. if..........................................................................................................................................54 5.12.2. for .......................................................................................................................................55 5.13. UMA BREVE INTRODUÇÃO ÀS FUNÇÕES..................................................................................57 5.13.1. Os Argumentos ...................................................................................................................57 5.13.2. O Retorno de Valores .........................................................................................................59 5.14. PRIMEIROS PASSOS ..................................................................................................................60 5.15. EXERCÍCIOS .............................................................................................................................66 5.16. AVALIAÇÃO ............................................................................................................................66

6.

ELEMENTOS DA LINGUAGEM..................................................................................................68 6.1. TOKENS DA LINGUAGEM C..........................................................................................................68 6.1.1. Caracteres de Espaço em Branco.......................................................................................68 6.1.2. Comentários em C ..............................................................................................................69 6.1.3. Avaliação dos Tokens .........................................................................................................70 6.2. KEYWORDS .................................................................................................................................71 6.3. IDENTIFICADORES .......................................................................................................................71 6.3.1. Caracteres Multibyte e Caracteres Longos ........................................................................72 6.3.2. Trigraphs ............................................................................................................................72 6.4. CONSTANTES ...............................................................................................................................73 6.4.1. Constantes de Ponto Flutuante...........................................................................................73 6.4.2. Constantes Inteiras .............................................................................................................74 6.4.3. Constantes Caractere .........................................................................................................75 6.4.4. Strings Literais ...................................................................................................................77 6.5. CARACTERES ESPECIAIS E PONTUAÇÃO ......................................................................................78 6.6. EXERCÍCIOS .................................................................................................................................78

7.

ESTRUTURA DE UM PROGRAMA ............................................................................................81 7.1. ARQUIVOS FONTE E PROGRAMAS FONTE ....................................................................................81 7.1.1. Diretivas de Pré-Processador ............................................................................................81 7.1.2. Pragmas..............................................................................................................................82 7.1.3. Declarações e Definições ...................................................................................................82 7.1.4. Declarações e Definições de Funções ................................................................................83 7.1.5. Blocos .................................................................................................................................83 7.2. A FUNÇÃO MAIN E A EXECUÇÃO DO PROGRAMA ........................................................................83 7.2.1. Os Argumentos argc e argv ................................................................................................84 7.2.2. Descrição dos Argumentos .................................................................................................85 7.3. TEMPO DE VIDA, ESCOPO, VISIBILIDADE E CONEXÕES ...............................................................86 7.3.1. Tempo de Vida....................................................................................................................86 7.3.2. Escopo e Visibilidade .........................................................................................................87 7.3.3. Encadeamentos...................................................................................................................88

7.4. 8.

ESPAÇOS DE NOMES ....................................................................................................................89

TIPOS E DECLARAÇÕES.............................................................................................................92 8.1. DECLARAÇÕES ............................................................................................................................92 8.2. CLASSES DE ARMAZENAMENTO ..................................................................................................93 8.2.1. Especificadores de Classe de Armazenamento para Declarações de Nível Externo..........94 8.2.2. Especificadores de Classe de Armazenamento para Nível Interno ....................................96 8.3. ESPECIFICADORES DE TIPO ..........................................................................................................99 8.3.1. Especificadores de Tipos de Dados e seus Equivalentes..................................................100 8.4. QUALIFICADORES DE TIPO ........................................................................................................101 8.5. DECLARAÇÕES DE VARIÁVEIS ...................................................................................................102 8.5.1. Declaração de Variáveis Simples .....................................................................................103 8.5.2. Declarações de Enumeração............................................................................................103 8.5.3. Declarações de Estruturas ...............................................................................................106 8.5.4. Declarações de Unions.....................................................................................................109 8.5.5. Declarações de Arrays .....................................................................................................111 8.5.6. Declarações de Ponteiros.................................................................................................112 8.5.7. Declarações Abstratas......................................................................................................114 8.6. INTERPRETANDO DECLARADORES COMPLEXOS ........................................................................114 8.7. INICIALIZAÇÃO ..........................................................................................................................117 8.7.1. Inicializando Tipos Escalares...........................................................................................117 8.7.2. Inicializando Tipos Compostos.........................................................................................118 8.7.3. Inicializando Strings.........................................................................................................121 8.8. ARMAZENAMENTO DE TIPOS BÁSICOS ......................................................................................121 8.8.1. Tipo char ..........................................................................................................................122 8.8.2. Tipo int .............................................................................................................................122 8.8.3. Tipo float ..........................................................................................................................123 8.8.4. Tipo double.......................................................................................................................125 8.8.5. Tipo long double...............................................................................................................125 8.9. TIPOS INCOMPLETOS .................................................................................................................125 8.10. DECLARAÇÕES TYPEDEF .......................................................................................................126 8.11. CONVERSÃO DE TIPOS ...........................................................................................................127

9.

OPERADORES E EXPRESSÕES................................................................................................129 9.1. INTRODUÇÃO .............................................................................................................................129 9.2. INTRODUÇÃO AOS OPERADORES ...............................................................................................129 9.2.1. Operadores Aritméticos e de Atribuição ..........................................................................129 9.2.2. Introdução aos Operadores Relacionais e Lógicos..........................................................131 9.2.3. Introdução aos Operadores Lógicos Bit a Bit ..................................................................132 9.3. EXPRESSÕES ..............................................................................................................................133 9.3.1. Conversão Temporária de Tipos ......................................................................................134 9.3.2. Expressões Abreviadas .....................................................................................................134 9.3.3. Encadeamento de Expressões: o Operador “,” ...............................................................135 9.3.4. Precedências de Operadores............................................................................................135 9.3.5. Expressões Primárias em C..............................................................................................135 9.3.6. Expressões L-Value e R-Value..........................................................................................137 9.3.7. Expressões Constantes em C ............................................................................................137 9.3.8. Avaliação de Expressões em C .........................................................................................138 9.3.9. Pontos de Seqüência em C................................................................................................139 9.4. MODELADORES (CASTS) ............................................................................................................139 9.4.1. Conversões Cast ...............................................................................................................140 9.5. OPERADORES DA LINGUAGEM C ...............................................................................................141 9.5.1. Precedência e Ordem de Avaliação..................................................................................141 9.5.2. Conversões Aritméticas Usuais ........................................................................................144 9.5.3. Operadores Postfixados ...................................................................................................144 9.5.4. Operadores Unários em C................................................................................................149 9.5.5. Operadores Multiplicativos ..............................................................................................153 9.5.6. Operadores de Adição ......................................................................................................154 9.5.7. Operadores de Deslocamento de Bits...............................................................................155 9.5.8. Operadores Relacionais e de Igualdade...........................................................................156

9.5.9. Operadores Lógicos entre Bits .........................................................................................158 9.5.10. Operadores Lógicos .........................................................................................................158 9.5.11. Operadores de Expressão Condicional ............................................................................159 9.5.12. Operadores de Atribuição ................................................................................................160 9.5.13. Operador de Avaliação Seqüencial ..................................................................................162 9.6. CONVERSÕES DE TIPOS .............................................................................................................162 9.6.1. Conversões de Atribuição.................................................................................................163 9.6.2. Conversões de Outros Tipos.............................................................................................167 9.7. CONVERSÕES EM CHAMADAS DE FUNÇÃO ................................................................................167 10.

CONTROLE DE FLUXO DE EXECUÇÃO – INSTRUÇÕES GERAIS..............................170

10.1. INSTRUÇÕES GERAIS .............................................................................................................170 10.2. EXPRESSÕES ..........................................................................................................................171 10.3. A INSTRUÇÃO “IF” ................................................................................................................171 10.3.1. A instrução else ................................................................................................................172 10.3.2. O if-else-if.........................................................................................................................173 10.3.3. ifs Aninhados ....................................................................................................................173 10.4. O OPERADOR “? :” ................................................................................................................174 10.5. AS INSTRUÇÕES COMPOSTAS ................................................................................................175 10.6. A INSTRUÇÃO “SWITCH” .......................................................................................................176 10.7. A INSTRUÇÃO “FOR” .............................................................................................................178 10.8. A INSTRUÇÃO “BREAK”.........................................................................................................181 10.9. A INSTRUÇÃO “WHILE” .........................................................................................................181 10.10. A INSTRUÇÃO “DO - WHILE” .................................................................................................182 10.11. A INSTRUÇÃO “CONTINUE” ...................................................................................................184 10.12. A INSTRUÇÃO “GOTO” E OS LABELS .....................................................................................185 10.13. A INSTRUÇÃO NULL ..............................................................................................................187 10.14. A INSTRUÇÃO “RETURN”.......................................................................................................187 11.

TRABALHANDO COM ARRAYS ..........................................................................................193

11.1. ARRAYS ................................................................................................................................193 11.2. STRINGS ................................................................................................................................194 11.2.1. gets....................................................................................................................................195 11.2.2. strcpy ................................................................................................................................196 11.2.3. strcat .................................................................................................................................196 11.2.4. strlen .................................................................................................................................196 11.2.5. strcmp ...............................................................................................................................197 11.3. MATRIZES .............................................................................................................................197 11.3.1. Matrizes bidimensionais ...................................................................................................197 11.3.2. Matrizes de strings............................................................................................................198 11.3.3. Matrizes multidimensionais ..............................................................................................198 11.3.4. Uso de Arrays em Sistemas com Microcontroladores ......................................................199 12.

PONTEIROS ..............................................................................................................................200

12.1. FUNCIONAMENTO ..................................................................................................................200 12.2. DECLARAÇÃO E UTILIZAÇÃO ................................................................................................201 12.3. PONTEIROS E VETORES..........................................................................................................203 12.3.1. Ponteiros como Vetores....................................................................................................205 12.3.2. Strings...............................................................................................................................205 12.3.3. Endereços de elementos de vetores ..................................................................................205 12.4. VETORES DE PONTEIROS ........................................................................................................206 12.5. PONTEIROS PARA PONTEIROS ................................................................................................206 12.6. CUIDADOS A SEREM TOMADOS AO SE USAR PONTEIROS .......................................................206 12.7. PONTEIROS E FUNÇÕES..........................................................................................................207 12.8. ALOCAÇÃO DINÂMICA DE MEMÓRIA ....................................................................................207 12.8.1. malloc ...............................................................................................................................208 12.8.2. calloc ................................................................................................................................208 12.8.3. realloc...............................................................................................................................209 12.8.4. free....................................................................................................................................209 12.9. ALOCAÇÃO DINÂMICA DE VETORES E MATRIZES .................................................................210

12.9.1. 12.9.2. 13.

Alocação Dinâmica de Vetores ........................................................................................210 Alocação Dinâmica de Matrizes.......................................................................................210

AS FUNÇÕES.............................................................................................................................216

13.1. INTRODUÇÃO ÀS FUNÇÕES ....................................................................................................216 13.2. DEFINIÇÃO DE UMA FUNÇÃO .................................................................................................217 13.2.1. Atributos das Funções – Funções inline...........................................................................218 13.3. CLASSES DE ARMAZENAMENTO ............................................................................................219 13.4. TIPO DE RETORNO DE UMA FUNÇÃO......................................................................................219 13.5. PARÂMETROS DE UMA FUNÇÃO.............................................................................................222 13.6. CORPO DE UMA FUNÇÃO .......................................................................................................222 13.7. PROTÓTIPOS DE UMA FUNÇÃO ...............................................................................................223 13.8. CHAMADAS DE FUNÇÃO ........................................................................................................224 13.8.1. Argumentos.......................................................................................................................226 13.8.2. Chamadas com Número Variável de Argumentos ............................................................227 13.9. RECURSIVIDADE ....................................................................................................................228 13.10. MODIFICADORES DE FUNÇÕES ..............................................................................................229 13.10.1. pascal............................................................................................................................230 13.10.2. cdecl..............................................................................................................................230 13.10.3. interrupt........................................................................................................................230 13.11. PONTEIROS PARA FUNÇÕES ...................................................................................................230 13.12. ALGUMAS CONSIDERAÇÕES GERAIS .....................................................................................231 13.13. ESCOPO DE VARIÁVEIS ..........................................................................................................231 13.13.1. Variáveis locais ............................................................................................................231 13.13.2. Parâmetros formais ......................................................................................................232 13.13.3. Variáveis globais ..........................................................................................................232 13.14. PASSAGEM DE PARÂMETROS POR VALOR E REFERÊNCIA ......................................................233 13.15. VETORES COMO ARGUMENTOS DE FUNÇÕES.........................................................................234 13.16. ARQUIVOS DE CABEÇALHO ...................................................................................................234 14.

DIRETIVAS DE COMPILAÇÃO ............................................................................................240

14.1. 14.2. 14.3. 14.4. 14.5. 14.6. 14.7. 15.

A DIRETIVA #INCLUDE ..........................................................................................................240 AS DIRETIVAS #DEFINE E #UNDEF .........................................................................................240 AS DIRETIVAS #IFDEF E #ENDIF .............................................................................................242 A DIRETIVA #IFNDEF.............................................................................................................243 A DIRETIVA #IF .....................................................................................................................243 A DIRETIVA #ELSE ................................................................................................................243 A DIRETIVA #ELIF .................................................................................................................244

ENTRADAS E SAÍDAS – I/O ...................................................................................................245

15.1. LENDO E ESCREVENDO CARACTERES ....................................................................................245 15.1.1. getche e getch ...................................................................................................................245 15.1.2. putchar..............................................................................................................................246 15.2. LEITURA E ESCRITA DE STRINGS ...........................................................................................246 15.2.1. gets....................................................................................................................................246 15.2.2. puts ...................................................................................................................................247 15.3. ENTRADA E SAÍDA FORMATADA ...........................................................................................247 15.3.1. printf .................................................................................................................................247 15.3.2. scanf..................................................................................................................................248 15.4. OPERANDO COM ARQUIVOS ..................................................................................................249 15.4.1. fopen .................................................................................................................................249 15.4.2. fclose.................................................................................................................................250 15.4.3. exit ....................................................................................................................................251 15.5. LENDO E ESCREVENDO CARACTERES EM ARQUIVOS ............................................................251 15.5.1. putc() ................................................................................................................................251 15.5.2. getc ...................................................................................................................................252 15.5.3. feof ....................................................................................................................................252 15.6. OUTROS COMANDOS DE ACESSO A ARQUIVOS ......................................................................253 15.6.1. Arquivos Predefinidos ......................................................................................................253 15.6.2. fgets ..................................................................................................................................253

15.6.3. fputs ..................................................................................................................................254 15.6.4. ferror e perror ..................................................................................................................254 15.6.5. fread..................................................................................................................................255 15.6.6. fwrite.................................................................................................................................255 15.6.7. fseek ..................................................................................................................................256 15.6.8. rewind ...............................................................................................................................256 15.6.9. remove ..............................................................................................................................256 15.7. FLUXOS PADRONIZADOS .......................................................................................................257 15.7.1. fprintf ................................................................................................................................257 15.7.2. fscanf ................................................................................................................................257 15.8. FUNÇÕES DE I/O - PORTAS ....................................................................................................258 15.8.1. _inp (Microsoft C e Visual C++) .....................................................................................258 15.8.2. _out (Microsoft C e Visual C++) .....................................................................................258 15.8.3. inportb (Borland C++).....................................................................................................258 15.8.4. outportb (Borland C++)...................................................................................................259 16.

TIPOS DE DADOS ESPECIAIS...............................................................................................262

16.1. ESTRUTURAS (STRUCT) .........................................................................................................262 16.1.1. Passando para Funções....................................................................................................264 16.1.2. Ponteiros...........................................................................................................................264 16.2. UNION ...................................................................................................................................265 16.3. ENUMERAÇÕES (ENUM).........................................................................................................266 16.4. O COMANDO SIZEOF..............................................................................................................267 16.5. O COMANDO TYPEDEF ..........................................................................................................267 16.6. LISTAS SIMPLESMENTE ENCADEADAS ...................................................................................268 17.

INTERRUPÇÕES ......................................................................................................................271

17.1. INTRODUÇÃO .........................................................................................................................271 17.2. INTERRUPÇÕES E A ARQUITETURA INTEL ..............................................................................271 17.3. INTERRUPÇÕES DE HARDWARE .............................................................................................272 17.4. INSTRUÇÕES DE INTERRUPÇÃO DE HARDWARE .....................................................................274 17.4.1. Borland C++ - 80x86 .......................................................................................................274 17.4.2. Franklin C – 8x51.............................................................................................................274 17.4.3. PCW CCS – Microchip PIC .............................................................................................274 17.5. IMPLEMENTANDO UMA ROTINA DE ATENDIMENTO A INTERRUPÇÃO (ISR) ...........................274 17.6. USANDO UMA NOVA ROTINA DE ATENDIMENTO A INTERRUPÇÃO - ISR ...............................276 17.7. O CONTROLADOR PROGRAMÁVEL DE INTERRUPÇÕES - PIC .................................................277 17.7.1. Redirecionamento IRQ2/IRQ9..........................................................................................278 17.8. ENDEREÇOS DOS CONTROLADORES PROGRAMÁVEIS DE INTERRUPÇÃO ................................280 17.8.1. Initialization Command Word 1 (ICW1) ..........................................................................280 17.8.2. Initialization Command Word 2 (ICW2) ..........................................................................281 17.8.3. Initialization Command Word 3 (ICW3) ..........................................................................281 17.8.4. Initialization Command Word 4 (ICW4) ..........................................................................282 17.8.5. Operation Control Word 1 (OCW1) .................................................................................282 17.8.6. Operation Control Word 2 (OCW2) .................................................................................282 17.8.7. Operation Control Word 3 (OCW3) .................................................................................283 17.9. PROGRAMAÇÃO DO TIMER DO PC .........................................................................................283 18.

A INTERFACE PARALELA....................................................................................................286

18.1. AS INTERFACES – UMA INTRODUÇÃO ...................................................................................286 18.2. A INTERFACE PARALELA.......................................................................................................286 18.3. INTERFACEAMENTO COM A PORTA PARALELA PADRÃO ........................................................287 18.4. PROPRIEDADES DO HARDWARE .............................................................................................288 18.5. CENTRONICS .........................................................................................................................289 18.6. ENDEREÇOS DAS PORTAS .....................................................................................................290 18.6.1. Endereços Iniciais ............................................................................................................290 18.7. REGISTRADORES DA STANDARD PARALLEL PORT (SPP).......................................................291 18.8. PORTAS BIDIRECIONAIS.........................................................................................................293 18.9. USANDO A PORTA PARALELA PARA LER 8 BITS....................................................................295 18.9.1. Modo Nibble .....................................................................................................................296

18.10. USANDO A INTERRUPÇÃO DA PORTA PARALELA ...................................................................298 18.11. MODOS DA PORTA PARALELA NO BIOS................................................................................300 18.12. MODOS DA PORTA PARALELA E EXTENDED CONTROL REGISTER DO MODO ECP .................301 18.12.1. Bit Function ..................................................................................................................301 18.12.2. Modos de Operação......................................................................................................301 19.

INTERFACES SERIAIS ...........................................................................................................303

19.1. INTRODUÇÃO .........................................................................................................................303 19.2. PROPRIEDADES DE HARDWARE DOS PCS...............................................................................304 19.2.1. Conectores Seriais (DB-25 e DB-9) .................................................................................304 19.2.2. Funções dos Pinos ............................................................................................................305 19.3. NULL MODEMS .....................................................................................................................305 19.3.1. Conexão LoopBack...........................................................................................................306 19.3.2. Velocidades DTE / DCE ...................................................................................................307 19.4. CONTROLE DE FLUXO - FLOW CONTROL ...............................................................................307 19.5. A UART (8250 E COMPATÍVEIS) ..........................................................................................308 19.6. TIPOS DE UARTS (PCS) ........................................................................................................310 19.7. REGISTRADORES DAS PORTAS SERIAIS (PCS) – ENDEREÇOS DAS PORTAS E IRQS ................310 19.8. TABELA DE REGISTRADORES.................................................................................................311 19.9. DLAB ...................................................................................................................................312 19.10. INTERRUPT ENABLE REGISTER (IER) ....................................................................................313 19.10.1. Interrupt Identification Register (IIR) ..........................................................................313 19.10.2. First In / First Out Control Register (FCR)..................................................................314 19.10.3. Line Control Register (LCR) ........................................................................................315 19.10.4. Modem Control Register (MCR)...................................................................................316 19.10.5. Line Status Register (LSR)............................................................................................317 19.10.6. Modem Status Register (MSR)......................................................................................318 19.10.7. Register de uso Geral (Scratch)....................................................................................319 19.11. PROGRAMANDO (PCS) – RECEPÇÃO POR POLLING E POR INTERRUPÇÃO ...............................319 19.12. VETORES DE INTERRUPÇÕES .................................................................................................321 19.12.1. Interrupt Service Routine (ISR) ....................................................................................322 19.13. CONFIGURAÇÃO DA UART ...................................................................................................323 19.13.1. Rotina Main (Loop) ......................................................................................................324 19.13.2. Determinando o Tipo de UART ....................................................................................324 19.14. INTERFACEANDO DISPOSITIVOS COM AS PORTAS RS-232 .....................................................324 19.14.1. Conversores de Nível RS-232 .......................................................................................325 19.15. INTERFACES COM MICROCONTROLADORES ...........................................................................327 19.16. AS PORTAS NO SISTEMA WINDOWS ......................................................................................327 19.17. A ANTIGA MAS ÚTIL BIBLIOTECA DE COMUNICAÇÃO DA BORLAND .....................................327 APÊNDICE A -

PADRÕES DE TRANSMISSÃO SERIAL...........................................................332

INTRODUÇÃO.........................................................................................................................................332 TRANSMISSÃO DE DADOS EM SISTEMAS DESBALANCEADOS (SINGLE-ENDED).....................................333 TRANSMISSÃO DE DADOS EM SISTEMAS BALANCEADOS (DIFERENCIAIS) .............................................334 COMPARAÇÃO ENTRE SISTEMAS BALANCEADOS E DESBALANCEADOS ..................................................335 DRIVERS DE LINHA DESBALANCEADOS ................................................................................................336 DRIVERS DE LINHA BALANCEADOS ......................................................................................................337 RECEPTORES BALANCEADOS ................................................................................................................337 PADRÕES DE TRANSMISSÃO TIA/EIA ...................................................................................................338 PADRÕES TIA/EIA DESBALANCEADOS.................................................................................................339 Padrão TIA/EIA-232-F (RS-232) .....................................................................................................339 TIA/EIA-423-B..................................................................................................................................340 TIA/EIA-562 .....................................................................................................................................341 TIA/EIA-694 .....................................................................................................................................342 PADRÕES TIA/EIA BALANCEADOS (DIFERENCIAL)..............................................................................342 TIA/EIA-422-B..................................................................................................................................342 TIA/EIA-485-A..................................................................................................................................345 TIA/EIA-612 .....................................................................................................................................348 TIA/EIA-644 (LVDS) ........................................................................................................................349 OUTROS PADRÕES TIA/EIA..................................................................................................................349

TIA/EIA-232-F..................................................................................................................................349 EIA-334-A.........................................................................................................................................349 EIA-363 ............................................................................................................................................350 EIA-404-A.........................................................................................................................................350 EIA-449 ............................................................................................................................................350 TIA/EIA-530-A..................................................................................................................................350 TIA/EIA-561 .....................................................................................................................................350 TIA/EIA-574 .....................................................................................................................................350 TIA/EIA-613 .....................................................................................................................................350 TIA/EIA-687 .....................................................................................................................................351 TIA/EIA-688 .....................................................................................................................................351 TIA/EIA-723 .....................................................................................................................................351 RECOMENDAÇÕES CCITT/ITU-T .........................................................................................................351 Recomendação V.10 .........................................................................................................................351 Recomendação V.11 .........................................................................................................................352 Recomendação V.24 .........................................................................................................................352 Recomendação V.28 .........................................................................................................................352 Recomendação V.35 .........................................................................................................................352 OUTROS PADRÕES .................................................................................................................................353 IEEE488 ...........................................................................................................................................353 CONFIGURAÇÃO DE SISTEMAS EIA-422 E EIA-485 ..............................................................................353 Controle Tristate de um dispositivo RS-485 utilizando o sinal RTS.................................................353 Configurações ..................................................................................................................................354 Sistemas a Dois ou Quatro Fios .......................................................................................................355 Terminação.......................................................................................................................................356 Polarizando uma rede RS-485..........................................................................................................358 Estendendo a Especificação .............................................................................................................360 SELEÇÃO DOS CABOS PARA RS-422 E RS-485 ......................................................................................360 Número de condutores......................................................................................................................360 Blindagem.........................................................................................................................................360 Características do Cabo...................................................................................................................360 PROTEÇÃO CONTRA TRANSIENTES NOS SISTEMAS RS-422 E RS-485.....................................................362 Com o que se parecem os surtos ? ...................................................................................................362 Modo Comum versus Modo Diferencial...........................................................................................364 Um terra não é igual a outro............................................................................................................364 Proteção contra Transientes usando Isolação .................................................................................365 Proteção contra Transientes utilizando Derivações Shunt ..............................................................366 Conectando os sinais de terra ..........................................................................................................367 Dispositivos de Derivação................................................................................................................367 Combinando Isolação com Derivação .............................................................................................367 Considerações Especiais para as Condições de Falha ....................................................................368 Escolha da proteção certa................................................................................................................369 SOFTWARE ............................................................................................................................................370 Considerações Básicas.....................................................................................................................370 Sistemas Master-Slave (Mestre-Escravo).........................................................................................371 Sistemas RS-485 Multimestre ...........................................................................................................372 APÊNDICE B -

MICROCONTROLADORES MICROCHIP PIC DA FAMILIA 16FXXX .....373

APLICAÇÕES ..........................................................................................................................................373 CARACTERÍSTICAS DOS MICROCONTROLADORES PIC ...........................................................................373 PIC 16F87X - CARACTERÍSTICAS ..........................................................................................................373 PIC 16F87X - PERIFÉRICOS ...................................................................................................................374 PINAGEM ...............................................................................................................................................375 ARQUITETURA MICROCHIP PIC.............................................................................................................375 ORGANIZAÇÃO DA MEMÓRIA DE PROGRAMA .......................................................................................376 REGISTRADORES INTERNOS E MEMÓRIA DE DADOS ..............................................................................377 MPLAB DA MICROCHIP .......................................................................................................................377 O COMPILADOR PCW DA CCS .............................................................................................................378 GRAVADOR ...........................................................................................................................................379 REGRAS DO COMPILADOR PCW DA CCS..............................................................................................379

Tipos de Variáveis Simples...............................................................................................................379 Biblioteca de Funções ......................................................................................................................379 Expressões Constantes .....................................................................................................................380 Identificadores: ................................................................................................................................380 DIRETIVAS DE COMPILADOR .................................................................................................................380 Algumas Diretivas ............................................................................................................................381 SEQÜÊNCIA DE PASSOS PARA IMPLEMENTAÇÃO DO SOFTWARE (FIRMWARE) .......................................381 PORTAS DE I/O DIGITAIS .......................................................................................................................381 PORTA .............................................................................................................................................381 PORTB .............................................................................................................................................382 PORTC .............................................................................................................................................383 Outras Portas ...................................................................................................................................384 EXERCÍCIO 1 - OSCILADOR....................................................................................................................384 EXERCÍCIO 2 - OSCILADOR CONTROLADO ............................................................................................385 EXERCÍCIO 3 - ONDA QUADRADA .........................................................................................................386 TIMER 0.................................................................................................................................................386 Características do Timer 0 ...............................................................................................................386 Registradores....................................................................................................................................387 Funcionamento do Timer 0 ..............................................................................................................388 EXERCÍCIO 4 - OSCILADOR UTILIZANDO O TIMER 0 ..............................................................................388 EXERCÍCIO 5 - OSCILADOR UTILIZANDO A INTERRUPÇÃO DO TIMER 0 ..................................................389 TIMER 1.................................................................................................................................................391 Características .................................................................................................................................391 Esquema Elétrico .............................................................................................................................392 Registradores Associados ao Timer1 ...............................................................................................392 EXERCÍCIO 6 - OSCILADOR UTILIZANDO A INTERRUPÇÃO DO TIMER 1 ..................................................393 USART OU SCI ....................................................................................................................................394 Modos de Operação .........................................................................................................................394 Registradores Associados.................................................................................................................395 USART BAUD RATE GENERATOR (BRG) ............................................................................................396 TRANSMISSÃO ASSÍNCRONA .................................................................................................................397 EXERCÍCIO 7 - TRANSMISSOR SERIAL ....................................................................................................398 EXERCÍCIO 8 - TRANSMISSOR SERIAL 2 .................................................................................................399 EXERCÍCIO 9 - RECEPTOR SERIAL..........................................................................................................399 TIMER 2.................................................................................................................................................401 Características .................................................................................................................................401 Diagrama do Timer 2 .......................................................................................................................402 Registradores Associados ao Timer 2 ..............................................................................................402 MÓDULO CCP (COMPARE, CAPTURE AND PWM MODULE) ..................................................................403 Características Gerais......................................................................................................................403 Recursos ...........................................................................................................................................403 Registradores Associados ao Módulo CCP......................................................................................403 Modo Capture...................................................................................................................................404 Modo Compare.................................................................................................................................405 Modo PWM.......................................................................................................................................405 PWM - Aplicações ............................................................................................................................406 EXERCÍCIO 10 - PWM...........................................................................................................................406 PORTA SERIAL SÍNCRONA (SSP) ...........................................................................................................409 Características .................................................................................................................................409 Registradores Associados à Porta Serial Síncrona..........................................................................410 Modo SPI..........................................................................................................................................411 SPI - Operação.................................................................................................................................412 SPI - Registradores Associados........................................................................................................414 EXERCÍCIO 11 - SPI...............................................................................................................................414 CONVERSOR ANALÓGICO-DIGITAL (ADC) ...........................................................................................416 ADC - Características ......................................................................................................................416 Diagrama do ADC............................................................................................................................417 Registradores Associados ao ADC...................................................................................................418 WATCHDOG TIMER E O MODO SLEEP (POWER DOWN)..........................................................................419 Watchdog Timer ...............................................................................................................................419

Sleep - Power Down .........................................................................................................................419 Acordando o Dispositivo ..................................................................................................................420 ICSP (IN CICUIT SERIAL PROGRAMMING).............................................................................................420 Circuito Típico .................................................................................................................................420 EXERCÍCIO 12........................................................................................................................................420 APÊNDICE C -

MICROCONTROLADORES DA FAMÍLIA INTEL 8051................................421

APLICAÇÕES ..........................................................................................................................................421 MICROCONTROLADORES 8X5X..............................................................................................................421 FABRICANTES ........................................................................................................................................421 AT89C52 - CARACTERÍSTICAS .............................................................................................................421 APPLICATION BUILDER DA INTEL®.......................................................................................................422 PINAGEM DO 8051.................................................................................................................................422 ARQUITETURA .......................................................................................................................................424 ORGANIZAÇÃO DA MEMÓRIA DE PROGRAMA .......................................................................................425 REGISTRADORES INTERNOS E MEMÓRIA DE DADOS ..............................................................................425 INTERRUPÇÕES ......................................................................................................................................427 O SIMULADOR - JSIM ...........................................................................................................................427 Ferramenta de simulação.................................................................................................................427 O JENS EDITOR - JFE ............................................................................................................................428 ADICIONAR A CHAMADA AO COMPILADOR ...........................................................................................429 ADICIONAR A CHAMADA AO LINKER .....................................................................................................429 ADICIONAR A CHAMADA AO SIMULADOR JSIM.....................................................................................430 ADICIONAR A CHAMADA AO CONVERSOR (ABS TO HEX) OHS51...........................................................430 ADICIONAR A CHAMADA AO CONVERSOR (HEX TO BIN) HEXBIN ...........................................................431 O COMPILADOR C51 DA FRANKLIN SOFTWARE ....................................................................................431 GRAVADOR ...........................................................................................................................................431 REGRAS DO COMPILADOR C51 DA KEIL ...............................................................................................431 BIBLIOTECA DE FUNÇÕES ......................................................................................................................431 SEQÜÊNCIA DE PASSOS PARA IMPLEMENTAÇÃO ....................................................................................432 PORTAS DE I/O DIGITAIS .......................................................................................................................432 Características .................................................................................................................................432 Porta P0 ...........................................................................................................................................432 Porta P1 ...........................................................................................................................................432 Porta P2 ...........................................................................................................................................433 Porta P3 ...........................................................................................................................................433 PROBLEMA 1 - OSCILADOR ...................................................................................................................434 PROBLEMA 2 - OSCILADOR CONTROLADO ............................................................................................435 EXERCÍCIO 3 - ONDA QUADRADA .........................................................................................................436 OS TEMPORIZADORES TIMER 0, TIMER 1 E TIMER 2..............................................................................436 Características do Timer 0 e Timer 1...............................................................................................436 Timer 0 e 1 - Operação ....................................................................................................................436 Timer 0 e 1- Modo 0 .........................................................................................................................436 Timer 0 e 1 - Modo 1 ........................................................................................................................437 Timer 0 e 1 - Modo 2 ........................................................................................................................437 Timer 0 e 1- Modo 3 .........................................................................................................................437 Registradores Associados ao Timer/Counter ...................................................................................438 Timer 2 - Características..................................................................................................................440 EXERCÍCIO 4 - OSCILADOR UTILIZANDO O TIMER 0 ..............................................................................440 EXERCÍCIO 5 - OSCILADOR UTILIZANDO A INTERRUPÇÃO DO TIMER 0 ..................................................441 USART (UNIVERSAL SYNCHRONOUS ASYNCHRONOUS RECEIVER TRANSMITTER)..............................443 Modos de Operação .........................................................................................................................443 Funcionamento.................................................................................................................................443 Registradores Associados.................................................................................................................444 USART - Modo 0 ..............................................................................................................................445 USART - Modo 1 ..............................................................................................................................445 USART - Modo 2 ..............................................................................................................................445 USART - Modo 3 ..............................................................................................................................445 EXERCÍCIO 6 - TRANSMISSOR SERIAL ....................................................................................................445 EXERCÍCIO 7 - TRANSMISSOR SERIAL 2 .................................................................................................448

EXERCÍCIO 8 - RECEPTOR SERIAL..........................................................................................................449 EXERCÍCIO 9 – COMUNICAÇÃO SERIAL .................................................................................................450 APÊNDICE D -

AS PORTAS DE COMUNICAÇÃO NO SISTEMA MS WINDOWS...............451

OS RECURSOS DE COMUNICAÇÃO NO WINDOWS® ...............................................................................451 MANIPULADORES DE RECURSOS DE COMUNICAÇÃO .............................................................................452 MODIFICAÇÕES DOS PARÂMETROS DOS RECURSOS DE COMUNICAÇÃO ................................................452 UTILIZANDO AS FUNÇÕES DE COMUNICAÇÃO .......................................................................................454 A ESTRUTURA DCB..............................................................................................................................456 CONFIGURAÇÃO DOS RECURSOS DE COMUNICAÇÃO .............................................................................460 CONFIGURAÇÃO DO MODEM .................................................................................................................461 OPERAÇÕES DE LEITURA E ESCRITA......................................................................................................463 OPERAÇÕES SOBREPOSTAS ...................................................................................................................464 TIMEOUTS .............................................................................................................................................465 ERROS DE COMUNICAÇÃO .....................................................................................................................467 EVENTOS DE COMUNICAÇÃO.................................................................................................................468 REFERÊNCIA DE FUNÇÕES DE COMUNICAÇÃO .......................................................................................469 EXEMPLO FUNCIONAL ...........................................................................................................................470 APÊNDICE E -

OS CONECTORES ................................................................................................479

PORTAS DE TECLADO E MOUSE (PS/2,AT,XT) .....................................................................................479 PS/2 - ATX ........................................................................................................................................479 Teclado AT .......................................................................................................................................479 PORTA DE JOGOS (JOYSTICK) ................................................................................................................480 PORTAS SERIAIS COM (RS-232)...........................................................................................................481 Porta Serial (DB-25) ........................................................................................................................481 Porta Serial (DB-9) ..........................................................................................................................482 Porta Serial (RJ-45) .........................................................................................................................483 Adaptador serial de 9 pinos para 25 ................................................................................................484 PORTA PARALELA - LPT / IMPRESSORA ................................................................................................484 Conector de Porta Paralela ECP .....................................................................................................485 USB ......................................................................................................................................................486 PORTAS DE DISPLAY .............................................................................................................................487 RGBI Digital (MDA,CGA,EGA,NEC) .............................................................................................487 RGB Analógico (VGA,SVGA,VESA).................................................................................................487 INTERFACE DE REDE ETHERNET (AUI,BNC,TP,FL) .............................................................................488 AUI ...................................................................................................................................................488 BNC (Coaxial) ..................................................................................................................................488 TP - Twisted-Pair Ethernet ..............................................................................................................489 ISA .......................................................................................................................................................490 EISA .....................................................................................................................................................492 IDE INTERNO ........................................................................................................................................494 SLOT DE EXPANSÃO PCI .......................................................................................................................495 PCMCIA...............................................................................................................................................499 CONECTORES DE ALIMENTAÇÃO DO PC................................................................................................501 Conector de Alimentação ATX .........................................................................................................501 Conector de Alimentação XT/AT......................................................................................................501 Conector de Alimentação 5¼ ...........................................................................................................501 Conector de Alimentação 3½ ...........................................................................................................502 TABELA DE REFERENCIA DE CONECTORES ............................................................................................503 APÊNDICE F -

EXEMPLOS DE APLICAÇÃO ............................................................................509

ADC .....................................................................................................................................................509 DAC .....................................................................................................................................................511 TECLADO...............................................................................................................................................511 LCD......................................................................................................................................................512 PWM ....................................................................................................................................................514 RELÉ .....................................................................................................................................................516 MOTOR DE PASSO .................................................................................................................................516 CALENDÁRIO .........................................................................................................................................520

MANIPULAÇÃO DE STRINGS...................................................................................................................521 CÓPIA DE STRINGS .................................................................................................................................523 INVERSAO DE STRINGS ..........................................................................................................................524 CONCATENAÇÃO DE STRINGS ................................................................................................................524 NÚMEROS COMPLEXOS .........................................................................................................................525 INTEGRAÇÃO .........................................................................................................................................526 RUNGE KUTTA ......................................................................................................................................535 AUTOVALORES DE UMA MATRIZ - HOUSEHOLDER ................................................................................537 CALCULO DE π PELO MÉTODO DE MONTECARLO ..................................................................................540 BÁSKARA ..............................................................................................................................................542 FÓRMULA ..............................................................................................................................................542 FATORIAL ..............................................................................................................................................543 DIFERENÇA DE ÂNGULOS ......................................................................................................................543 ORDEM CRESCENTE ..............................................................................................................................544 APÊNDICE G -

PRIMEIROS PASSOS ...........................................................................................545

MICROSOFT VISUAL C++4.0, 5.0 E 6.0 ................................................................................................545 BORLAND BUILDER C++ 3.0, 4.0 E 5.0 .................................................................................................551 BORLAND C++ 3.0 E 3.1 .......................................................................................................................556 GLOSSÁRIO ..........................................................................................................................................560 REFERÊNCIAS .....................................................................................................................................561 BIBLIOGRAFIA .......................................................................................................................................561 WEB ......................................................................................................................................................561 ÍNDICE ...................................................................................................................................................562

Índice de Figuras FIGURA 2-1 – PROCESSO DE GRAVAÇÃO .......................................................................................................7 FIGURA 2-2 – PROCESSADOR 8051 FX INTEL ...............................................................................................9 FIGURA 2-3 - EXEMPLO DE FLUXOGRAMA ..................................................................................................13 FIGURA 3-1 – ANTIGOS SISTEMAS DE NUMERAÇÃO.....................................................................................17 FIGURA 3-2 – PORTA AND .........................................................................................................................25 FIGURA 3-3 – PORTA OR ............................................................................................................................26 FIGURA 3-4 – PORTA XOR .........................................................................................................................27 FIGURA 3-5 – PORTA NOT..........................................................................................................................27 FIGURA 3-6 – PORTAS NAND E NOR ........................................................................................................27 FIGURA 4-1 – BLOCO DE PROCESSO ............................................................................................................41 FIGURA 4-2 – BLOCO DE TOMADA DE DECISÃO ...........................................................................................42 FIGURA 4-3 – FLUXOGRAMA GENÉRICO .....................................................................................................42 FIGURA 4-4 – PROCEDIMENTO DE GERAÇÃO DE UM PROGRAMA EXECUTÁVEL ...........................................44 FIGURA 5-1 – ESTRUTURAÇÃO DE UM PROGRAMA EM C.............................................................................61 FIGURA 17-1 – CONTROLADOR PROGRAMÁVEL DE INTERRUPÇÕES ..........................................................277 FIGURA 17-2 – REDIRECIONAMENTO DE IRQ2/IRQ9................................................................................279 FIGURA 18-1 – CONECTOR DE DB-25 .......................................................................................................288 FIGURA 18-2 - HANDSHAKE DO PADRÃO CENTRONICS .............................................................................289 FIGURA 18-3- PORTA PARALELA BIDIRECIONAL........................................................................................294 FIGURA 18-4 – USANDO A PORTA PARALELA PARA LER OITO BITS ............................................................295 FIGURA 18-5 – OITO ENTRADAS UTILIZANDO UM MULTIPLEXADOR 74LS157 ..........................................297 FIGURA 19-1 – DIAGRAMA DE CONEXÃO DE UM NULL MODEM................................................................305 FIGURA 19-2 – DIAGRAMA DE CONEXÃO LOOPBACK ................................................................................306 FIGURA 19-3 – PINAGEM DAS UARTS 16550, 16450 E 8250 ...................................................................308 FIGURA 19-4 – FORMA DE ONDA TTL/CMOS PARA O CANAL SERIAL......................................................325 FIGURA 19-5 – FORMA DE ONDA NO PADRÃO RS-232...............................................................................325 FIGURA 19-6 – PINAGEM E DIAGRAMA ESQUEMÁTICO DO DRIVER TRANSCEPTOR MAX232.....................326 FIGURA 19-7 – CONVERSOR DE NÍVEIS TTL/CMOS PARA RS-232...........................................................327 FIGURA 20-1 - TRANSMISSÃO DE DADOS EM SISTEMAS DESBALANCEADOS - 3 CANAIS, 4 LINHAS ..........333 FIGURA 20-2 - SISTEMA BALANCEADO DE TRANSMISSÃO - 3 CANAIS, 6 LINHAS E SINAL DE TERRA ........334 FIGURA 20-3 – CIRCUITO DE INTERFACE RS-232 .....................................................................................336 FIGURA 20-4 – DRIVER DE LINHA DIFERENCIAL BALANCEADO................................................................337 FIGURA 20-5 – RECEPTOR DE LINHA DIFERENCIAL BALANCEADO ...........................................................338 FIGURA 20-6 - APLICAÇÃO TÍPICA TIA/EIA-232-F ..................................................................................339 FIGURA 20-7 - APLICAÇÃO TÍPICA TIA/EIA-423-B..................................................................................340 FIGURA 20-8 - APLICAÇÃO TÍPICA TIA/EIA-561 .....................................................................................341 FIGURA 20-9- APLICAÇÃO TÍPICA TIA/EIA-694 .......................................................................................342 FIGURA 20-10 - APLICAÇÃO TIA/EIA-422-B PONTO A PONTO ...............................................................343 FIGURA 20-11 - APLICAÇÃO TÍPICA TIA/EIA-422-B MULTIDROP ............................................................344 FIGURA 20-12 – REDE RS-422 DE 4 FIOS TÍPICA .......................................................................................344 FIGURA 20-13 – RELAÇÕES ENTRE OS TERMINAIS ‘A’ E ‘B’ NOS DISPOSITIVOS RS-422 OU RS-485 E OS IDENTIFICADORES CONVENCIONAIS ‘+’ E ‘-‘. ....................................................................................345 FIGURA 20-14 - APLICAÇÃO TÍPICA TIA/EIA-485-A................................................................................346 FIGURA 20-15 – REDE MULTIDROP RS-485 A DOIS FIOS ...........................................................................347 FIGURA 20-16 – REDE MULTIDROP RS-485 A QUATRO FIOS .....................................................................348 FIGURA 20-17 - APLICAÇÃO TÍPICA TIA/EIA-612 E TIA/EIA-644 PONTO A PONTO ................................349 FIGURA 20-18 – DIAGRAMA DE TEMPOS PARA UM CONVERSOR RS-232 PARA RS-485 COM CONTROLE RTS DO DRIVER E RECEPTOR RS-485 ........................................................................................................354 FIGURA 20-19 – TOPOLOGIAS DE REDE .....................................................................................................354 FIGURA 20-20 – CONFIGURAÇÃO TÍPICA DE REDE MULTIDROP RS-485 A QUATRO FIOS ..........................355 FIGURA 20-21 – CONFIGURAÇÃO TÍPICA DE REDE MULTIDROP RS-485 A DOIS FIOS ................................356 FIGURA 20-22 - TERMINAÇÃO EM PARALELO E COM ACOPLAMENTO AC..................................................357 FIGURA 20-23 – TERMINAÇÃO DE REDES ..................................................................................................358 FIGURA 20-24 - TRANSCEPTOR COM RESISTORES DE POLARIZAÇÃO .........................................................359

FIGURA 20-25 – TAXA DE TRANSMISSÃO DE DADOS VERSUS COMPRIMENTO DO CABO PARA INTERFACES BALANCEADAS, UTILIZANDO UM CABO DE PAR TRANÇADO 24 AWG................................................361 FIGURA 20-26 – TAXA DE DADOS POR COMPRIMENTO DE CABO, COMO CONSEQÜÊNCIA DOS ATRASOS FINITOS DE PROPAGAÇÃO DA LINHA DE TRANSMISSÃO ......................................................................361 FIGURA 20-27 – ATENUAÇÃO VERSUS FREQÜÊNCIA PARA VÁRIOS TIPOS DE CABOS .................................362 FIGURA 20-28 – FORMA DE ONDA DE TENSÃO DO SINAL DE COMBINAÇÃO ...............................................363 FIGURA 20-29 – FORMA DE ONDA DE CORRENTE DO SINAL DE COMBINAÇÃO ...........................................363 FIGURA 20-30 – RING WAVE DE 100 KHZ ................................................................................................363 FIGURA 20-31 – UM TERRA NÃO É IGUAL A OUTRO ...................................................................................364 FIGURA 20-32 – DISPOSITIVO RS-485 ISOLADO .......................................................................................365 FIGURA 20-33 – DISPOSITIVO RS-485 COM SINAL DE TERRA CONECTADO NA MASSA ..............................365 FIGURA 20-34 – CONEXÃO DO SINAL DE TERRA ENTRE DOIS NÓS COM UM RESISTOR DE 100 Ω................367 FIGURA 20-35 – NÓ ISOLADO COM PROTEÇÃO SHUNT PARA O TERRA .......................................................368 FIGURA 20-36 – PORTA ISOLADA COM PROTEÇÃO SHUNT NÃO ATERRADA ...............................................368 FIGURA 20-37 – PROTEÇÃO DA PORTA COM FUSÍVEIS ...............................................................................369 FIGURA 20-38 – EXEMPLO DE CIRCUITO COM PROTEÇÃO DE LINHA ..........................................................369 FIGURA 20-39 – EXEMPLO DE CIRCUITO COMUM PARA PROTEÇÃO DE LINHA............................................370 FIGURA 21-1 – PINAGEM DO MICROCONTROLADOR PIC 16F877..............................................................375 FIGURA 21-2 – ARQUITETURA DO MICROCONTROLADOR PIC 16F877......................................................375 FIGURA 21-3 – ORGANIZAÇÃO DA MEMÓRIA DE PROGRAMA DO MICROCONTROLADOR PIC 16F877........376 FIGURA 21-4 – REGISTRADORES INTERNOS DO MICROCONTROLADOR PIC 16F877..................................377 FIGURA 21-5 – APARÊNCIA DO SOFTWARE MPLAB .................................................................................378 FIGURA 21-6 – APARÊNCIA DO COMPILADOR PCW ..................................................................................379 FIGURA 21-7 – PORTA A ...........................................................................................................................382 FIGURA 21-8 – PINO RA4 .........................................................................................................................382 FIGURA 21-9 – PORTA B ...........................................................................................................................383 FIGURA 21-10 – PORTA C .........................................................................................................................384 FIGURA 21-11 – EXERCÍCIO 1 NO MPLAB ...............................................................................................385 FIGURA 21-12 – EXERCÍCIO 2 NO MPLAB ...............................................................................................386 FIGURA 21-13 – TIMER 0 ..........................................................................................................................387 FIGURA 21-14 – TEMPORIZAÇÃO DO TIMER 0: CLOCK INTERNO SEM PRESCALER.....................................388 FIGURA 21-15 – TEMPORIZAÇÃO DO TIMER 0: CLOCK INTERNO COM PRESCALER 1:2 ..............................388 FIGURA 21-16 – OSCILADOR UTILIZANDO O TIMER 0 NO MPLAB ...........................................................389 FIGURA 21-17 – OSCILADOR UTILIZANDO A INTERRUPÇÃO DO TIMER 0 NO MPLAB ...............................391 FIGURA 21-18 – DIAGRAMA DO TIMER 1 ..................................................................................................392 FIGURA 21-19 – OSCILADOR UTILIZANDO A INTERRUPÇÃO DO TIMER 1 NO MPLAB ...............................394 FIGURA 21-20 – DIAGRAMA DE BLOCOS DO TRANSMISSOR DA USART....................................................397 FIGURA 21-21 – TEMPORIZAÇÃO DA TRANSMISSÃO ASSÍNCRONA DO MESTRE ..........................................397 FIGURA 21-22 – DIAGRAMA DO TIMER 2 ..................................................................................................402 FIGURA 21-23 – SAÍDA PWM ...................................................................................................................405 FIGURA 21-24 – CONEXÃO SPI MESTRE-ESCRAVO ..................................................................................412 FIGURA 21-25 – FORMAS DE ONDA NO MODO SPI MESTRE ......................................................................413 FIGURA 21-26 – FORMAS DE ONDA NO MODO SPI ESCRAVO (MODO DE SELEÇÃO DE ESCRAVO COM CKE = 1........................................................................................................................................................413 FIGURA 21-27 – DIAGRAMA DE BLOCOS DO CONVERSOR A/D DE 8 BITS ..................................................417 FIGURA 21-28 – MODELO DE ENTRADA ANALÓGICA.................................................................................419 FIGURA 21-29 – FUNÇÃO DE TRANSFERÊNCIA DO A/D .............................................................................419 FIGURA 21-30 – CIRCUITO TÍPICO DE APLICAÇÃO ICSP............................................................................420 FIGURA 22-1 – APARÊNCIA DO APPLICATION BUILDER DA INTEL ............................................................422 FIGURA 22-2 – PINAGEM DOS MICROCONTROLADORES 8051, ENCAPSULAMENTO PQFF..........................422 FIGURA 22-3 – PINAGEM DOS MICROCONTROLADORES 8051, ENCAPSULAMENTO PDIP ..........................423 FIGURA 22-4 – PINAGEM DOS MICROCONTROLADORES 8051, ENCAPSULAMENTO PLCC .........................423 FIGURA 22-5 – ARQUITETURA DOS MICROCONTROLADORES 8052............................................................424 FIGURA 22-6 – ORGANIZAÇÃO DA MEMÓRIA DE PROGRAMA DOS MICROCONTROLADORES 8052..............425 FIGURA 22-7 – MEMÓRIA DE DADOS DOS MICROCONTROLADORES 8052..................................................425 FIGURA 22-8 – REGISTRADORES INTERNOS DOS MICROCONTROLADORES 8052........................................426 FIGURA 22-9 – INTERRUPÇÕES DOS MICROCONTROLADORES 8052...........................................................427 FIGURA 22-10 – APARÊNCIA DO SOFTWARE JSIM ....................................................................................428 FIGURA 22-11 – APARÊNCIA DO SOFTWARE JFE.......................................................................................428 FIGURA 22-12 – ADICIONANDO A CHAMADA AO COMPILADOR .................................................................429

FIGURA 22-13 – ADICIONANDO A CHAMADA AO LINKER ..........................................................................429 FIGURA 22-14 – ADICIONANDO A CHAMADA AO JSIM .............................................................................430 FIGURA 22-15 – ADICIONANDO A CHAMADA AO CONVERSOR PARA HEX ................................................430 FIGURA 22-16 – ADICIONANDO A CHAMADA O CONVERSOR PARA BINÁRIO ..............................................431 FIGURA 22-17 – BUFFERS DE I/O E LATCHES DA PORTA P0.......................................................................432 FIGURA 22-18 – DIAGRAMAS DAS PORTAS P1 E P3...................................................................................433 FIGURA 22-19 – DIAGRAMAS DA PORTA P2 ..............................................................................................433 FIGURA 22-20 – OSCILADOR UTILIZANDO O MS VISUAL C++ 5.0 COMO EDITOR .....................................434 FIGURA 22-21 – OSCILADOR CONTROLADO ..............................................................................................435 FIGURA 22-22 – TEMPORIZADOR/CONTADOR 0 NO MODO 0: CONTADOR DE 13 BITS ...............................436 FIGURA 22-23 – TEMPORIZADOR/CONTADOR 0 NO MODO 1 .....................................................................437 FIGURA 22-24 – TEMPORIZADOR/CONTADOR 1 NO MODO 2: CONTADOR DE 8 BITS COM AUTO-RECARGA437 FIGURA 22-25 – TEMPORIZADOR/CONTADOR 0 NO MODO 3: DOIS CONTADORES DE 8 BITS .....................438 FIGURA 22-26 – REGISTRADOR TMOD ....................................................................................................438 FIGURA 22-27 – REGISTRADOR TCON .....................................................................................................439 FIGURA 22-28 – REGISTRADOR IE ............................................................................................................439 FIGURA 22-29 - OSCILADOR UTILIZANDO O TIMER 0 ................................................................................441 FIGURA 22-30 - OSCILADOR UTILIZANDO A INTERRUPÇÃO DO TIMER 0 USANDO O JFE............................443 FIGURA 22-31 – REGISTRADOR SCON .....................................................................................................444 FIGURA 22-32 – REGISTRADOR SCON (CONT.) ........................................................................................444 FIGURA 22-33 – FORMA DE ONDA NO CANAL SERIAL DO 8051..................................................................445 FIGURA 22-34 - TRANSMISSOR SERIAL......................................................................................................449 FIGURA 24-1 - CONECTOR FÊMEA DE 6 PINOS MINI-DIN6 ........................................................................479 FIGURA 24-2 – TECLADO AT - CONECTOR FÊMEA DE 5 PINOS DIN5 (DIN41524) NO COMPUTADOR.......480 FIGURA 24-3 – CONECTOR DA PORTA DE JOYSTICK ..................................................................................480 FIGURA 24-4 - CONECTOR DE 25 PINOS SUB-D MACHO NO DTE (COMPUTADOR)...................................481 FIGURA 24-5 - CONECTOR DE 25 PINOS SUB-D FÊMEA NO DCE (MODEM)..............................................481 FIGURA 24-6 - NO COMPUTADOR, CONECTOR DE 9 PINOS SUB-D MACHO ...............................................482 FIGURA 24-7 – CONECTOR SERIAL RJ-45..................................................................................................483 FIGURA 24-8 - CONECTOR DB9 FÊMEA PARA CONEXÃO COM O PC: .........................................................484 FIGURA 24-9 - CONECTOR DB25 MACHO PARA CONEXÃO COM O CABO SERIAL: ......................................484 FIGURA 24-10 - CONECTOR DB25 NA PORTA PARALELA ..........................................................................484 FIGURA 24-11 - CONECTOR DB25 NA PORTA PARALELA ECP ..................................................................486 FIGURA 24-12 - CONECTOR RGBI ............................................................................................................487 FIGURA 24-13 - CONECTOR RGB ANALÓGICO (VGA, SVGA, VESA) ....................................................487 FIGURA 24-14 – CONECTORES DE REDE BNC, AUI E TP..........................................................................488 FIGURA 24-15 – CONECTOR TP FÊMEA NA PLACA DA INTERFACE ............................................................489 FIGURA 24-16 – CONECTOR TP MACHO NO CABO.....................................................................................489 FIGURA 24-17 – CONECTOR DA PLACA PERIFÉRICA ISA ...........................................................................490 FIGURA 24-18 – CONECTOR ISA NA PLACA MÃE ......................................................................................490 FIGURA 24-19 – CONECTOR DA PLACA PERIFÉRICA EISA.........................................................................492 FIGURA 24-20 – CONECTOR EISA NA PLACA MÃE....................................................................................492 FIGURA 24-21 – CONECTOR IDE MACHO.................................................................................................494 FIGURA 24-22 – CONECTOR IDE FÊMEA ..................................................................................................495 FIGURA 24-23 – CONECTOR PCI ...............................................................................................................496 FIGURA 24-24 – CONECTOR PCI UNIVERSAL 32/64 BITS ..........................................................................496 FIGURA 24-25 – CONECTOR PCI 5 V 32/64 BITS ......................................................................................496 FIGURA 24-26 – CONECTOR PCI 3.3 V 32/64 BITS ...................................................................................496

Índice de Tabelas TABELA 3-1 – SISTEMA BINÁRIO .................................................................................................................19 TABELA 3-2 – EQUIVALÊNCIA ENTRE OS SISTEMAS BINÁRIO E HEXADECIMAL............................................24 TABELA 3-3 - EXEMPLOS DE EXTENSÃO DE SINAL ......................................................................................31 TABELA 3-4 – MAIS EXEMPLOS DE EXTENSÃO DE SINAL .............................................................................31 TABELA 3-5 – SUBGRUPO DE BITS DE CONTROLE ........................................................................................33 TABELA 3-6 – VALORES ASCII DOS DÍGITOS NUMERAIS ............................................................................34 TABELA 3-7 – TABELA ASCII.....................................................................................................................37 TABELA 6-1 – EXEMPLOS DE TRIGRAPHS ....................................................................................................73 TABELA 6-2 – SEQÜÊNCIAS DE ESCAPE .......................................................................................................76 TABELA 7-1– EXEMPLO DE DIRETIVAS DE PRÉ-PROCESSADOR....................................................................82 TABELA 7-2 – TEMPO DE VIDA E ESCOPO ....................................................................................................88 TABELA 8-1 – ESPECIFICADORES DE TIPO .................................................................................................100 TABELA 8-2 – TIPOS DE VARIÁVEIS ..........................................................................................................102 TABELA 8-3 – TIPOS DE DADOS DE UM COMPILADOR PARA PROCESSADORES DA FAMÍLIA 8X86 DE 32 BITS (VISUAL C++ E BORLAND C++ 4.0): ................................................................................................122 TABELA 8-4 – TIPOS DE DADOS DE UM COMPILADOR PARA PROCESSADOR PIC DE 8 BITS CCS PCW: .....122 TABELA 8-5 - TIPOS DE DADOS DE UM COMPILADOR PARA PROCESSADOR DA FAMÍLIA 8051 DE 8 BITS (EX. FRANKLIN, KEIL E ARCHIMEDES): ....................................................................................................122 TABELA 8-6 – TIPOS DE DADOS DE UM COMPILADOR PARA PROCESSADOR DA FAMÍLIA 8X86 DE 16 BITS (EX. BORLAND TURBO C++ 3.X E MICROSOFT C): ...................................................................................122 TABELA 8-7 – CARACTERÍSTICAS DOS TIPOS FLOAT E DOUBLE .................................................................123 TABELA 8-8 - COMPRIMENTO DO EXPOENTE E MANTISSA .........................................................................124 TABELA 8-9 - VALORES MÁXIMOS E MÍNIMOS EM PONTO FLUTUANTE ......................................................124 TABELA 8-10 - CONVERSÕES COM PERDA DE PRECISÃO ............................................................................128 TABELA 9-1 – OPERADORES ARITMÉTICOS ...............................................................................................130 TABELA 9-2 -OPERADORES RELACIONAIS .................................................................................................131 TABELA 9-3 - OPERADORES LÓGICOS .......................................................................................................131 TABELA 9-4 - TABELA VERDADE DOS OPERADORES LÓGICOS E RELACIONAIS ..........................................131 TABELA 9-5 - OPERADORES LÓGICO BIT A BIT ..........................................................................................132 TABELA 9-6 -ABREVIAÇÃO DE EXPRESSÕES .............................................................................................135 TABELA 9-7 - PRECEDÊNCIA DE OPERADORES ..........................................................................................135 TABELA 9-8 - CONVERSÕES DE TIPOS DE DADOS .......................................................................................140 TABELA 9-9 - OPERADORES UNÁRIOS .......................................................................................................141 TABELA 9-10 – OPERADORES BINÁRIOS....................................................................................................141 TABELA 9-11 – OPERADORES POR ORDEM DE PRECEDÊNCIA ....................................................................142 TABELA 9-12 - EXEMPLO DE RELACIONAMENTOS AUTOMÁTICOS .............................................................143 TABELA 9-13 - OPERADORES ARITMÉTICOS UNÁRIOS ...............................................................................151 TABELA 9-14 - OPERADORES DE MULTIPLICAÇÃO, DIVISÃO E RESTO........................................................153 TABELA 9-15 - OPERADORES RELACIONAIS .............................................................................................157 TABELA 9-16 - OPERADORES LÓGICOS ENTRE BITS ...................................................................................158 TABELA 9-17 - OPERADORES LÓGICOS .....................................................................................................159 TABELA 9-18 - OPERADORES DE ATRIBUIÇÃO...........................................................................................161 TABELA 9-19 - CONVERSÕES DE TIPOS INTEIROS COM SINAL ...................................................................164 TABELA 9-20 - CONVERSÕES DE TIPOS INTEIROS SEM SINAL ...................................................................165 TABELA 9-21 - CONVERSÃO DE TIPOS PONTO FLUTUANTE.......................................................................166 TABELA 14-1 – DIRETIVAS DE COMPILAÇÃO ............................................................................................240 TABELA 15-1 - TABELA DE CÓDIGOS DE FORMATOS .................................................................................248 TABELA 15-2 -EXEMPLOS DA FORMATOS DA FUNÇÃO PRINTF ...................................................................248 TABELA 15-3 - EXEMPLOS DA FUNÇÃO PRINTF .........................................................................................248 TABELA 15-4 - ESPECIFICADORES DE FORMATO DE ENTRADA ..................................................................249 TABELA 15-5 -MODOS DE ABERTURA DE ARQUIVOS .................................................................................250 TABELA 17-1 – VETORES DE INTERRUPÇÕES ............................................................................................272 TABELA 17-2 – BITS DE CONFIGURAÇÃO DA IRQ0 A IRQ7 (PIC 1 – ENDEREÇO 0X21) ...........................273

TABELA 17-3 - BITS DE CONFIGURAÇÃO DA IRQ8 A IRQ15 (PIC 2 – ENDEREÇO 0XA1) .........................273 TABELA 17-4 – ENDEREÇOS/REGISTRADORES PARA O PIC1.....................................................................280 TABELA 17-5 – ENDEREÇOS/REGISTRADORES PARA O PIC2.....................................................................280 TABELA 17-6 – ICW1 ...............................................................................................................................281 TABELA 17-7 – ICW2 ...............................................................................................................................281 TABELA 17-8 – ICW3 PARA O PIC MESTRE .............................................................................................281 TABELA 17-9 – ICW3 PARA DISPOSITIVOS ESCRAVOS ..............................................................................281 TABELA 17-10 – ICW4 .............................................................................................................................282 TABELA 17-11 – OCW1 ...........................................................................................................................282 TABELA 17-12 – OCW2 ...........................................................................................................................283 TABELA 17-13 – OCW3 ...........................................................................................................................283 TABELA 18-1 – PINAGEM DO CONECTOR DE PORTA PARALELA, DO TIPO DB-25 ......................................289 TABELA 18-2 – ENDEREÇOS DAS PORTAS PARALELAS ..............................................................................290 TABELA 18-3 – ENDEREÇOS DE MEMÓRIA DAS PORTAS PARALELAS .........................................................291 TABELA 18-4 – REGISTRADOR DADOS DA PORTA PARALELA ....................................................................291 TABELA 18-5 – REGISTRADOR DE STATUS DA PORTA PARALELA ..............................................................292 TABELA 18-6 – REGISTRADOR DE STATUS DA PORTA PARALELA ..............................................................292 TABELA 18-7 - ECR – REGISTRADOR DE CONTROLE ESTENDIDO.............................................................301 TABELA 19-1 – PINAGEM DOS CONECTORES SERIAIS DB25 E DB9...........................................................304 TABELA 19-2 - FUNÇÕES DOS PINOS NUM CANAL SERIAL PADRÃO ..........................................................305 TABELA 19-3 – PINAGEM DA UART 16550A ...........................................................................................309 TABELA 19-4 – ENDEREÇOS PADRONIZADOS DA PORTA SERIAL................................................................310 TABELA 19-5 – ENDEREÇOS DAS PORTAS COM NA ÁREA DE DADOS DA BIOS.........................................311 TABELA 19-6 – REGISTRADORES ASSOCIADOS AO CANAL DE COMUNICAÇÃO SERIAL ...............................311 TABELA 19-7 - TAXAS DE TRANSMISSÃO MAIS COMUNS E OS VALORES DO DIVISOR .................................312 TABELA 19-8 – REGISTRADOR DE HABILITAÇÃO DE INTERRUPÇÕES .........................................................313 TABELA 19-9 – REGISTRADOR DE IDENTIFICAÇÃO DA INTERRUPÇÃO .......................................................314 TABELA 19-10 - REGISTRADOR DE CONTROLE DA FIFO ...........................................................................315 TABELA 19-11 – REGISTRADOR DE CONTROLE DA LINHA DE TRANSMISSÃO .............................................316 TABELA 19-12 – REGISTRADOR DE CONTROLE DO MODEM .......................................................................317 TABELA 19-13 – REGISTRADOR DE STATUS DA LINHA DE COMUNICAÇÃO ................................................318 TABELA 19-14 – REGISTRADOR DE STATUS DO MODEM ............................................................................319 TABELA 19-15 – ARGUMENTO DAS FUNÇÕES BIOSCOM E _BIOS_SERIALCOM ...........................................328 TABELA 19-16 – VALORES DE RETORNO DAS FUNÇÕES BIOSCOM E _BIOS_SERIALCOM ............................328 TABELA 19-17 – SIGNIFICADO DO VALOR DE RETORNO DEPENDENDO DE CMD.........................................329 TABELA 19-18 – VALORES PARA CMD ......................................................................................................329 TABELA 19-19 – VALORES PARA ABYTE...................................................................................................329 TABELA 20-1 – COMPARAÇÃO ENTRE SISTEMAS BALANCEADOS E DESBALANCEADOS .............................336 TABELA 20-2 - ESPECIFICAÇÕES ELÉTRICAS TIA/EIA-232-F...................................................................340 TABELA 20-3 - ESPECIFICAÇÕES ELÉTRICA TIA/EIA-423-B ....................................................................341 TABELA 20-4 - PRINCIPAIS ESPECIFICAÇÕES ELÉTRICAS TIA/EIA-562....................................................342 TABELA 20-5 - - PRINCIPAIS ESPECIFICAÇÕES ELÉTRICAS TIA/EIA-694 .................................................342 TABELA 20-6 - ESPECIFICAÇÕES TIA/EIA-422-B.....................................................................................343 TABELA 20-7 – ESPECIFICAÇÕES ELÉTRICAS DO PADRÃO RS-422 ............................................................345 TABELA 20-8 - ESPECIFICAÇÕES ELÉTRICAS TIA/EIA-485-A ..................................................................346 TABELA 20-9 - CARACTERÍSTICAS ELÉTRICAS DO PADRÃO RS-485.........................................................348 TABELA 20-10 - ESPECIFICAÇÕES ELÉTRICAS TIA/EIA-612 ....................................................................349 TABELA 20-11 - ESPECIFICAÇÕES ELÉTRICAS TIA/EIA-644 LVDS .........................................................349 TABELA 20-12 - REFERENCIA CRUZADA ENTRE A SERIE V E X .................................................................351 TABELA 20-13 - CARACTERÍSTICAS ELÉTRICAS IEEE488.........................................................................353 TABELA 20-14 – COMPARAÇÃO ENTRE AS TÉCNICAS DE PROTEÇÃO .........................................................369 TABELA 21-1 - BIBLIOTECA DE FUNÇÕES .................................................................................................380 TABELA 21-2 – REGISTRADOR OPTION_REG.........................................................................................387 TABELA 21-3 – REGISTRADOR INTCON ..................................................................................................390 TABELA 21-4 – REGISTRADORES ASSOCIADOS AO TIMER 1 ......................................................................392 TABELA 21-5 – REGISTRADOR T1CON ....................................................................................................393 TABELA 21-6 – REGISTRADOR TXSTA ....................................................................................................395 TABELA 21-7 – REGISTRADOR RCSTA ....................................................................................................396 TABELA 21-8 – FORMULA PARA O BAUDRATE ..........................................................................................396 TABELA 21-9 – REGISTRADORES ASSOCIADOS COM O BAUDRATE GENERATOR .......................................397

TABELA 21-10 – REGISTRADORES ASSOCIADOS COM A TRANSMISSÃO ASSÍNCRONA ................................398 TABELA 21-11 – REGISTRADORES ASSOCIADOS COM O TIMER 2 ..............................................................402 TABELA 21-12 – REGISTRADOR T2CON ..................................................................................................402 TABELA 21-13 – MODO CCP – RECURSOS DE TEMPORIZAÇÃO ................................................................403 TABELA 21-14 – NOMENCLATURA CCP ESPECIFICA E GENÉRICA .............................................................403 TABELA 21-15 – REGISTRADOR CCPXCON .............................................................................................404 TABELA 21-16 – REGISTRADOR SSPSTAT...............................................................................................410 TABELA 21-17 – REGISTRADOR SSPCON ................................................................................................411 TABELA 21-18 – REGISTRADORES ASSOCIADOS AO SPI............................................................................414 TABELA 21-19 – REGISTRADOR ADCON0 ...............................................................................................418 TABELA 21-20 – REGISTRADOR ADCON1 ...............................................................................................418 TABELA 23-1 – VALORES PARA O PARÂMETRO BAUDRATE ......................................................................457 TABELA 23-2 – VALORES PARA O PARÂMETRO FDTRCONTROL ................................................................457 TABELA 23-3 – VALORES PARA O PARÂMETRO FRTSCONTROL.................................................................458 TABELA 23-4 – VALORES PARA O PARÂMETRO PARITY ............................................................................459 TABELA 23-5 – VALORES PARA O PARÂMETRO STOPBITS ........................................................................459 TABELA 23-6 – COMPORTAMENTO DAS OPERAÇÕES DE LEITURA BASEADAS NOS VALORES ESPECIFICADOS PARA OS TIMEOUTS TOTAIS E DE INTERVALO .....................................................................................467 TABELA 23-7 – EVENTOS A SEREM MONITORADOS ...................................................................................468 TABELA 23-8 – GETCOMMMODEMSTATUS ..............................................................................................469 TABELA 23-9 – FUNÇÕES DE COMUNICAÇÃO ...........................................................................................469 TABELA 23-10 – ESTRUTURAS DE COMUNICAÇÃO ...................................................................................470 TABELA 24-1 – PS/2 ATX ........................................................................................................................479 TABELA 24-2 – TECLADO AT ...................................................................................................................480 TABELA 24-3 – JOYSTICK .........................................................................................................................480 TABELA 24-4 – CONECTOR SERIAL DB9 ...................................................................................................483 TABELA 24-5 – CONECTOR SERIAL DB9 ...................................................................................................483 TABELA 24-6 – CONVERSOR DB9 PARA DB25 .........................................................................................484 TABELA 24-7 – CONECTOR DB25 DA PORTA PARALELA ...........................................................................485 TABELA 24-8 – CONECTOR DB25 DA PORTA PARALELA ECP...................................................................486 TABELA 24-9 – CONECTOR USB...............................................................................................................486 TABELA 24-10 – PINAGEM DO CONECTOR RGBI......................................................................................487 TABELA 24-11 – PINAGEM DO CONECTOR RGB ANALÓGICO ...................................................................488 TABELA 24-12 – CONECTOR AUI .............................................................................................................488 TABELA 24-13 –CONECTOR BNC .............................................................................................................488 TABELA 24-14 – PINAGEM DO CONECTOR TP...........................................................................................489 TABELA 24-15 – CABOS USADOS NA REDE ................................................................................................489 TABELA 24-16 – CONEXÕES USADAS NOS CABOS .....................................................................................490 TABELA 24-17 – PINAGEM DO CONECTOR ISA .........................................................................................492 TABELA 24-18 – PINAGEM DO CONECTOR EISA.......................................................................................494 TABELA 24-19 – PINAGEM DO CONECTOR IDE .........................................................................................495 TABELA 24-20 – PINAGEM DO CONECTOR PCI .........................................................................................499 TABELA 24-21 – PINAGEM DO CONECTOR PCMCIA.................................................................................501 TABELA 24-22 – PINAGEM DO CONECTOR DE ALIMENTAÇÃO ATX...........................................................501 TABELA 24-23 – PINAGEM DO CONECTOR DE ALIMENTAÇÃO XT/AT .......................................................501 TABELA 24-24 – PINAGEM DO CONECTOR DE ALIMENTAÇÃO 5 ¼.............................................................502 TABELA 24-25 – PINAGEM DO CONECTOR DE ALIMENTAÇÃO 3 ½.............................................................502

1

Capítulo

1. INTRODUCÃO 1.1.

Por que estudar a linguagem C ?

Basicamente todas as linguagens de programação conseguem os mesmos efeitos, algumas de forma mais eficiente que outras, sempre dependendo do tipo de aplicação para o qual será destinada. A linguagem C de programação tem se tornado muito popular, devido à sua versatilidade e ao seu poder. Uma das grandes vantagens do C é a sua característica de "alto nível" e de "baixo nível" ao mesmo tempo, permitindo o controle total da máquina (hardware e software) por parte do programador, permitindo efetuar ações sem depender do sistema operacional utilizado. Em algumas aplicações de engenharia, é necessário manter o controle total do hardware através do software, para efetuar acionamentos e temporizações precisas em tempo real, basicamente sistemas determinísticos. A linguagem C foi projetada para a construção de sistemas operacionais, com o conseqüente controle do hardware. Em aplicações de engenharia, a linguagem C é utilizada freqüentemente para implementar: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19.

Programas executivos e aplicativos em CLPs. Firmware e software aplicativo em coletores de dados. Controle eletrônico em automóveis. Instrumentos inteligentes Gateways de comunicação. Modems. Programadores de FPGAs (alternativa para a linguagem VHDL). Periféricos em geral. Software básico. Interfaces Homem-Máquina Sistemas operacionais. Drivers de comunicação e de dispositivos. Firmware de telefones celulares. Programas do tipo Vírus e antivírus. Firmware em satélites artificiais e veículos espaciais. Processamento digital de sinais Processamento de Imagens Programas de Inteligência Artificial e redes neurais. Modelagem numérica de sistemas físicos para simulação de efeitos dinâmicos em eletromagnetismo, fenômenos de transporte e termodinâmica.

A linguagem C é a indicada em sistemas que envolvem software e hardware, e onde se deseja ter o controle total da máquina digital.

1

1

I N T R O D U Ç Ã O

Alguns engenheiros preferem utilizar a linguagem assembly ainda hoje por conhecimento limitado da linguagem C ou pela falta de espaço de memória disponível, devido à manutenção de projetos de hardware antigos ou mal elaborados. O assembly é a melhor linguagem de programação ?. A resposta é que a eficiência do assembly para sistemas grandes e complexos é muito pobre, além do código não poder ser reutilizado para repetir a aplicação em outros microprocessadores que não o de origem e de ser de difícil depuração. Ante esta resposta, freqüentemente os engenheiros respondem que o código gerado pelo assembly é mais rápido e utiliza menos recursos da máquina, o que otimizaria o seu desempenho. A isto pode ser complementado que a maior rapidez na execução e o menor uso de recursos para efetuar uma tarefa vá depender do programador. A probabilidade de que os programadores, de uma empresa que produz compiladores, consigam obter o código mais eficiente em C do que o nosso próprio, em assembly, é muito maior, já que eles, sem lugar a dúvidas, gastaram muitas horas e dias procurando gerar o código mais eficiente possível. Isto é comparado com a escolha do tipo de câmbio quando a compra de um veículo: Câmbio manual ou automático ? Alguns preferem o manual, dando como desculpa de que é possível a mudança mais rápida das marchas. Mas tem muita gente que não tem a habilidade motora suficiente para efetuar esta tarefa de modo eficiente o tempo inteiro. Obviamente um piloto profissional efetuará as marchas de forma muito mais rápida do que uma pessoa comum.

1.2.

Quando esta linguagem ficará obsoleta ?

Como qualquer ferramenta tecnológica, a linguagem C deverá ficar obsoleta algum dia, mas pode-se antecipar de que isto não ocorrerá até pelo menos o fim da segunda década dos 2000, devido à quantidade enorme de linhas de código produzidas e que normalmente são re-aproveitadas. Por ser uma linguagem extremamente simples, fácil de aprender, clara e objetiva, aplicável à maioria dos problemas de engenharia, esta linguagem provavelmente sobreviverá por mais 30 anos.

1.3.

Breve história da Linguagem C

A linguagem C foi inventada na década de 70. Seu inventor, Dennis Ritchie, implementou-o pela primeira vez usando um DEC PDP-11 rodando o sistema operacional UNIX. A linguagem C é derivada de uma outra: a B, criado por Ken Thompson. O histórico a seguir mostra a evolução das linguagens de programação que certamente influenciaram a linguagem C. • • • • •

Algol 60 – Projetado por um comitê internacional. CPL – Combined Programming Language. Desenvolvida em Cambridge e na Universidade de Londres em 1963. BCPL – Basic Combined Programming Language. Desenvolvida em Cambridge por Martin Richards em 1967. B – Desenvolvida por Ken Thompson, nos Laboratórios Bell em 1970, a partir da linguagem BCPL. C – Desenvolvida por Dennis Ritchie, nos Laboratórios Bell em 1972. Aparece também a figura de Brian Kerningham como colaborador. 2

1

I N T R O D U Ç Ã O

• •

ANSI C – O comitê ANSI (American National Standards Institute) foi reunido com a finalidade de padronizar a linguagem C em 1983. C++ - A linguagem C se torna ponto de concordância entre teóricos do desenvolvimento da teoria de Object Oriented Programming (programação orientada a objetos): surge a linguagem C++ com alternativa para a implementação de grandes sistemas. Esta linguagem consegue interpretar linhas de código escritas em C.

A linguagem Algol apareceu alguns anos depois da linguagem Fortran. Esta era bem sofisticada e sem lugar a dúvidas, influenciou muito o projeto das linguagens de programação que surgiram depois. Seus criadores deram especial atenção à regularidade da sintaxe, estrutura modular e outras características associadas com linguagens estruturadas de alto nível. Os criadores do CPL pretendiam fazer baixar, até a realidade de um computador real, os elevados intentos do Algol. Isto tornou a linguagem de difícil aprendizagem e implementação. Desta surge o BCPL como um aperfeiçoamento da CPL. No início da linguagem B, o seu criador Ken Thompson projetando a linguagem para o sistema UNIX, tenta simplificar a linguagem BCPL. A linguagem B não ficou bem coesiva boa somente para o controle do hardware. Logo após de ter surgido a linguagem B, surge uma nova máquina, o PDP-11. O sistema operacional Unix e o compilador B foram adaptados para esta máquina. A linguagem B começa a ser questionada devido à sua relativa lentidão, por causa do seu desenho interpretativo. Além disto a linguagem B era orientada a palavra enquanto o PDP11 era orientado a byte. Por estas razões começou-se a trabalhar numa linguagem sucessora da B. A criação da linguagem C é atribuída a Dennis Ritchie, que restaurou algumas das generalidades perdidas pela BCPL e B. Isto foi conseguido através do hábil uso dos tipos de dados, enquanto mantinha a simplicidade e o contato com o computador.

3

2

Capítulo

2. OS COMPUTADORES 2.1.

O que são os computadores ?

Não há como controlar os computadores sem conhecer o que são e como funcionam. Os computadores são basicamente máquinas que executam tarefas, tais como cálculos matemáticos e comunicações eletrônicas de informação, sob o controle de um grupo de instruções inserido de antemão, denominado programa. Os programas usualmente residem dentro do computador e são lidos e processados pela eletrônica do sistema que compõe o computador. Os resultados do processamento do programa são enviados a dispositivos eletrônicos de saída, tais como um monitor de vídeo, uma impressora ou um modem. Estas máquinas são utilizadas para efetuar uma ampla variedade de atividades com confiabilidade, exatidão e velocidade.

2.2.

Como os computadores funcionam ?

A parte física do computador é conhecida como hardware. O hardware do computador inclui a memória, que armazena tanto os dados quanto as instruções, a unidade central de processamento (CPU) que executa as instruções armazenadas na memória, o barramento que conecta os vários componentes do computador, os dispositivos de entrada, tais como o mouse ou o teclado, que permitem ao usuário poder comunicar-se com o computador, e os dispositivos de saída, tais como impressoras e monitores de vídeo, que possibilitam a visualização das informações processadas pelo computador. O programa que é executado pelo computador é chamado de software. O software é geralmente projetado para executar alguma tarefa particular, por exemplo, controlar o braço de um robô para a soldagem de um chassis de automóvel ou desenhar um gráfico.

2.3.

Tipos de Computadores

Os computadores podem ser digitais ou analógicos. A palavra digital refere-se aos processos que manipulam números discretos (por exemplo, sistemas binários: 0s e 1s), que podem ser representados por interruptores elétricos que abrem ou fecham (implementados por transistores trabalhando na região de saturação e de corte respectivamente). O termo analógico refere-se a valores numéricos que tem faixa de variação contínua. 0 e 1 são números analógicos, assim como 1.5 ou o valor da constante π. Como exemplo, considere uma lâmpada incandescente que produz luz em um momento e não a produz em outro quando manipulado um interruptor (iluminação digital). Se o interruptor for substituído por um dimmer, então a iluminação ficará analógica uma vez que a intensidade de luz pode variar continuamente entre os estados de ligada e desligada.

4

O S

C O M P U T A D O R E S

Os primeiros computadores eram analógicos mas devido à sensibilidade a perturbações externas e pelas necessidades de serem sistemas confiáveis, foram substituídos por computadores digitais que trabalham com informação codificada de forma discreta. Estes são mais imunes a interferências externas e internas. A natureza dos sinais utilizados na codificação da informação pode ser na forma de campos elétricos gerados por cargas (circuitos que utilizam transistores como chaves), campos eletromagnéticos (computadores que utilizam fótons), fenômenos eletroquímicos (computadores orgânicos), forças hidráulicas, pneumáticas e outros.

2.4.

Software Básico e o Sistema Operacional

Quando um computador é ligado, a primeira coisa que ele faz é a procura de instruções armazenadas na sua memória. Usualmente o primeiro grupo de instruções é um programa especial que permite o inicio da operação. Estas instruções mandam o computador executar um outro programa especial chamado sistema operacional, que é o software que facilita a utilização da máquina por parte do usuário. Ele faz o computador esperar por instruções do usuário (ou de outras máquinas) por comandos de entrada, relata os resultados destes comandos e outras operações, armazenamento e gerenciamento de dados e controla a seqüência das ações do software e do hardware. Quando o usuário requisita a execução de um programa, o sistema operacional o carrega na memória de programa do computador e o instrui para executar o mesmo. Mund o Exterior

Entradas

Microprocessador

CPU Controle e Aritmética

Barramento de Endereços

Memória de Programa

Barramento de Dados

Memória de Dados

Dispositiv os de Saída

Mund o Exterior

Figura 2. Componentes básicos de um sistema computador

5

2

O S

C O M P U T A D O R E S

2.4.1.

A Memória

Para processar a informação eletronicamente, os dados são armazenados no computador na forma de dígitos binários, ou bits, cada um tendo duas possíveis representações (0 ou 1 lógicos). Se adicionarmos um segundo bit a unidade única de informação, o número de representações possíveis é dobrado, resultando em quatro possíveis combinações: 00, 01, 10, 11. Um terceiro bit adicionado a esta representação de dois bits duplica novamente o número de combinações, resultando em oito possibilidades: 000, 001, 010, 011, 100, 101, 110, ou 111. Cada vez que um bit é adicionado, o número possível de combinações é duplicado. Um conjunto de 8 bits é chamado de byte. Cada byte possui 256 possíveis combinações de 0 e 1’s. O byte é uma quantidade freqüentemente utilizada como unidade de informação porque possibilita a representação do alfabeto ocidental completo, incluindo os símbolos das letras em maiúsculas e minúsculas, dígitos numéricos, sinais de pontuação e alguns símbolos gráficos. Como alternativa, o byte poderá representar simplesmente uma quantidade numérica positiva entre 0 e 255. O computador divide o total da memória disponível em dois grupos lógicos, a memória de programa e a memória de dados. A memória física do computador pode ser do tipo RAM (Random Access Memory) que pode ser tanto lida quanto escrita, ROM (Read Only Memory) que somente pode ser lida. Em geral as memórias RAM são voláteis, isto é, são apagadas quando o sistema é desenergizado. Outros tipos de memórias são: PROMs (OTPs), EPROMs, EEPROMs, Flash-EEPROMs, NVRAM que são não voláteis, isto é, os dados permanecem inalterados mesmo depois de desligar o sistema. A Figura 2-1 mostra o processo de gravação da letra ‘A’ (com código ASCII igual a 41H em hexadecimal, 01000001 em binário ou 65 em decimal) na posição de memória número 0. Este chip de memória hipotético, possui 16 posições de memória de 1 byte cada, endereçáveis por 4 bits (24 = 16 posições possíveis). No processo de escrita, a CPU coloca o dado a ser gravado no barramento de endereços, logo coloca o endereço onde os dados serão armazenados, no barramento de endereços, e finalmente indica ao chip que a operação é de escrita ativando o sinal WR (WRITE).

6

2

O S

C O M P U T A D O R E S

1

D0

0

0100 0001

ADD0

0

D1

ADD1

0

0

D2

ADD2

0

0

D3

ADD3

0

0

D4

0

D5

RD

0

1

D6

WR

1

0

D7

Figura 2-1 – Processo de gravação

No processo de leitura a CPU coloca o endereço da posição de memória que deseja ser lida, no barramento de endereços e indica que o processo é de leitura, acionando o pino RD (READ). A memória posteriormente coloca o dado armazenado naquela memória no barramento de dados. Após um certo intervalo de tempo, a CPU faz a leitura desses dados.

2.4.2.

Os Barramentos

O barramento (bus) é usualmente um conjunto paralelo de fios que interconecta os vários dispositivos componentes do hardware do sistema, tais como a CPU e a memória, habilitando e gerenciando a comunicação de dados entre estes. Usualmente existem três tipos de barramentos, o barramento de controle que controla o funcionamento dos componentes do sistema, o barramento de endereços, onde é colocada a informação de origem ou destino para a informação a ser enviada ou recuperada, e o barramento de dados, onde trafegam os dados. O número de linhas componentes do barramento limita a capacidade de endereçamento de memória para o computador. Por exemplo, o 8051 possui 16 linhas de endereços no seu barramento externo, e portanto ele poderá endereçar no máximo 216 = 65536 posições de memória. Já um barramento de 32 bits conseguirá endereçar 232 = 4294967296 posições no máximo.

2.5.

A Unidade Central de Processamento - CPU

A informação originária de um dispositivo de entrada ou da memória é transferida através do barramento para a CPU, sendo esta a unidade que interpreta os comandos e executa os programas. A CPU é um circuito microprocessador, constituído de uma peça única feita em silício e óxidos contendo milhões de componentes eletrônicos numa área muito pequena. A informação é armazenada em posições de memórias especiais colocadas

7

2

O S

C O M P U T A D O R E S

dentro do microprocessador chamadas de Registradores. Estes são pequenas memórias de armazenamento temporário para instruções ou dados. Enquanto um programa estiver sendo executado, existe um registrador especial que armazena o próximo lugar da memória de programa que corresponde à próxima instrução a ser executada; freqüentemente chamado de Contador de Programa1. A unidade de controle situada no microprocessador coordena e temporiza as funções da CPU e recupera a próxima instrução da memória a ser executada. Numa seqüência típica de operação, a CPU localiza a instrução seguinte no dispositivo apropriado da memória. A instrução é transferida por meio do barramento para um registrador especial de instruções dentro da CPU. Depois disto, o contador de programa é incrementado para se preparar para a próxima instrução. A instrução corrente é analisada pelo decodificador, que determina o que esta determina que deve ser feito. Os dados necessários pela instrução serão recuperados através do barramento e colocados em outros registradores da CPU. A CPU então executa a instrução e o resultado é armazenado também em outros registradores especiais ou copiado para lugares específicos da memória. Uma característica importante das CPUs é o tamanho dos dados (em número de bits) que esta pode manipular com uma única instrução. Assim temos atualmente CPUs de 8 bits (ex. PIC16C877, 8051), de 16 bits (ex. 8088, 80286, 80196), 32 bits (80386, 80486, 80586, Pentium) e algumas menos comuns de 64 bits. O tamanho indica por exemplo, que um processador 80486 consegue somar dois números representados com 32 bits utilizando uma instrução de código de máquina, sendo que a mesma operação deverá ser repartida em várias instruções para ser efetuada em uma CPU com um número de bits de menor. A Figura 2-2 mostra um processador 8051FX da Intel com os blocos componentes da pastilha de circuito integrado.

1

Do inglês Program Counter ou simplesmente PC.

8

2

O S

C O M P U T A D O R E S

2

Figura 2-2 – Processador 8051 FX Intel

2.6.

Programas de Computador

Um programa de computador é basicamente uma lista de instruções que este deverá executar. Uma vez que as máquinas digitais só conseguem interpretar informações na forma de sinais elétricos, e que os humanos interpretam na forma de imagens ou sons, é necessária uma ferramenta que implemente uma interface simplificada para a programação. Estas ferramentas são chamadas de linguagens de programação. As linguagens de programação contêm uma série de comandos que formam o software. Em geral, a linguagem que é diretamente codificada em números binários interpretáveis pelo hardware do computador é mais rapidamente entendida e executada. As linguagens que usam palavras e outros comandos que refletem o pensamento lógico humano são mais fáceis de utilizar mas são mais lentas, já que esta deve ser traduzida antes, para que o computador possa interpretá-la. O software de um computador consiste em programas ou lista de instruções que controla a operação da máquina. O termo pode ser referido a todos os programas utilizados com um computador específico ou simplesmente a um único programa. O software é a informação abstrata armazenada como sinais elétricos na memória do computador, em contraste como os componentes de hardware tais como a unidade 9

O S

C O M P U T A D O R E S

central de processamento e os dispositivos de entrada e saída. Estes sinais são decodificados pelo hardware e interpretados como instruções, sendo que cada tipo de instrução guia ou controla o hardware por um breve intervalo de tempo. Uma grande variedade de softwares são utilizados num computador. Uma forma fácil de entender esta variedade é pensar em níveis. O nível mais baixo é o que está mais perto do hardware da máquina. O mais alto está mais perto do operador humano. Os humanos raramente interagem com o computador no nível mais baixo, mas o fazem utilizando tradutores chamados Compiladores. Um compilador é um programa de software cujo propósito é converter programas escritos em uma linguagem de alto nível, numa de baixo nível que possa ser interpretado pelo hardware. Os compiladores eliminam o processo entediante de conversar com um computador na sua própria linguagem binária. Uma camada acima do nível mais baixo, poderá existir um software chamado de Sistema Operacional, que controla o sistema em si. Ele organiza as funções de hardware tais como a leitura e escrita em dispositivos de entrada e saída (teclado, monitor de vídeo, discos magnéticos, etc.), interpretando comandos do usuário e administrando o tempo e os recursos para os programas de aplicação O software de aplicação adapta o computador a um propósito especial tal como o processamento e monitoração de variáveis de controle de uma fábrica ou para efetuar a modelagem de uma parte de uma máquina. As aplicações são escritas em qualquer uma das várias linguagens compiladas que forem mais apropriadas, para a aplicação específica. Estas linguagens, inventadas pelos seres humanos, não podem ser diretamente entendidas pelo hardware do computador. Ela deve ser traduzida por um compilador apropriado que a converta em códigos de zeros e uns que a máquina possa processar. O software é usualmente distribuído em discos magnéticos ou ópticos. Quando o disco é lido pela unidade de leitura apropriada, o software será copiado na memória. Então o sistema operacional do computador passa o controle para a aplicação no processo que ativa o programa. Quando o programa é terminado, o sistema operacional reassume o controle da máquina e espera alguma requisição por parte do usuário.

2.7.

Linguagens de Programação

Como foi visto anteriormente, um programa de computador é um conjunto instruções que representam um algoritmo para a resolução de algum problema. Estas instruções são escritas através de um conjunto de códigos (símbolos e palavras). Este conjunto de códigos possui regras de estruturação lógica e sintática própria. Dizemos que este conjunto de símbolos e regras forma uma linguagem de programação.

2.7.1.

A Linguagem de Máquina

Os programas de computador que podem ser executados por um sistema operacional são freqüentemente chamados de executáveis. Um programa executável é composto de uma seqüência de um grande número de instruções extremamente simples conhecida como código de máquina. Estas instruções são específicas para cada tipo especial de CPU e ao hardware à qual se dedicam (por exemplo, microprocessadores Pentium®, 80486, 8051, PIC16F877, Z80, etc.) e que têm diferentes linguagens de máquina e requerem diferentes grupos de códigos para executar a mesma tarefa. O número de instruções de código de máquina normalmente é pequeno (de 20 a 200 dependendo do 10

2

O S

C O M P U T A D O R E S

computador e da CPU). Instruções típicas são para copiar dados de um lugar da memória e adicionar o conteúdo de dois locais de memória (usualmente registradores internos da CPU). As instruções de código de máquina são informações binárias não compreensíveis facilmente por humanos, e por causa disto as instruções não são usualmente escritas diretamente em código de máquina.

2.7.2.

A Linguagem Assembly

A linguagem Assembly utiliza comandos que são mais fáceis de entender pelos programadores que a linguagem de máquina. Cada instrução da linguagem de máquina tem um comando equivalente na linguagem assembly. Por exemplo, na linguagem assembly, o comando “MOV A,B” instrui ao computador a copiar dados de um lugar para outro. A mesma instrução em linguagem de máquina poderá ser uma cadeia de 8 bits binários ou mais dependendo do tipo de CPU (por exemplo 0011 1101). Uma vez que o programa em assembly é escrito, deve ser convertido em um programa em linguagem de máquina através de um outro programa chamado de Assembler. A linguagem assembly é a mais rápida e poderosa devido a sua correspondência com a linguagem de máquina. É uma linguagem muito difícil de utilizar. Às vezes, instruções em linguagem assembly são inseridas no meio de instruções de alto nível para executar tarefas específicas de hardware ou para acelerar a execução de algumas tarefas.

2.7.3.

Linguagens de Alto-Nível

As linguagens de Alto-Nível foram desenvolvidas devido às dificuldades de programação utilizando linguagens assembly. As linguagens de alto nível são mais fáceis de utilizar que as linguagens de máquina e a assembly, devido a que seus comandos lembram a linguagem natural humana. Ainda que estas linguagens independem da CPU a ser utilizada, contendo comandos gerais que trabalham em diferentes CPUs da mesma forma. Por exemplo, um programador escrevendo na linguagem C para mostrar uma saudação num dispositivo de saída (por exemplo um monitor de vídeo) somente teria que colocar o seguinte comando: printf(“Bom dia, engenheiro !”);

Este comando direcionará a saudação para o dispositivo de saída, e funcionará sem importar que tipo de CPU o computador utiliza. De forma análoga à linguagem assembly, as linguagens de alto nível devem ser traduzidas, e para isto é utilizado um software chamado Compilador. Um compilador transforma um programa escrito numa linguagem de alto nível num programa em código de máquina específico. Por exemplo, um programador pode escrever um programa em uma linguagem de alto nível tal como C e então prepará-lo para ser executado em diferentes máquinas, tais como um supercomputador Cray Y-MP ou simplesmente um PC, usando compiladores projetados para cada uma destas máquinas. Esta característica acelera a tarefa de programação e faz o software mais portável para diferentes usuários e máquinas. A oficial naval e matemática americana, Grace Murray Hopper, ajudou a desenvolver a primeira linguagem de software de alto nível comercialmente disponível, a FLOW-MATIC, em 1957. É creditada a ela a invenção do termo bug, para indicar que o computador apresenta um defeito no funcionamento. Em 1945 ela descobriu uma falha do hardware num computador Mark II ocasionada por um inseto que ficou preso entre os relés eletromecânicos componentes do sistema lógico.

11

2

O S

C O M P U T A D O R E S

Na década de 1950 (1954 a 1958), o cientista de computação Jim Backus da International Business Machines, Inc. (IBM) desenvolveu a linguagem FORTRAN (FORmula TRANslation). Esta permanece até hoje, especialmente no mundo científico, como uma linguagem padrão de programação já que facilitava o processamento de fórmulas matemáticas. Em 1964 foi criada a linguagem BASIC (Beginner’s All-purpose Symbolic Instruction Code), desenvolvida por dois matemáticos: o americano John Kemeny e o húngaro Thomas Kurtz, no Dartmouth College. A linguagem era muito fácil de aprender comparada com as predecessoras e ficou popular devido a sua simplicidade, natureza interativa e a sua inclusão nos computadores pessoais. Diferente de outras linguagens que requerem que todas as suas instruções sejam traduzidas para linguagens de máquina antes de serem executadas, estas são interpretadas, isto é, são convertidas em linguagem de máquina, linha a linha, enquanto o programa está sendo executado. Os comandos em BASIC tipificam a linguagem de alto nível devido a sua simplicidade e semelhança com a linguagem natural humana. Um exemplo de programa que divide um número por dois, pode ser escrito como: 10 INPUT “ENTRE COM O NÚMERO,” X 20 Y=X/2 30 PRINT “A metade do número é ,” Y

Outras linguagens de alto nível em uso hoje em dia incluem C, C++, Ada, Pascal, LISP, Prolog, COBOL, HTML, e Java, entre outras.

2.7.4.

Linguagens Orientadas a Objetos

As linguagens de programação orientada a objetos (OOP – Object Oriented Programming) tais como o C++ são baseadas nas linguagens tradicionais de alto nível, mas elas habilitam ao programador a pensar em termos de coleções de objetos cooperativos no lugar de uma lista de comandos. Os objetos, tais como um círculo, tem propriedades tais como o raio do círculo e o comando que o desenha na tela. Classes de objetos podem ter características inerentes de uma outra classe de objetos. Por exemplo, uma classe que define quadrados pode herdar características tais como ângulos retos de uma classe que define os retângulos. Estes grupos de classes de programação simplificam a tarefa de programação, resultando em programas mais eficientes e confiáveis.

2.7.5.

Algoritmos

Um algoritmo é o procedimento para resolver um problema complexo, utilizando uma seqüência precisa e bem determinada de passos simples e não ambíguos. Tais procedimentos eram utilizados originalmente em cálculos matemáticos e hoje são usados em programas de computador e em projetos de hardware. Usualmente são auxiliados por fluxogramas que são utilizados para facilitar o entendimento da seqüência dos passos. Os fluxogramas representam a seqüência de passos implementada pelo algoritmo, de forma gráfica. A Figura 2-3 mostra o exemplo de um fluxograma.

12

2

O S

C O M P U T A D O R E S

Início

2

Configuração de periféricos

Modo de descarga de dados?

Sim

Descarga dados

Sim

Descarga status

Sim

Apaga dados

Não Modo de descarga de status? Não Modo de apaga? Não Sleep

Figura 2-3 - Exemplo de Fluxograma

2.7.6.

Exemplos de Codificação de Instruções

Existem muitas linguagens de programação. Pode-se escrever um algoritmo para resolução de um problema por intermédio de qualquer linguagem. A seguir são mostrados alguns exemplos de trechos de códigos escritos utilizando algumas linguagens de programação. Exemplo: trecho de um algoritmo escrito numa pseudo-linguagem de alto nível que recebe um número (armazenado na variável num), calcula e mostra os valores múltiplos de 1 a 10 para o mesmo. ler num para n de 1 até 10 passo 1 fazer tab ← num * n imprime tab fim fazer

Exemplo: trecho do mesmo programa escrito em linguagem C: unsigned int num,n,tab; scanf("%d",&num); for(n = 1; n m, usando a extensão de sinal. Desafortunadamente, dado um número de n bits, não pode ser sempre convertido num número de m bits se m < n. Por exemplo, considerar o valor –448. Usando 16 bits a sua representação é 0FE40h. A magnitude deste número é maior da que pode ser comportada num valor de oito bits, de forma que não pode ser contraído em oito bits. Este é um exemplo de uma condição de overflow que pode ocorrer durante a conversão. Para poder contrair apropriadamente um valor em outro, deve ser verificado o(s) byte(s) mais significativo(s) que se desejam descartar. O byte mais significativo que se deseja remover deverá conter 00h ou FFh. Se tiver qualquer outro valor, o número não poderá ser contraído sem efetuar um overflow. Finalmente, o bit mais significativo do valor resultante deve ter o mesmo valor que os que foram removidos do número. Exemplos para números de 16 bits. FF80h pode ser contraído em 80h 0040h pode ser contraído em 40h FE40h não pode ser contraído em 8 bits. 0100h não pode ser contraído em 8 bits.

3.8.

A Codificação ASCII

ASCII são as siglas para American Standard Code for Information Interchange. É um código que designa valores numéricos às letras, números, sinais de pontuação e outros símbolos especiais. Este padrão foi criado para organizar e compatibilizar a troca de informação entre vários computadores e sistemas. O ASCII define 256 códigos divididos em dois conjuntos, o padrão e o estendido, com 128 códigos cada. Estes grupos representam o total de representações possíveis de 8 bits (1 byte). O conjunto básico ou padrão, utiliza 7 bits para cada código, usando do código 0 até o 127 (00h a 7Fh), sendo que o conjunto estendido utiliza os códigos de 128 a 255 (80h a FFh). No conjunto padrão, os primeiros 32 caracteres são designados para os códigos de comunicação e controle de impressão (basicamente caracteres não imprimíveis), tais como retorno de posição, retorno de carro, nova linha e tabulação, que são utilizados para controlar a forma com que a informação é transferida de um computador para outro sistema. Os 96 códigos remanescentes são designados aos sinais de pontuação, os dígitos 0 ao 9, e as letras maiúsculas e minúsculas do alfabeto romano. O conjunto estendido de códigos é designado para grupos variáveis de caracteres para serem usados pelos fabricantes de computadores e engenheiros de software. Estes códigos não são intercambiáveis entre diferentes programas de computador como o conjunto padrão de caracteres ASCII.

3.8.1.

O Grupo Padrão de Caracteres

O grupo padrão de caracteres pode ser dividido em quatro subgrupos de 32 caracteres. Os primeiros 32 caracteres (código 00h a 1Fh) formam um grupo especial de caracteres não imprimíveis chamados caracteres de controle, porque executam várias funções de controle de impressão. Desafortunadamente, os caracteres de controle

32

3

C O D I F I C A Ç Ã O

D A

I N F O R M A Ç Ã O

executam diferentes operações em dispositivos diferentes de saída de dados. Existe uma padronização muito fraca nos dispositivos de saída em geral. O segundo subgrupo consiste em vários símbolos de pontuação, caracteres especiais e dígitos numéricos. Os caracteres mais notáveis deste grupo incluem o caractere “espaço” (código 20h) e os dígitos numéricos (códigos 30h a 39h). Deve ser notado que os dígitos numéricos diferem dos seus valores numéricos somente no nibble mais significativo. Subtraindo 30h do código em ASCII, pode ser obtido o equivalente numérico para aquele dígito. O terceiro subgrupo de 32 caracteres é reservado para os símbolos das letras maiúsculas do alfabeto. Os códigos ASCII para os caracteres de ‘A’ a ‘Z’ ficam na faixa de 41h a 5Ah. Como existem somente 26 caracteres alfabéticos definidos, os seis códigos remanescentes servem para representar outros símbolos especiais. O quarto e último subgrupo de 32 caracteres é reservado para os símbolos das letras minúsculas do alfabeto, cinco símbolos especiais e um outro caractere de controle (delete). Notar que os símbolos dos caracteres minúsculos usam os códigos 61h a 7Ah. Convertendo os códigos para os caracteres maiúsculos e minúsculos, pode ser notado que a diferença entre ambos tipos diferem da posição de somente um bit. Por exemplo, considerar o código para as letras ‘E’ (45h) e ‘e’ (65h) ‘E’:

0100 0101

‘e’:

0110 0101

Ambos códigos diferem somente no bit cinco. Os caracteres em maiúsculas sempre contêm um “0” no bit número cinco e os caracteres em minúsculas, em um. Esta característica pode ser facilmente usada para converter rapidamente maiúsculas em minúsculas e vice-versa. Tendo um caractere em maiúsculas pode ser forcado para minúsculas setando o bit número cinco. Estas tarefas são facilmente executadas utilizando as funções lógicas vistas nas seções anteriores. Em resumo, os bits número cinco e seis determinam o subgrupo: Bit 6 0 0 1 1

Bit 5 0 1 0 1

Subgrupo Caracteres de Controle Dígitos e Pontuação Maiúsculas e especiais Minúsculas & especiais

Tabela 3-5 – Subgrupo de bits de controle

Desta maneira, podem ser convertidos quaisquer caracteres maiúsculos ou minúsculos nos seus equivalentes caracteres de controle resetando os bits número cinco e seis. Considere no momento, os códigos ASCII para os dígitos numéricos: "0" "1" "2" "3" "4" "5" "6" "7"

48 49 50 51 52 53 54 55

33

30h 31h 32h 33h 34h 35h 36h 37h

3

C O D I F I C A Ç Ã O

D A

I N F O R M A Ç Ã O

"8" 56 38h "9" 57 39h Char Dec Hex Tabela 3-6 – Valores ASCII dos dígitos numerais

A representação decimal destes códigos não é muito clara em relação ao símbolo que representam. A representação hexadecimal deste código ASCII revela algumas características importantes como que o nibble menos significativo do código é equivalente ao valor do número representado. Desta forma, resetando para zero o nibble menos significativo do código numérico do caractere numérico, pode ser convertido no seu significado em binário correspondente. De forma análoga, pode ser convertido um valor numérico binário na sua representação em código ASCII simplesmente setando para “1” os dois primeiros bits do nibble mais significativo. Notar que pode ser utilizado um operador lógico AND para forçar os bits mais significativos para zero, ou OR para forçá-los para um. Deve ser notado que não é possível converter uma cadeia (string) de caracteres numéricos para a sua representação equivalente em binário simplesmente ajustando o nibble mais significativo para cada dígito da string. Se for convertido o número 123 (31h 32h 33h) desta forma obteremos três bytes: 010203h, diferente do valor correto, que deveria ser 7Bh. A conversão de cadeias de dígitos em números inteiros, requer maior sofisticação, sendo que a conversão sugerida anteriormente funciona somente com dígitos isolados. Embora é dado o nome de padrão ASCII, o simples uso desta codificação não garante a compatibilidade entre sistemas. Enquanto é verdade que a letra ‘A’ numa máquina é freqüentemente uma ‘A’ na outra máquina, não existe uma verdadeira padronização entre máquinas com respeito aos caracteres de controle. Do total de 32 caracteres de controle mais o “delete”, existem somente quatro códigos de controle comumente suportados: o retorno de cursor (backspace - BS), a tabulação, retorno de carro (CR) e nova linha (LF). O que é pior, diferentes máquinas freqüentemente utilizam estes códigos de controle de formas diferentes. O fim de linha é um exemplo particularmente problemático. Enquanto os sistemas MS-DOS, CP/M e outros sistemas marcam o final de uma linha com uma seqüência de dois caracteres (CR e LF), os sistemas Apple Macintosh, Apple II e outros marcam o final de linha com um único caractere (CR). Os sistemas UNIX marcam o final de uma linha com um único caractere LF. Não é necessário dizer que tentando intercambiar simples arquivos de texto entre estes sistemas pode ser frustrante. Se forem utilizados os caracteres padrão ASCII em todos seus arquivos, será necessário converter os dados para intercambiar dados com um outro que não tem o mesmo padrão. Felizmente tal conversão é bastante simples. Outro tipo de formato que pode ser usado é o formato ANSI. Ambos os sistemas, ASCII e ANSI, foram desenvolvidos para padronizar a comunicação entre computadores. Os países cujo idioma não é o inglês, têm desenvolvido outros métodos de codificação. É interessante considerar outros idiomas, tais como o japonês, o chinês e o coreano, que possuem mais caracteres que os do alfabeto inglês. Este problema requer um sistema de codificação diferente do ASCII com seus 127 caracteres ou o ANSI com seus 256 caracteres. Os japoneses por exemplo usam a codificação EUC, JIS, S-JIS, and JASCII para manipular caracteres. A internacionalização tenta definir um padrão para todos os

34

3

C O D I F I C A Ç Ã O

D A

I N F O R M A Ç Ã O

códigos de caracteres num padrão universal. chamado UNICODE.

Um destes esquemas de codificação é

A seguir é apresentada a tabela de códigos ASCII padrão. Character Name Null Start of Heading Start of Text End of Text End of Transmit Enquiry Acknowledge Bell Back Space Horizontal Tab Line Feed Vertical Tab Form Feed Carriage Return Shift Out Shift In Data Line Escape Device Control 1 Device Control 2 Device Control 3 Device Control 4 Negative Acknowledge Synchronous Idle End of Transmit Block Cancel End of Medium Substitute Escape File Separator Group Separator Record Separator Unit Separator Space Exclamation Point Double Quote Pound/Number Sign Dollar Sign Percent Sign Ampersand Single Quote Left Parenthesis Right Parenthesis Asterisk Plus Sign Comma Hyphen / Minus Sign Period Forward Slash Zero Digit One Digit Two Digit

Char NUL SOH STX ETX EOT ENQ ACK BEL BS TAB LF VT FF CR SO SI DLE DC1 DC2 DC3 DC4

Code Ctrl @ Ctrl A Ctrl B Ctrl C Ctrl D Ctrl E Ctrl F Ctrl G Ctrl H Ctrl I Ctrl J Ctrl K Ctrl L Ctrl M Ctrl N Ctrl O Ctrl P Ctrl Q Ctrl R Ctrl S Ctrl T

Decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Binary 00000000 00000001 00000010 00000011 00000100 00000101 00000110 00000111 00001000 00001001 00001010 00001011 00001100 00001101 00001110 00001111 00010000 00010001 00010010 00010011 00010100

NAK

Ctrl U

21

00010101 15

SYN

Ctrl V

22

00010110 16

ETB

Ctrl W

23

00010111 17

CAN EM SUB ESC FS GS RS US

Ctrl Ctrl Ctrl Ctrl Ctrl Ctrl Ctrl Ctrl

! " # $ % & ‘ ( ) * + , . / 0 1 2

Shift Shift Shift Shift Shift Shift ‘ Shift Shift Shift Shift , . / 0 1 2

35

X Y Z [ \ ] ^ _

24 25 26 27 28 29 30 31 32 1 33 ‘ 34 3 35 4 36 5 37 7 38 39 9 40 0 41 8 42 = 43 44 45 46 47 48 49 50

00011000 00011001 00011010 00011011 00011100 00011101 00011110 00011111 00100000 00100001 00100010 00100011 00100100 00100101 00100110 00100111 00101000 00101001 00101010 00101011 00101100 00101101 00101110 00101111 00110000 00110001 00110010

Hex 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14

18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32

3

C O D I F I C A Ç Ã O

D A

I N F O R M A Ç Ã O

Three Digit Four Digit Five Digit Six Digit Seven Digit Eight Digit Nine Digit Colon Semicolon Less-Than Sign Equals Sign Greater-Than Sign Question Mark At Sign Capital A Capital B Capital C Capital D Capital E Capital F Capital G Capital H Capital I Capital J Capital K Capital L Capital M Capital N Capital O Capital P Capital Q Capital R Capital S Capital T Capital U Capital V Capital W Capital X Capital Y Capital Z Left Bracket Backward Slash Right Bracket Caret Underscore Back Quote Lower-case A Lower-case B Lower-case C Lower-case D Lower-case E Lower-case F Lower-case G Lower-case H Lower-case I Lower-case J Lower-case K Lower-case L Lower-case M

3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h I j k l m

3 4 5 6 7 8 9 Shift ; Shift = Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift Shift [ \ ] Shift Shift ` A B C D E F G H I J K L M

36

51 52 53 54 55 56 57 ; 58 59 , 60 61 . 62 / 63 2 64 A 65 B 66 C 67 D 68 E 69 F 70 G 71 H 72 I 73 J 74 K 75 L 76 M 77 N 78 O 79 P 80 Q 81 R 82 S 83 T 84 U 85 V 86 W 87 X 88 Y 89 Z 90 91 92 93 6 94 - 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

00110011 00110100 00110101 00110110 00110111 00111000 00111001 00111010 00111011 00111100 00111101 00111110 00111111 01000000 01000001 01000010 01000011 01000100 01000101 01000110 01000111 01001000 01001001 01001010 01001011 01001100 01001101 01001110 01001111 01010000 01010001 01010010 01010011 01010100 01010101 01010110 01010111 01011000 01011001 01011010 01011011 01011100 01011101 01011110 01011111 01100000 01100001 01100010 01100011 01100100 01100101 01100110 01100111 01101000 01101001 01101010 01101011 01101100 01101101

33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D

3

C O D I F I C A Ç Ã O

D A

I N F O R M A Ç Ã O

Lower-case N Lower-case O Lower-case P Lower-case Q Lower-case R Lower-case S Lower-case T Lower-case U Lower-case V Lower-case W Lower-case X Lower-case Y Lower-case Z Left Brace Vertical Bar Right Brace Tilde Delta

n o p q r s t u v w x y z { | } ~ ∆

N O P Q R S T U V W X Y Z Shift Shift Shift Shift

[ \ ] `

110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

Tabela 3-7 – Tabela ASCII

37

01101110 01101111 01110000 01110001 01110010 01110011 01110100 01110101 01110110 01110111 01111000 01111001 01111010 01111011 01111100 01111101 01111110 01111111

6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F

3

4

Capítulo

4. PROJETO DE SISTEMAS DE SOFTWARE

Normalmente, o projeto de um sistema não envolve somente os passos da programação e o código fonte, mas uma série de etapas importantes que devem ser levadas em conta antes de começar o projeto. Qualquer projeto pode ser dividido quatro etapas principais, uma etapa de especificação do sistema (software e hardware), uma etapa de implementação, uma etapa de depuração e uma etapa de validação. Todo projeto começa com uma especificação escrita e detalhada de todo os sistema desejado, usualmente chamado de Especificação de Sistema. Nele deverão estar descritos da forma mais detalhada possível todos as características de hardware desejadas, as funções do software, os protocolos de comunicação a serem utilizados e os cronogramas completos, entre outros detalhes. Qualquer detalhe omitido ou esquecido nesta etapa pode inutilizar o projeto todo. A etapa de especificação é a mais importante do projeto e deve ser alocado o tempo suficiente para ela. É comum que projetos de software de grande porte tenham a metade do tempo de projeto alocado somente para a especificação. Na etapa de implementação são construídos e definidos os algoritmos de software1 durante a especificação. A etapa de depuração serve para a detecção e correção de erros que aconteceram nas interfaces entre as sub-etapas do projeto. A etapa de validação serve para avaliar os objetivos alcançados em relação aos propostos na etapa de especificação, e a de encontrar problemas não detectados nas etapas anteriores. Usualmente devido a validação deverá ser executada novamente uma etapa de depuração para correção de erros e melhorias de funcionamento, cujos resultados deverão ser validados novamente. As etapas mencionadas mais acima possuem uma sub-etapa de documentação que normalmente é executada em paralelo, e que incluem, descrições de software e hardware, relatórios de validação, lista de erros e melhorias a serem efetuadas, etc.. Os projetos de engenharia eletrônica, normalmente devem ser projetados os sistemas de hardware e de software. Nos projetos de grandes sistemas há uma necessidade de estilo, abstração e formalismo.

1

Os conceitos desenvolvidos neste capítulo, também se aplicam a projetos de hardware.

38

P R O J E T O

D E

4.1.

4.1.1.

S I S T E M A S

Top Down

Estilo

A mente humana precisa de ajuda quando efetua tarefas grandes ou complexas. O estilo é o método de particionar um problema grande em sub-unidades manipuláveis de uma forma sistemática e inteligível. A necessidade de ter-se um bom estilo fica mais aparente quando o problema é maior. Os programas de computador são um dos grandes tipos de projetos complexos implementados pelo homem, alguns deles excedendo 5000000 de linhas de código, sendo estes tão grandes que nenhuma pessoa pode acompanhar o programa completo, e nem uma parte significativa do mesmo. O estudo do estilo de programação tem forçado aos projetistas a encarar o particionamento do problema em uma arte, como sendo um caminho para ganhar controle sobre os seus projetos. O estilo em programação pode ser definido por um grupo de técnicas chamadas de “top-down” e “estruturada”. O hardware de grandes computadores envolve uma complexidade que fica na mesma escala daqueles programas gigantes. Podemos citar algumas regras para obter um bom estilo em projetos de sistemas: Projete de cima para baixo (top for down): O projeto começa com a especificação do sistema completo de forma suficientemente compacta para que uma pessoa possa rapidamente compreende-la. O projeto procede pelo seccionamento do sistema em subsistemas e subunidades com as suas inter-relações bem definidas. Depois disto, cada subsistema poderá ser descrito em detalhes mantendo a capacidade de compreender os detalhes da unidade e do sistema como um todo. Este processo continua até o sistema ter sido especificado completamente e no detalhe, podendo prosseguir com a elaboração do cronograma. Sempre se devem utilizar técnicas que mantenham o projetista no caminho correto, dentro do processo da implementação (técnicas foolproof). O hardware permite um alto grau de flexibilidade no projeto. Esta excessiva flexibilidade permite aos projetistas de utilizar circuitos complexos e inusuais. O uso incontrolado desta flexibilidade promove a implementação de forma indisciplinada, não-inteligente e incorreta. Este fenômeno tem a contrapartida (de forma menos severa) em software de computadores, onde a linguagem assembly permite o acesso a todo o poder do computador. A experiência na solução de problemas de software e hardware tem mostrado que se deve restringir as ferramentas e técnicas de projeto nas que mostram uma capacidade funcional e interpretativa, sobre uma variedade de circunstâncias. Usar técnicas de documentação para o nível de sistema e para nível dos circuitos ou rotinas de software (descrições de software e hardware) que mostrem claramente o que o projetistas estava pensando quando o problema foi primeiramente abstraído para uma solução abstrata e depois para uma solução de software e hardware. A violação deste preceito atua contra o princípio da “cortesia comum”. Durante a documentação o projetista deve-se colocar no lugar do usuário ou mantenedor do seu projeto, mantendo uma documentação clara e completa.

4.1.2.

Abstração

Neste contexto, a abstração permite encarar o problema num nível conceptual. O conceito de memória é um exemplo de abstração. Quando o projeto começar é necessário encará-lo com elementos conceituais a as suas inter-relações. Somente mais tarde, durante o processo de implementação será necessário trabalhar com conceitos reais. Esta liberdade é absolutamente essencial para um começo apropriado de um projeto de complexidade considerável. Começa-se de cima e continua-se reduzindo o problema, até seus elementos conceituais básicos. Por exemplo um computador precisará de uma memória, um sistema de entrada e saída, uma unidade aritmética e outros subsistemas.

39

4

P R O J E T O

D E

S I S T E M A S

Comumente começa-se o projeto neste nível de abstração, e prossegue-se descendo a níveis inferiores, um por um, sempre no ponto de vista conceitual. Desta forma, no próximo nível será desenhado um diagrama de blocos de uma unidade aritmética, pela interconexão das suas unidades funcionais, tais como registradores, unidades de controle, e barramento de dados. A abstração inicial é a parte crítica de qualquer projeto, desde que planejamento errado nas fases iniciais do mesmo levará inevitavelmente a implementações erradas. Normalmente não há forma de resgatar um projeto mal planejado utilizando circuitos exóticos ou rotinas de ajuste.

4.1.3.

Formalismo

O formalismo é a teoria do comportamento do sistema. Em um projeto, o formalismo ajuda a estabelecer regras e procedimentos sistemáticos com características conhecidas. Os formalismos são importantes em todos os níveis do projeto. Os formalismos de alto nível não são de grande importância para o bom desenvolvimento do projeto e servem somente para adotar métodos sistemáticos em todos os níveis onde se espera a transformação correta dos conceitos em hardware ou software. No nível de implementação, o formalismo é extremamente necessário e deve ser rígido o suficiente para evitar erros na implementação. Duas naves espaciais destinadas a cartografar o planeta Marte, foram perdidas no espaço em 1999 porque alguns dos algoritmos projetados, utilizavam unidades do sistema inglês enquanto que outros utilizavam unidades no sistema internacional. Como o erro era muito pequeno para ser detectado nos auto-testes, resultaram no exemplo de um dos erros de formalismo mais caros da história.

4.1.4.

O Projeto em Top-Down

O projeto começa com o estudo cuidadoso do problema geral. Deliberadamente devem ser ignorados os detalhes neste estágio, e devem ser feitas perguntas como: O problema está claramente definido ? É possível remodelar o problema para obter mais clareza ou simplificá-lo ? Se estivesse trabalhando com um subsistema de um sistema maior; quais são as relações com o subsistema de hierarquia maior ?. Poderá um particionamento diferente do sistema inteiro simplificar a estrutura ?

Neste estágio o entendimento é global e se deve permanecer neste nível até ter esmiuçado sensivelmente e digerido o problema, até o ponto onde haja o convencimento de que este pode ser resolvido. Isto é essencial, desde que qualquer dificuldade neste nível é seria e pode ser insolúvel. Após ter especificado claramente o problema no nível global, procede-se ao particionamento racional do problema em pequenas peças com inter-relações claramente definidas. O objetivo é de escolher as peças “naturais” de tal forma que cada peça possa ser compreendida como uma unidade e sejam bem compreendidas as interações entre as unidades. Este processo de particionamento continua para níveis inferiores, até a escolha final das funções a serem utilizadas, circuitos integrados a serem empregados, etc..

40

4

P R O J E T O

4.2.

D E

S I S T E M A S

Algoritmos

Nas ciências matemáticas, um algoritmo é um método de resolver um problema pelo uso repetitivo de métodos computacionais simples. Um exemplo básico é o processo da divisão de números grandes. O termo algoritmo hoje em dia é aplicado para vários tipo de soluções de problemas que empregam uma seqüência mecânica de passos, como nos programas de computador. A seqüência pode ser representada na forma de um diagrama de fluxo ou fluxograma para facilitar o entendimento da seqüência. Assim como os algoritmos utilizados na aritmética, os algoritmos para computadores podem ser simples ou altamente complexos. Em todos os casos, a tarefa que o algoritmo vai desempenhar deve ser bem definida. Isto é, as definições podem envolver termos matemáticos ou lógicos ou um conjunto de dados ou instruções escritas, mas a tarefa em si deve ser de tal forma que possa ser representada de uma maneira. Em dispositivos tais como computadores, a lógica é a forma de algoritmo. Como os computadores aumentam em complexidade, mais e mais algoritmos de programas de software tomam a forma do que é chamado de “hard software”. Isto é, há um aumento da parte básica do circuito elétrico dos computadores que facilitam a inserção de lógicas em hardware. Muitos algoritmos de aplicação diferentes estão disponíveis, e sistemas altamente avançados tais como algoritmos de inteligência artificial ficarão muito comuns num futuro próximo.

4.3.

Fluxogramas

Um fluxograma [4] ou diagrama de fluxo, é um diagrama seqüencial empregado em várias áreas da tecnologia para mostrar os procedimentos, passo a passo, que devem ser executados para a implementação de uma certa tarefa ou para a geração de um produto; por exemplo, para descrever processos em manufaturas, ou para resolver um determinado problema, em algoritmos. Um fluxograma é basicamente a representação gráfica por meio de símbolos geométricos, da solução algorítmica de um problema. Os fluxogramas são compostos de blocos ou caixas, conectadas por setas. Para descrever o processo descrito em um diagrama de fluxo, começa-se pelo bloco inicial e segue-se de bloco em bloco seguindo as setas e executando as ações indicadas. A forma de cada bloco indica o tipo de ação que esta representa, tais como processamento, tomadas de decisão e controle. Os blocos de processo indicam a execução de uma determinada ação.

Processo 1

Figura 4-1 – Bloco de processo

41

4

P R O J E T O

D E

S I S T E M A S

As caixas de decisões indicam o caminho a ser tomado de acordo com uma condição.

Condição

Falsa

Verdadeira Figura 4-2 – Bloco de tomada de decisão

Os blocos mais as setas de conexão, são suficientes para representar qualquer diagrama de fluxo. Existem outros tipos de blocos que especificam tipos de processos específicos, mas que não são imprescindíveis. Inicio

Processo 1

Condição

Falsa

Processo 2

Verdadeira

Processo 3

Fim

Figura 4-3 – Fluxograma Genérico

4.4.

Componentes Básicos de um Programa

Um programa de computador é baseado no fluxograma do algoritmo e implementa a solução de software para o problema. itens::

Um programa em qualquer linguagem normalmente é composto pelos seguintes

42

4

P R O J E T O

D E

S I S T E M A S

Os programas devem obter informação de alguma fonte de entrada. Os programadores devem decidir a forma em que os dados de entradas serão armazenados e dispostos. Os programas devem utilizar uma série de instruções para manipular as entradas. Estas instruções são do tipo simples, condicionais, laços e funções ou sub-rotinas. Os programas devem apresentar os resultados da manipulação dos dados das entradas. Uma aplicação correta incorpora os fundamentos acima listados, expressos através da utilização de um projeto modular incluindo uma especificação completa, uma codificação devidamente documentada e um esquema de apresentação apropriado.

4.5.

Procedimento Geral

Um programa codificado usando uma linguagem de programação, deverá ser transformado no seu equivalente em código de máquina. Dependendo da forma com que isto é feito, existe uma classificação em linguagens compiladas e interpretadas. Nas linguagens interpretadas, cada linha de programa é interpretada e posteriormente executada durante a execução do programa, por meio de um software chamado interpretador. Um exemplo deste tipo de linguagem é o BASIC. As linguagens compiladas são transformadas em equivalentes de linguagem de máquina, antes da execução. Exemplo deste tipo de linguagens são a linguagem C e Pascal. As linguagens compiladas são executadas mais rapidamente do que suas equivalentes interpretadas, com a desvantagem de que as compiladas não possuem verificação de erros em tempo de execução. O primeiro passo no processo de construção de um programa é a criação dos arquivos de código fonte, com as instruções desejadas[2]. Após isto deve ser invocado o Compilador que antes de efetuar a compilação executa um outro programa chamado Préprocessador que criará a entrada para o compilador. O compilador então efetua a checagem da sintaxe e cria um arquivo objeto que contém código de máquina, diretivas de ligação, seções, referências externas, nome de funções e de dados gerados a partir do código fonte. Finalmente o Linker combina o código objeto com as bibliotecas estáticas utilizadas e outros códigos objeto, define os recursos necessários e cria um arquivo executável. Tipicamente, um arquivo de construção chamado makefile coordena a combinação dos elementos e ferramentas necessárias para a criação do arquivo executável.

4.5.1.

Compilação

O compilador é um tipo de software projetado para traduzir os programas escritos em linguagem de alto nível em instruções de linguagem de máquina elementares para um tipo de computador em particular. Uma linguagem de alto nível particular pode ser utilizada por muitos tipos de computadores independendo do hardware. Por outro lado, os compiladores são projetados para operar num tipo de máquina em particular sendo dependente do hardware. Os compiladores são basicamente programas de computador capazes de transformar um grupo de símbolos em outro diferente segundo um grupo de regras sintáticas e semânticas bem definidas. Os compiladores dedicados a microcontroladores, e que são executados em computadores pessoais, são freqüentemente chamados de “Cross Compilers”. A Figura 4-4 mostra o procedimento para a geração de um programa executável.

43

4

P R O J E T O

D E

S I S T E M A S

Editor

Arquivo Fonte (hello.c)

Makefile

Arquivos de Cabeçalho (stdio.h)

4

Pré-Processador

Compilador

Arquivo Objeto (hello.obj)

Outros Arquivos Objeto (*.obj)

Linker (hello.obj)

Bibliotecas (*.lib)

Arquivo Executável (hello.exe)

Figura 4-4 – Procedimento de geração de um programa executável

44

5

Capítulo

5. FUNDAMENTOS DA LINGUAGEM C Neste capítulo serão vistos os fundamentos da linguagem C. O conceito de linguagem de programação, linguagens de alto e baixo nível, linguagens genéricas e especificas. Será visto um pouco do histórico da criação da linguagem e a descrição das características mais importantes da linguagem C. Finalmente, será visto o aspecto geral de um código fonte escrito em C. No Apêndice G - pode ser visto um exemplo de utilização de alguns compiladores tradicionais.

5.1.

Características da Linguagem C

Entre as principais características da linguagem C, pode-se citar: É uma linguagem de alto nível de sintaxe estruturada e flexível, tornando sua programação bastante simplificada. Os programas em C são compilados, gerando programas executáveis depois de montados (linker). A linguagem C compartilha recursos de alto e de baixo nível, pois permite acesso e programação direta do hardware do computador. Assim, as rotinas cuja dependência de tempo seja crítica, podem ser facilmente implementadas usando instruções em Assembly. Por esta razão a linguagem C, é a preferida dos engenheiros programadores de aplicativos. O C é uma linguagem estruturalmente simples e portável. O compilador C gera códigos menores e mais velozes do que outras linguagens de programação. Embora estruturalmente simples (poucas funções intrínsecas) a linguagem C não perde funcionalidade pois permite a inclusão de uma farta quantidade de rotinas do usuário. Os fabricantes de compiladores fornecem uma ampla variedade de rotinas pré-compiladas em bibliotecas.

5.2.

Pontos Positivos da Linguagem

Tamanho Pequeno: A linguagem C possui poucas regras de sintaxe, quando comparada com outras linguagens. Um compilador C pode ser implementado com apenas 256 KB de memória. Poucos Comandos: A linguagem C é extremamente pequena. O número total de palavras-chave é de 43. Isto faz dela uma linguagem extremamente simples de aprender. Velocidade: A combinação de uma linguagem pequena com regras de sintaxe simples, a falta de verificação durante a execução e uma linguagem parecida com o assembly faz que o código gerado seja executado em velocidades próximas do assembler. Linguagem Estruturada: Contém todas as estruturas de controle utilizadas nas linguagens de programação mais modernas. Têm recursos de escopo utilizando variáveis locais. 45

F U N D A M E N T O S

D A

L I N G U A G E M

C

Não Fortemente Figurada: Os dados são tratados de maneira muito flexível, o que permite uma grande versatilidade. Suporte de Programação Modular: Suporta a compilação e montagem (linker) separadas, o que permite re-compilar somente as partes de um programa que tenham sido alteradas durante o desenvolvimento. Manipulação de Bits: Uma vez que a linguagem foi criada para a implementação de sistemas operacionais, esta linguagem foi dotada de uma vasta série de operadores para a manipulação direta de bits. Interface para Rotinas em Assembly: Suporta a inclusão de rotinas em assembly diretamente no mesmo código fonte em C. Variáveis Ponteiros: Um sistema operacional deve ser capaz de endereçar áreas específicas da memória ou dispositivos de I/O. A linguagem C utiliza variáveis ponteiro permitindo manipulá-los aritmeticamente. Uma variável ponteiro guarda no seu conteúdo uma informação de endereço da informação. Estruturas Flexíveis: Os arranjos de dados são unidimensionais. Os arranjos multidimensionais são construídos a partir de arranjos unidimensionais. Bibliotecas de Funções: Existem vastas bibliotecas de funções prontas que podem ser anexadas aos executáveis durante a montagem (linker). Uso Eficiente da Memória: Os programas em C tendem a ser mais eficientes em termos de memória devido à falta de funções embutidas que não são necessárias à aplicação. Portabilidade: A portabilidade indica a facilidade de se converter um programa feito para um hardware específico e sistema operacional em um equivalente que possa ser executado em outro hardware ou sistema operacional. Atualmente ainda pode ser considerada como uma das linguagens mais portáveis.

5.3.

Pontos Negativos

Não fortemente Figurada: Este fato é também um ponto negativo da linguagem. Trata-se do processamento dos dados de acordo com a sua natureza ou tipo de dado. Este processamento é chamado de tipagem que indica o quanto a linguagem permite a troca de dados entre duas variáveis de tipos diferentes. O uso acidental de misturas de tipos de dados pode gerar erros de execução no programa. Verificação em Tempo de Execução: A linguagem C não possui verificação em tempo de execução, de forma que podem acontecer problemas cujas origens são muito difíceis de detectar.

46

5

F U N D A M E N T O S

5.4.

D A

L I N G U A G E M

C

O Padrão ANSI C

O comitê ANSI1 desenvolveu padrões para a linguagem C. Anteriormente a única referência da linguagem era o livro The C Programming Language (V. Kernighan e D. Ritchie, Laboratórios Bell, 1988). Este livro não é muito específico em certos detalhes da linguagem, o que levou a divergências entre os fabricantes de compiladores, prejudicando a portabilidade. O padrão ANSI surgiu para remover ambigüidades, embora nem todas tenham sido corrigidas, permanece como a melhor alternativa para produzir um código C portátil. O comitê ANSI adotou como norma várias frases que foram denominadas “o espírito do C”, dentre elas: “Não impeça que o programador faça aquilo que precisa ser feito”. “Confie no programador”. “Mantenha a linguagem pequena e simples”.

Além disso, a comunidade internacional foi consultada para garantir que o padrão ANSI C americano seria idêntico à versão do padrão ISO (International Standards Organization)

5.5.

Palavras Reservadas da Linguagem C

Todas as linguagens de programação têm palavras reservadas. As palavras reservadas não podem ser usadas a não ser nos seus propósitos originais, i.e., não podem ser declaradas funções ou variáveis com os mesmos nomes. Como a linguagem C é "case sensitive" (sensível a maiúsculas e minúsculas) podemos declarar uma variável For, apesar de haver uma palavra reservada for, mas isto não é recomendável pois gera confusão no código. A seguir são listadas as palavras reservadas do ANSI C, ao todo 32 palavras. Veremos o significado destas palavras chave à medida que os demais conceitos forem apresentados. auto break case char const continue default do

5.6.

double else enum extern float for goto if

int long register return short signed sizeof static

struct switch typedef union unsigned void volatile while

Estrutura de um Programa em C

Um programa em C é constituído de: um cabeçalho contendo as diretivas de compilador onde se definem o valor de constantes simbólicas, declaração de variáveis e funções, inclusão de bibliotecas, macros, etc.; um bloco de instruções chamado de função principal (main) e outros blocos de funções secundárias; comentários do programa que constituem a documentação in situ. 1

ANSI: American National Standards Institute. – www.ansi.org.

47

5

F U N D A M E N T O S

D A

L I N G U A G E M

C

Programa Exemplo: O paralel.c é um programa que calcula a resistência equivalente de um par de resistores conectado em paralelo. #include

/* Biblioteca padrão de I/O (ex. video e teclado) */

void main(void){ /* funcao principal */ float RA; /* Declaração da variável para a Resistência A */ float RB; /* Declaração da variável para a Resistência B */ float Req; printf("Programa que calcula o equivalente de duas resistências"); printf(" conectadas em paralelo"); printf("\n"); /* pula uma linha do monitor de video */ printf("Entre com o valor de RA:"); /* imprime a string no vídeo */ scanf("%f",&RA); /* espera o valor do teclado */ printf("\n"); /* pula uma linha do monitor de video */ printf("Entre com o valor de RB:"); /* imprime a string no vídeo */ scanf("%f",&RB); /* espera o valor do teclado */ Req = (RA * RB)/(RA + RB); /* Calcula a resistencia equivalente */ printf("\n"); /* pula uma linha do monitor de video */ printf("A Resistencia Equivalente para RA//RB = "); printf("%f",Req); }

/* Fim da função principal e do programa */ Código 5-1

5.7.

Conjunto de caracteres

Um programa fonte em C é um texto não formatado escrito utilizando um software editor de textos usando um conjunto padrão de caracteres ASCII. A seguir estão os caracteres válidos utilizados em C: Caracteres válidos: a A 1 +

b B 2 -

c C 3 *

d D 4 /

e E 5 \

f F 6 =

g G 7 |

h H 8 &

i I 9 !

j k l m n o p q r s t u v w x y z J K L M N O P Q R S T U V W X Y Z 0 ? # % ( ) { } [ ] _ ‘ “ . , : < >

Exemplos de caracteres inválidos: @ $ ¨ á é õ ç

Os caracteres acima são válidos apenas em strings. Maiores detalhes serão tratados no capítulo

5.8.

Comentários

Em C, comentários do programa, podem ser escritos em qualquer lugar do texto para facilitar a interpretação do algoritmo. Para que um comentário seja identificado como tal, ele deve ter um conjunto de símbolos /* antes do comentário, e um outro conjunto */ depois do mesmo. Observe que no exemplo paralel.c. Exemplo: /* esta e uma linha de comentário em C */

Observação: O C++ permite que comentários sejam escritos de outra forma: colocando duas barras (//) precedendo o comentário de uma linha. O compilador entenderá que tudo que estiver a direita do símbolo composto é um comentário. Alguns

48

5

F U N D A M E N T O S

D A

L I N G U A G E M

C

compiladores C aceitam algumas regras do C++, como por exemplo, definir comentários com dupla barra. Alguns compiladores aceitam colocar caracteres acentuados no meio dos comentários, outros não. Exemplo: // este e’ um comentário valido para todos os compiladores C++ // e alguns compiladores C mais novos

O uso de comentários torna o código do programa mais legível de ser entendido. Os comentários do C devem começar com o símbolo composto /* e terminar com */. A linguagem C padrão não permite comentários aninhados (um dentro do outro), até porque seria incoerente, mas existem alguns compiladores que os aceitam sem gerar erros de sintaxe.

5.9.

Diretivas de Compilação2

Em C, existem comandos que são processados antes da compilação do programa. Estes comandos são genericamente chamados de diretivas de compilação e servem para informar ao compilador, quais são as constantes simbólicas usadas no programa e quais bibliotecas devem ser anexadas ao programa executável entre outras funções. A diretiva #include instrui ao compilador para incluir na compilação do programa o conteúdo de outros arquivos. Normalmente estes arquivos contem declarações de funções da biblioteca ou rotinas do usuário. A diretiva #define diz ao compilador quais são as constantes simbólicas usadas no programa código fonte.

5.10.

Declaração de Variáveis3

Em C, como na maioria das linguagens, as variáveis devem ser declaradas antes de serem utilizadas. Existem dois tipos de variáveis de acordo com o escopo em que estas podem ser acessadas: as variáveis globais e as locais. Variáveis globais devem ser declaradas no início do programa e fora de qualquer função. As variáveis locais devem ser declaradas no inicio da função onde elas serão válidas. As variáveis podem ser de vários tipos: int (inteiras), float (real de simples precisão) e outras que serão vistas no capítulo a seguir. No exemplo acima Req, RA e RB são declaradas como variáveis float (reais). Os nomes das variáveis indicam o endereço de memória onde está um determinado dado. Cabe ressaltar que os nomes das variáveis não são armazenados no código executável, e que elas fazem sentido só para o instante da compilação e linker. Isto denota que não pode ser interpretado um código fonte a partir de um arquivo executável.

2 3

Este tema será tratado em mais detalhes no capítulo 14. Este tema será tratado em mais detalhes no capítulo 8.

49

5

F U N D A M E N T O S

5.11.

D A

L I N G U A G E M

C

Uma Introdução às Entrada e Saída de Dados4

Em C existem várias maneiras de fazer a leitura e escrita de informações. Estas operações são chamadas de operações de entrada e saída, ou simplesmente operações de I/O. No capítulo a seguir serão vistas algumas funções padronizadas. Um exemplo típico de dispositivo de saída é o monitor de vídeo, e um dispositivo de entrada, o teclado. Existem também funções padronizadas de I/O em arquivos, portas seriais e paralelas. Um exemplo de função padronizada é a função printf que é uma rotina de envio de dados formatados, utilizada para enviar caracteres ASCII para a placa de vídeo, para o canal serial, ou para qualquer função definida na sua chamada. A função scanf é uma função padronizada de leitura formatada de caracteres ASCII de um dispositivo de entrada de dados, tipicamente o teclado ou um canal serial.

5.11.1.

Caracteres

Os caracteres são um tipo de dado: o char. As variáveis char são armazenadas em memórias de um byte. Os inteiros (int) podem possuir um número maior de bytes. Dependendo da implementação do compilador e do microprocessador alvo, eles podem ter 1 byte (8 bits), 2 bytes (16 bits), 4 bytes (32 bits) ou mais. De forma geral também se pode usar uma variável do tipo char para armazenar valores numéricos inteiros de 8 bits. Para indicar um caractere de texto devem ser usadas apóstrofes. No exemplo a seguir pode-se visualizar o uso de variáveis do tipo char. #include void main (void){ char car; car = 'D'; /* car armazena o equivalente em ASCII da letra D */ printf ("%c",car); } Código 5-2

No programa anterior, %c indica à função printf() que deverá enviar um caractere para o dispositivo de saída. Como foi visto antes, uma variável char também pode ser usada para armazenar um número inteiro de oito bits. Observar o seguinte programa. #include void main (void){ char car; car = 'D'; printf ("%d",car); /* Imprime o caractere como inteiro */ } Código 5-3

Este programa colocará o número 68 no dispositivo de saída (memória da placa de vídeo ou canal serial, por exemplo), que é o código ASCII correspondente ao caractere 'D'. Algumas vezes é necessário capturar um caractere único fornecido pelo usuário do sistema ou por um dispositivo de entrada qualquer. Para efetuar esta tarefa existem duas funções na biblioteca chamadas getch() e getche(). Ambas retornam o caractere 4

Este tema será tratado em mais detalhes no capítulo 15.

50

5

F U N D A M E N T O S

D A

L I N G U A G E M

C

pressionado, se for num teclado, ou um caractere que chegou pelo canal serial, em várias aplicações de microcontroladores. A função getche() imprime o caractere na tela antes de retorná-lo (num compilador para PC) e getch() apenas retorna o caractere pressionado sem imprimi-lo na tela. Ambas as funções são declaradas no arquivo de cabeçalho conio.h. Geralmente estas funções não estão disponíveis em ambiente Unix (compiladores cc e gcc) e podem ser substituídas pela função scanf(), porém sem a mesma funcionalidade. A seguir um exemplo que usa a função getch(), e seu correspondente em ambiente Unix: #include #include void main (void){ char car; car=getch(); printf ("Foi pressionada a tecla %c",car); }

Equivalente para o ambiente Unix do programa acima, sem usar getch():

5

#include void main (void){ char Ch; scanf("%c",&Ch); printf ("Foi pressionada a tecla %c",Ch); } Código 5-4

Na maioria dos compiladores C para 8051, PIC, Motorola, etc., as funções scanf e printf utilizam o canal serial (ou um par de pinos de I/O digital) como dispositivo padrão para a entrada e saída de dados. Os compiladores para PC normalmente utilizam o teclado e o monitor de vídeo como dispositivo padrão. A principal diferença da versão que utiliza getch() para a versão que não a utiliza é que no primeiro caso, o usuário simplesmente seleciona a tecla e o sistema a lê diretamente do buffer de teclado (compiladores para PCs). No segundo caso, é necessário pressionar também a tecla .

5.11.2.

As Strings5

Para a linguagem C, uma string é definida como sendo um conjunto de caracteres terminado com um caractere nulo (00h). O caractere nulo é um caractere com valor inteiro igual a zero (código ASCII igual a 0). O terminador nulo também pode ser representado usando a convenção de barra invertida como sendo '\0'. Embora uma string seja um vetor de variáveis do tipo char, e que o assunto vetores será discutido posteriormente, serão vistos nesta seção os fundamentos necessários para que possam ser utilizadas estas cadeias de caracteres. Para declarar uma string pode-se utilizar o seguinte formato geral: char identificador-da-string[tamanho]; A expressão acima declara um vetor de caracteres (uma string) com número de posições igual a tamanho. Observar que devido ao terminador nulo, deve-se declarar o comprimento da string como sendo, no mínimo, um caractere maior que a maior string que se pretende armazenar. Supondo que seja declarada uma string de 7 posições e colocando a palavra Diodo nela, tem-se na memória: ‘D’

5

‘i’

‘o’

‘d’

‘o’

Este tema será tratado em mais detalhes no capítulo 11.

51

‘\0’

...

F U N D A M E N T O S

D A

L I N G U A G E M

C

No caso acima, as células de memória posteriores não utilizadas conterão valores indeterminados (usualmente chamado de lixo6 de memória pelos programadores). Isto acontece porque a linguagem C não inicializa automaticamente as suas variáveis, cabendo ao programador esta tarefa caso seja necessária. Caso seja necessária a leitura de uma string fornecida por um sistema ou pelo usuário através do teclado, pode ser usada a função gets(). Um exemplo do uso desta função é apresentado abaixo. A função gets() coloca o terminador nulo na string, quando no final da mesma aparece o equivalente em ASCII da tecla . Uma vantagem da representação de uma string pela finalização de um caractere nulo, é que esta não precisa ter um tamanho pré-definido, e em operações de leitura, a string pode ser lida caractere a caractere até o terminador nulo. #include void main (void) { char string[100]; printf ("Digitar uma string: "); gets(string); printf ("\n Foi digitada %s",string); } Código 5-5

Neste programa, o tamanho máximo da string que pode ser inserida é 99 caracteres. Caso a string inserida tiver um tamanho maior poderá levar a resultados desastrosos. Como as strings são basicamente vetores de caracteres, para se acessar um determinado caractere, basta utilizar um índice relacionado ao caractere desejado dentro da string. Supondo uma string chamada str pode-se acessar o segundo caractere (‘t’) de str da seguinte forma: str[1] = 'a';

Tanto na linguagem C como no hardware, a primeira posição de um vetor é a posição zero. Desta forma, o primeiro caractere de uma string estará na posição 0 do vetor; a segunda letra na posição 1 e assim sucessivamente. Segue um exemplo que imprimirá o segundo caractere da string "Diodo". Em seguida, o programa troca o caractere e apresenta a string resultante. #include void main(void) { char str[10] = "Diodo"; printf("\n String: %s", str); printf("\n Segundo caractere: %c", str[1]); str[1] = 'U'; /*Troca o caractere ‘i’ por ‘U’ */ printf("\n Agora o segundo caractere é: %c", str[1]); printf("\n A string resultante: %s", str); } Código 5-6

Nesta string, o terminador nulo está na posição número cinco. Das posições 0 a 5, sabe-se que existem caracteres válidos, e portanto podem ser impressos. Deve-se notar a forma como a string str foi inicializada com os caracteres ‘D’ ‘i’ ‘o’ ‘d’ ‘o’ e ‘\0’ simplesmente declarando char str[10] = "Diodo". No programa acima, o símbolo %s indica à função printf() que deve colocar uma string no dispositivo de saída. A continuação será feita uma abordagem inicial mais detalhada sobre as duas funções que já têm sido utilizadas para implementar entradas e saídas de dados. 6

Na gíria de programação, a palavra lixo de memória, significa um conjunto de valores desconexos e sem sentido.

52

5

F U N D A M E N T O S

5.11.3.

D A

L I N G U A G E M

C

printf

A função printf() tem a seguinte forma geral: printf (string-de-controle,lista-de-argumentos); A string de controle serve como modelo do que vai ser enviado para o dispositivo de saída, por exemplo a placa de vídeo. A string de controle contém os caracteres que devem ser colocados no dispositivo de saída e os espaços reservados para os valores das variáveis e suas respectivas posições. A colocação de conteúdos de variáveis é feita usandose os códigos de controle, que usam a uma notação especial começando com o caractere %. Na string de controle podem ser indicadas quais variáveis terão o conteúdo enviado, de que tipo e ainda em que posição serão enviadas. Para cada código de controle deve-se ter um argumento na lista de argumentos. Na tabela abaixo estão apresentados alguns códigos: Código %d %f %c %s %x %%

Significado Inteiro Float Caractere String Hexadecimal Coloca na tela um %

Mais abaixo são mostrados alguns exemplos de uso da função printf() e o que eles exibem: printf printf printf printf printf

("\n ("\n ("\n ("\n ("\n

Teste %% %%"); %f",40.345); Um caractere %c e um inteiro %d",'D',120); %s e um exemplo","Este"); %s%d%%","Tolerância de ",10);

Resultado: Teste % % 40.345 Um caractere D e um Este e um exemplo Tolerância de 10%

inteiro 120

Maiores detalhes sobre a função printf() incluindo demais códigos de controle serão vistos posteriormente.

5.11.4.

scanf

O formato geral da função scanf() é: scanf (string-de-controle,lista-de-argumentos); Usando a função scanf() pode-se capturar dados de um dispositivo de entrada (canal serial ou teclado, por exemplo). O número de argumentos deve ser igual ao de códigos de controle na string de controle. É importante lembrar o uso do símbolo & antes das variáveis da lista de argumentos (endereço da variável). Maiores detalhes sobre a função scanf() serão vistos posteriormente. Uma desvantagem do uso desta função é que o sistema pára na função até que seja inserido um caractere equivalente ao . Na maioria das aplicações de engenharia

53

5

F U N D A M E N T O S

D A

L I N G U A G E M

C

este tipo de comportamento não pode ser tolerado e os dados devem ser capturados utilizando interrupções. O uso de interrupções será tratado em outros capítulos.

5.12. Uma Introdução aos Comandos de Controle de Fluxo7 A linguagem C permite uma ampla variedade de estruturas de controle de fluxo de processamento. Estas estruturas serão vistas em detalhes nos capítulos seguintes. Existem duas estruturas básicas (decisão e iteração) que são similares às estruturas usadas nas pseudolinguagens algorítmicas: Estrutura de Tomada de Decisão: Permite direcionar o fluxo lógico para dois blocos distintos de instruções, de acordo com uma condição de controle. Pseudolinguagem se condição então bloco 1 senão bloco 2 fim se

Linguagem C if(condição){ bloco 1; }else{ bloco 2; };

Estrutura de Iteração ou Repetição: Permite executar repetidamente um bloco de instruções até que a condição de controle seja satisfeita. Pseudolinguagem faça bloco enquanto condição

Linguagem C do{ bloco; }while(condição);

A linguagem C é sensível a maiúsculas e minúsculas (case sensitive), assim se for declarada uma variável chamada soma, a mesma será interpretada de forma diferente de outras que forem declaradas com nomes parecidos, tais como Soma, SOMA, SoMa ou sOmA. Da mesma forma, os comandos (palavras chave ou instruções), if e for, por exemplo, só poderão ser escritos com letras minúsculas, caso contrário, não serão interpretados como comandos, e sim como identificadores. Os comandos de controle de fluxo permitem ao programador alterar a seqüência de execução de um programa. Nesta seção será feita uma breve introdução a dois comandos de controle de fluxo mais utilizados. Outros comandos serão estudados posteriormente.

5.12.1.

if

O comando if representa uma tomada de decisão do tipo "SE (isto for verdadeiro) ENTÃO (execute o seguinte...)". A forma geral do comando é: if (condição) instrução; A condição do comando if é uma expressão que será avaliada como sendo verdadeira ou falsa. Em C, uma expressão é falsa se o seu valor é igual a zero. Se o resultado for zero a declaração não será executada. Se o resultado for qualquer coisa diferente de zero a instrução será executada.

7

Este tema será tratado em mais detalhes no capítulo 10.

54

5

F U N D A M E N T O S

D A

L I N G U A G E M

C

A instrução pode ser um bloco de código ou apenas um comando. É interessante notar que, no caso da declaração ser um bloco de código, não é necessário o uso do símbolo ‘;’ no final do bloco. Isto é uma regra geral para blocos de código. Abaixo é mostrado um exemplo de utilização. #include void main (void){ int res; printf ("\nDigite o valor do resistor: "); scanf("%d",&res); if (res>100) printf ("\nO resistor é maior que 100 ohms"); if (res==100){ printf ("\n\nO resistor é de 100 ohms\n"); printf ("O numero e igual a 100."); } if (res100 é previamente avaliada e retornará um valor diferente de zero se verdadeira, ou zero se for falsa. Deve ser observada a utilização do símbolo composto ‘==’ dentro da condição do segundo if. Este é um operador de comparação cujo resultado é verdadeiro, se ambos operandos forem iguais, ou zero se forem diferentes. O símbolo simples ‘=’ é um operador de atribuição, onde o operando esquerdo recebe uma cópia de um valor relacionado como o operando colocado à direita. Caso for colocada a seguinte condição: if (res = 10) ...

/* Isto não é uma comparação */

Neste caso o compilador gerará um código que atribuirá a quantidade 10 à variável res e a expressão res = 10 retornará 10 (diferente de zero, portanto verdadeiro), fazendo com que a declaração fosse executada sempre. Este problema gera erros lógicos freqüentes mas geralmente fáceis de serem detectados durante a depuração. Deve-se evitar efetuar uma comparação de igualdade entre dois números em ponto flutuante. Observar o seguinte exemplo. #include void main(void){ float pi = 3.1415926536; if( pi == 3.1415926506 ){ printf(“Os valores são diferentes, mas foram considerados iguais ”); printf(“por causa da precisão”); } } Código 5-8

Os operadores de comparação ou relacionais são: == igual != diferente de > maior que < menor que >= maior ou igual proximo; free(noatual); noatual = cabeca; } } /* Lista todos os elementos presentes na lista encadeada */ void listar (TProduto *noatual){ int i=0; while( noatual != NULL){ /* Enquanto nao chega no fim da lista */ i++; printf("\n\nProduto numero %d\nCodigo: %d \nPreco:R$%.2lf", i, noatual>codigo, noatual->preco); noatual = noatual->proximo; /* Faz noatual apontar para o proximo no */ } } /* Função para inserir um novo no, ao final da lista */ void inserir (TProduto **cabeca){ TProduto *noatual, *novono; int cod; double preco; printf("\n Codigo do novo produto: "); scanf("%d", &cod); printf("\n Preco do produto:R$"); scanf("%lf", &preco); if (*cabeca == NULL){ /* Se ainda nao existe nenhum produto na lista */ /* cria o no cabeca */ *cabeca = (TProduto *) malloc(sizeof(TProduto)); (*cabeca)->codigo = cod; (*cabeca)->preco = preco; (*cabeca)->proximo = NULL; } else{ /* Se ja existem elementos na lista, deve percorre-la ate' o seu final e inserir o novo elemento */ noatual = *cabeca; while(noatual->proximo != NULL) noatual = noatual->proximo; /* Ao final do while, noatual aponta para o ultimo no */ novono = (TProduto *) malloc(sizeof(TProduto));

269

16

T I P O S

D E

D A D O S

E S P E C I A I S

/* Aloca memoria para o novo no */ novono->codigo = cod; novono->preco = preco; novono->proximo = NULL; noatual->proximo = novono; /* Faz o ultimo no apontar para o novo no */ } } Código 16-10

É interessante notar que, no programa anterior não existe limite para o número de produtos que se vai armazenar na lista. Toda vez que for necessário criar um novo produto, memória para ele será alocada e ele será criado no final da lista. Note que a função inserir recebe o endereço do ponteiro cabeça da lista. Qual a razão disto? A razão é que o endereço para o qual a cabeça da lista aponta poderá ser modificado caso se esteja inserindo o primeiro elemento na lista. É importante notar que várias outras estruturas de dados complexas podem ser criadas com structs contendo ponteiros que apontam para outras structs. EXERCÍCIOS

1.

Crie uma struct para descrever os componentes de hardware de uma placa microprocessada. Os campos devem armazenar o nome do componente, part number, valor e nome do fornecedor. Criar uma lista encadeada com esta struct e escreva um programa que: Insira um novo componente na lista; Leia uma lista de componentes a partir de um arquivo; Grave a lista de componentes para um arquivo; Liste todos os componentes na tela; Crie uma lista de produtos, onde cada um possui uma lista de componentes, com as mesmas características descritas nos itens anteriores.

2.

Escrever um programa fazendo o uso de structs. Deverá ser criada uma struct chamada Ponto, contendo apenas a posição x e y (inteiros) do ponto. Declarar 2 pontos, ler a posição (coordenadas x e y) de cada um e calcular a distância entre eles. Apresentar como resultado final a distância entre os dois pontos.

3.

Seja a seguinte struct que é utilizada para descrever os produtos que estão no estoque de uma empresa que produz instrumentos de medida:

struct Produto { char nome[30]; /* Nome do produto */ int codigo; /* Codigo do produto */ double preco; /* Preco do produto */ };

Escreva uma instrução que declare uma matriz de Produto com 10 itens de produtos; Atribua os valores "Voltímetro", 13205 e R$200 aos membros da posição 0 e os valores "Amperímetro", 15202 e R$210,00 aos membros da posição 1 da matriz anterior; Faça as mudanças que forem necessárias para usar um ponteiro para Produto ao invés de uma matriz de Produtos. Faça a alocação de memória de forma que se possa armazenar 10 produtos na área de memória apontada por este ponteiro e refaça as atribuições do item anterior b; Escreva as instruções para imprimir os campos que foram atribuídos no item anterior.

270

16

17 Capítulo

17. INTERRUPÇÕES 17.1.

Introdução

Quando são recebidos dados e houver mudança no status das portas de I/O, existem basicamente dois métodos disponíveis de utilização. Pode-se "perguntar" (Poll) à porta, efetuando uma leitura do status da mesma, em certos intervalos fixos de tempo, para determinar se algum dado tem sido recebido ou se houve alguma mudança em relação ao estado anterior. Caso tenha acontecido alguma alteração, então o programa deve ser desviado para as rotinas de serviço apropriadas. Como se pode imaginar, o método anterior, chamado de polling, pode consumir muito tempo. Este tempo, pode ser utilizado para efetuar alguma outra tarefa, como por exemplo, repintar a tela do monitor, mostrar as horas num relógio, etc.. Uma melhor alternativa é a de utilizar as interrupções. Neste tipo de método, o processador efetua as suas tarefas comuns, tais como a atualização da tela, atualização do relógio, etc., e quanto acontecer algum evento num dispositivo de I/O, no caso da chegada de um byte, ou a mudança no status da porta, este solicitará a atenção do processador enviando um sinal de requisição de interrupção (Interrupt Request). Quando o processador receber um sinal de requisição de interrupção, este finaliza a instrução corrente, armazena algumas informações prévias numa área de memória chamada de pilha ou stack para posterior restauração, e executa as rotinas de atendimento a interrupção (Interrupt Service Routine - ISR), que por exemplo, poderá capturar o byte da porta e colocá-lo num buffer. Uma vez acabada a rotina ISR, o processador retorna a execução que tinha sido interrompida, utilizando a informação deixada no stack. Usando este método, o processador não perde tempo, procurando ver se um dispositivo de I/O precisa da sua atenção, mas no lugar disto, o próprio dispositivo irá solicitar interromper a execução quando for necessário.

17.2.

Interrupções e a Arquitetura Intel

As interrupções não precisam ser todas associadas com dispositivos de I/O. A família de microprocessadores 8086, possui 256 interrupções, muitas destas são utilizadas somente para interrupções de software. A série de microprocessadores 8086 possui uma tabela de vetores de interrupção, denominada Interrupt Vector Table, iniciando no endereço de memória 0000:0000, estendendo-se até 1024 bytes. A posição de tabela de vetor de interrupções, armazena os endereços das rotinas de serviço de interrupção (ISR), cada uma delas com quatro bytes de extensão, dando lugar a 256 vetores de interrupções. 271

I N T E R R U P Ç Õ E S

INT (Hex) 00 02 03 08 09 0A 0B 0C 0D 0E 0F 10 70 71 72 73 74 75 76 77 78 -

01 07

6F

7F

IRQ

Usos mais Comuns

Manipuladores de Exceção (Exception Handlers) IRQ não mascarável Manipuladores de Exceção IRQ0 - Hardware IRQ1 - Hardware IRQ2 - Hardware IRQ3 - Hardware IRQ4 - Hardware IRQ5 - Hardware IRQ6 - Hardware IRQ7 - Hardware Interrupções de Software IRQ8 - Hardware IRQ9 - Hardware IRQ10 - Hardware IRQ11- Hardware IRQ12 - Hardware IRQ13 - Hardware IRQ14 - Hardware IRQ15 - Hardware Interrupções de Software

Erros de paridade, etc. Timer do Sistema Teclado Redirecionada Comunicação Serial COM2/COM4 Comunicação Serial COM1/COM3 Reservado/Placa de Som Controlador de disco flexível Comunicação Paralela Relógio de Tempo Real IRQ2 redirecionada Reservada Reservada Mouse PS/2 Co-Processador Matemático Disco Rígido Reservado

Tabela 17-1 – Vetores de Interrupções

Em resumo, existem somente 15 interrupções (IRQs) de hardware e uma interrupção não-mascarável. Os demais vetores de interrupção são utilizados como interrupções de software e por manipuladores de exceções. Os manipuladores de exceções são rotinas parecidas com as ISRs, que podem ser chamadas ou interrompidas quando acontecer tipo de erro. Um exemplo deste é o primeiro vetor de interrupção que armazena o endereço da Divisão por Zero. Quando ocorrer uma divisão por zero, o microprocessador encontra o endereço armazenado na posição 0000:0000 e inicia a execução do código colocado neste endereço.

17.3.

Interrupções de Hardware

O Controlador Programável de Interrupções (PIC) manipula as interrupções de hardware. A maioria dos PCs possui dois destes chips, localizados em endereços diferentes. Um destes cuida das IRQs 0 a 7, e o outro, as IRQs 8 a 15, totalizando em 15 linhas de IRQ individuais, sendo o segundo PIC cascateado com o primeiro, utilizando a IRQ2. A maior parte da inicialização do PIC é feita pela BIOS, de forma a facilitar a utilização, sendo que o programador somente tem que se preocupar com duas instruções iniciais. O PIC possui algumas facilidades implementadas, como o mascaramento de IRQs individuais, de forma a que as requisições específicas não interrompam o processador. A primeira instrução de inicialização a ser feita pelo programador é a inicialização do registrador OCW1 (Operation Control Word) para selecionar quais as IRQs serão mascaradas e quais não. Como existem dois circuitos PIC localizados em endereços diferentes, primeiro deve-se determinar qual PIC será utilizado. O primeiro, localizado no endereço base 0x20H, controla a IRQ0 a IRQ7. O formato de bits de controle do registrador OCW1 deste PIC é mostrado na tabela que segue. Bit 7

Desabilita IRQ IRQ7

Função Porta Paralela

272

17

I N T E R R U P Ç Õ E S

6 5 4 3 2 1 0

IRQ6 IRQ5 IRQ4 IRQ3 IRQ2 IRQ1 IRQ0

Controlador de disco flexível Reservado/Placa de Som Porta Serial Porta Serial PIC2 Teclado Timer do Sistema

Tabela 17-2 – Bits de configuração da IRQ0 a IRQ7 (PIC 1 – Endereço 0x21)

Notar que a IRQ2 está conectada ao Segundo PIC (PIC2), de forma a que mascarando este bit, desabilitará as IRQ8 a IRQ15. O Segundo PIC está localizado no endereço base 0xA0H, controlando as IRQs 8 a 15. A seguir, a tabela mostra os bits de controle necessários para as habilitações independentes. Bit 7 6 5 4 3 2 1 0

Desabilita IRQ IRQ15 IRQ14 IRQ13 IRQ12 IRQ11 IRQ10 IRQ9 IRQ8

Função Reservado Disco Rígido Co-Processador Matemático Mouse PS/2 Reservado Reservado IRQ2 redirecionada Relógio de Tempo Real

Tabela 17-3 - Bits de configuração da IRQ8 a IRQ15 (PIC 2 – Endereço 0xA1)

Como a tabela acima mostra os bits necessários para desabilitar uma IRQ, no caso de precisar habilita-la, os bits correspondentes deverão ser setados para zero. Por exemplo, se for necessário habilitar a IRQ 3 então deverá ser enviado o byte 0xF7 como OCW1 para o PIC1. Mas o que aconteceria se existir a possibilidade de que uma destas IRQs já esteja habilitada e em uso ? Neste caso, deve-se proceder primeiramente ao mascaramento, usando uma função AND, para poder modificar somente aquele bit que interessa, deixando os outros na sua condição anterior. Para conhecer a condição anterior, deve-se ler antes o valor do registrador, e logo então proceder a modificação do bit correspondente através da mascara. Por exemplo, pode-se habilitar somente a IRQ3 da seguinte forma: outportb(0x21,(inportb(0x21) & 0xF7);

Lembrar que o registrador OCW1 fica no registrador com endereço Base + 1. O mesmo procedimento deve ser usado para mascarar (desabilitar) uma IRQ. Embora que neste caso, deverá ser utilizada uma máscara com a função OR, usando o byte 0x08 sobre o conteúdo original do registrador OCW1. Um exemplo disto é mostrado a seguir. outportb(0x21,(inportb(0x21) | 0x08);

Uma outra instrução do PIC que deve ser executada é o Fim da Interrupção (End of Interrupt - EOI). Esta deve ser enviada para o PIC no final da rotina de atendimento a interrupção (ISR), de forma que o PIC possa resetar o seu registrador In Service Register. Uma EOI pode ser enviada para o PIC1 usando o seguinte código: outportb(0x20,0x20);

ou para o PIC2 outportb(0xA0,0x20);

273

17

I N T E R R U P Ç Õ E S

17.4.

Instruções de Interrupção de Hardware

As instruções de interrupção não são padronizadas, sendo que cada compilador possui a sua própria implementação. A seguir são comentadas as instruções de interrupção para três compiladores diferentes.

17.4.1.

Borland C++ - 80x86

A instrução interrupt define uma função como sendo um manipulador de interrupção. A sintaxe é mostrada a seguir. interrupt ; Todos os registradores da CPU são gravados e o código da função é finalizado por uma instrução assembly IRET. Um exemplo de utilização é mostrado a seguir. void interrupt nova_isr() {}

17.4.2.

Franklin C – 8x51

A instrução interrupt define uma função como sendo um manipulador de interrupção. Este compilador implementa a sintaxe da seguinte forma: void Serial_Interrupt () interrupt 4 { .... }

A função de atendimento a interrupção foi chamada de Serial_Interrupt, e o número depois da instrução interrupt, identifica qual a interrupção de hardware, que é tabelada de acordo com as especificações estabelecidas no manual.

17.4.3.

PCW CCS – Microchip PIC

Este compilador implementa a definição dos manipuladores de interrupção através da seguinte sintaxe: #int_NOME_DA_INT A isto vai em seguida a definição da função de atendimento a interrupção. A seguir um exemplo de codificação. #int_timer1 timer1_interrupt(){}

17.5. Implementando uma Rotina de Atendimento a Interrupção (ISR) Em C pode ser implementada uma ISR da seguinte forma1: void interrupt nova_isr()

onde nova_isr é um ponteiro longo2, apontando para o endereço que a Rotina de Atendimento a Interrupção irá estar colocada na memória. Este endereço será colocado 1

Usar um compilador da Borland.

274

17

I N T E R R U P Ç Õ E S

depois na Tabela de Vetores de Interrupção de forma que, esta será chamada quando acontecer a interrupção. O seguinte código mostra a implementação básica de uma ISR. void interrupt nova_isr() {/* Rotina de Atendimento a Interrupcao (ISR) */ disable(); /* O corpo da ISR a partir daqui */ oldhandler(); outportb(0x20,0x20); /* Envia EOI para o PIC1 */ enable(); }

A função void interrupt nova_isr() define a função como sendo uma rotina de atendimento a interrupção. A função disable()3 limpa o flag de interrupção, de forma que nenhuma outra interrupção de hardware, exceto que a NMI (Non-Maskable Interrupt – Interrupção não Mascarável) possa ocorrer. Se não for feito desta forma, uma interrupção com prioridade maior, poderá interromper a execução da ISR. Embora, isto não seja um problema na maioria dos casos, é uma situação que merece ser analisada. O corpo da ISR deverá incluir o código que se deseja executar quando a requisição de interrupção seja ativada. A maioria das portas e UARTs4 podem interromper o processador por um grande motivo de razões, por exemplo, um byte recebido, timeouts, buffer da FIFO cheio, overruns, etc., de forma que a natureza da interrupção tem que ser determinada. Isto normalmente é feito pela leitura dos registradores de status da porta que está em uso. Uma vez estabelecido a causa da interrupção, pode-se efetuar as tarefas necessárias a esta. Caso devam ser lidos quaisquer dados de uma porta, é uma prática comum, colocalos em um buffer, no lugar de escreve-los diretamente na tela do monitor de vídeo, por exemplo, inibindo que outras interrupções posteriores de serem processadas. A maioria das Portas possui buffers FIFO que podem conter mais de um byte, de forma que a rotina de leitura deste buffer deverá ser repetida, até que a FIFO fique vazia, e somente então, finalizar a ISR. Em alguns casos pode ser apropriado redirecionar o código para a ISR original para execução previa. Um exemplo é a interrupção do Clock (Clock Interrupt – Interrupção do Relógio do Sistema). Alguns programas residentes (TSR) podem precisar utilizar a rotina original de atendimento, de forma que se esta rotina original for interceptada e capturada para uso exclusivo do programa próprio, os outros programas poderão ocasionar efeitos colaterais, como por exemplo ocasionar um desajuste do relógio do sistema operacional que esteja sendo utilizado. Normalmente, isto não é problema com as portas seriais e paralelas. Para redirecionar temporariamente a ISR própria para a original ou anterior, pode ser utilizada uma função oldhandler(), onde esta aponta para a ISR original. Não esquecer que antes de retornar da interrupção, deverá ser informado ao PIC (Programmable Interrupt Controller) o encerramento da rotina, enviando uma instrução EOI (End of Interrupt 0x10). Como existem dois PICs (no caso de um PC), primeiro deverá ser estabelecido para qual destes será enviado. Pode ser utilizado outportb(0x20,0x20); para o PIC 1 (IRQ 0 -7) ou outportb(0xA0,0x20); para o PIC 2 (IRQ 8 - 15)5. 2 Nos compiladores de 32 bits todos os ponteiros têm esse tamanho. Nos cross-compilers, os ponteiros normalmente são de 8 ou 16 bits. 3 A função disable() está declarada em DOS.H nos compiladores da Borland. 4 UART: Universal Asynchronous Receiver Transmitter 5 Se estiver em uso o PIC2, então o comando EOI tem que ser enviado para ambos, PIC1 e PIC2.

275

17

I N T E R R U P Ç Õ E S

17.6. Usando uma nova Rotina de Atendimento a Interrupção - ISR Uma vez que tenha sido escrita uma nova rotina de atendimento de interrupção, pode-se analisar como será executada. O segmento de código que segue, mostra o uso de uma nova ISR. Neste caso foi escolhido o uso da IRQ 3. #include #define INTNO 0x0B /* Numero da Interrupçao – Ver Tabela 1 */ void main(void){ oldhandler = getvect(INTNO); /* Salva o Vetor de Interrupçao anterior */ setvect(INTNO, nova_isr); /* Seta uma nova entrada no Vetor de Interrupções */ outportb(0x21,(inportb(0x21) & 0xF7)); /* Habilita a IRQ3 */ /* Seleciona a placa e seta a porta para gerar interrupções */ /* Corpo do programa começa aqui */ /* Reseta a placa para que a porta pare de gerar interrupçoes */ outportb(0x21,(inportb(0x21) | 0x08)); /* Mascara (Desabilita) IRQ3 */ setvect(INTNO, oldhandler); /* Restaura o Vetor de Interrupções anterior antes de sair */ } Código 17-1

Antes de colocar o endereço da nova ISR na tabela de vetores de interrupção, devese primeiro salvar o vetor de interrupção original, de forma que possa ser restaurado novamente na saída do programa. Isto pode ser efetuado utilizando oldhandler = getvect(INTNO); onde INTNO é o numero do vetor de interrupção que se desejará restaurar posteriormente. Antes que oldhandler possa ser utilizado, primeiro deve-se declarar usando void interrupt (*oldhandler)();. Uma vez que o vetor de interrupções original foi armazenado, pode-se proceder a instalação da nova ISR no tabela de vetores de interrupção. Isto pode ser feito utilizando a linha setvect(INTNO, nova_isr); onde nova_isr aponta para a nova rotina de atendimento da interrupção. A IRQ a ser utilizada, agora deverá ser habilitada. A maioria das portas e UARTS6 precisa ser inicializadas para serem capazes de gerar interrupções. Por exemplo, a porta paralela padrão (Standard Parallel Port - SPP) requer que seja setado o bit 4 do registrador Control Port (Enable IRQ Via ACK) no endereço Base + 2. As portas seriais padrão requerem o ajuste apropriado dos bits 0 a 4 do registrador IER (Interrupt Enable Register) localizado no endereço Base + 1. O corpo do programa normalmente consiste de poucas tarefas simples dependendo da sua aplicação. Aqui pode ser monitorado se novas teclas forem pressionadas, menus que estão sendo selecionados, atualização de relógios, verificação da chegada de dados nos buffers de recepção, etc., sabendo que qualquer dado proveniente de uma porta poderá ser automaticamente lido e processado pela ISR. Por exemplo, pode-se implementar uma ISR própria na Interrupção de Teclado, de forma que qualquer tecla que seja pressionada, seja automaticamente manipulada por uma outra ISR, por exemplo a ISR do clock. A cada 18.2 ticks o programa poderá atualizar os segundos no monitor de vídeo. As possibilidades das ISRs são enormes. Antes de sair do programa, sempre deve-se restaurar o vetor original de interrupções, de forma, que o computador não fique instável. Isto pode ser feito utilizando setvect(INTNO, oldhandler);, onde oldhandler aponta para a rotina de atendimento a

6

UART: Universal Asynchronous Receiver Transmitter

276

17

I N T E R R U P Ç Õ E S

interrupção original, cujo endereço foi armazenado utilizando oldhandler = getvect(INTNO);.

17.7.

O Controlador Programável de Interrupções - PIC

Como discutido anteriormente, as requisições de interrupção (Interrupt ReQuests IRQ's) de um PC são manipuladas por dois Controladores de Interrupções Programáveis 8259 (Programmable Interrupt Controllers - PIC). Os antigos sistemas XTs e ATs possuíam dois chips DIP de 28 pinos, mas como se pode imaginar, a tecnologia tem mudado dramaticamente desde então. Enquanto que a operacionalidade dos PICs ainda é a mesma, agora estes se encontram integrados em algum dos chips dos novos sistemas, junto com muitos outros dispositivos.

Figura 17-1 – Controlador Programável de Interrupções

O diagrama de blocos básicos de um PIC é mostrado acima. As oito linhas individuais de requisição de interrupção são armazenadas no Interrupt Mask Register (IMR) para verificar se estas estão mascaradas ou não. Se estiverem mascaradas, então a requisição não será processada. Agora, se não estiverem mascaradas, então este registrador irá sinalizar a interrupção para o Interrupt Request Register (IRR). O Interrupt Request Register irá armazenar todas as requisições das IRQs até que tenham sido manipuladas apropriadamente. Se necessário, o registrador pode ser lido setando alguns bits apropriados do Operation Control Word 3. O bloco Priority Resolver simplesmente seleciona a IRQ com a mais alta prioridade. As interrupções de mais alta prioridade são as identificas com o menor número. Por exemplo, a IRQ 0 é a interrupção com mais alta prioridade, seguida pela IRQ 1 e assim sucessivamente. Uma vez que o PIC tenha determinado qual IRQ processar, chegou a hora de indicar ao processador, de forma que ele possa chamar a ISR programada. Este processo é feito enviando uma INT ao processador, i.e. a linha INT do processador será ativada. O processador irá então finalizar a instrução corrente que estiver sendo processada e responderá à requisição INT com um pulso em INTA (Interrupt Acknowledge).

277

17

I N T E R R U P Ç Õ E S

Na recepção do sinal INTA do processador, a IRQ que o PIC estiver processando no momento, será armazenada no In Service Register (ISR) que como o nome diz, indica qual IRQ está em serviço. Os bits das IRQs são resetados no Interrupt Request Register, já que neste ponto não há mais requisição de interrupção, mas sim atendimento a interrupção. Um outro pulso INTA será enviado pelo processador, para indicar ao PIC que deve colocar um apontador de 8 bits no barramento de dados, correspondente ao número da IRQ. Se estiver sendo solicitado um serviço de atendimento de uma IRQ controlada pelo PIC2, então este deverá enviar o apontador para o processador.. O PIC mestre (PIC1) neste estágio, selecionará o PIC2 para enviar o apontador, pela colocação da identificação do escravo nas linhas de cascateamento (CAS0 – CAS2), que são um barramento de três linhas entre o sistema dos PICs. Os 5 bits mais significativos deste apontador são setados utilizando a Initialization Command Word 2 (ICW2). Esta deverá ser 00001 para o PIC1 e 01110 para o PIC2. Os três bits menos significativos, contêm a informação de qual IRQ está sendo atendida. Por exemplo, se a IRQ3 estiver requerendo atendimento, então o apontado de 8 bits estará com valor 00001 nos 5 bits mais significativos, e com valor 011 (IR3) nos bits menos significativos. Colocando todos os bits juntos, tem-se 00001011 ou 0x0B que representa o vetor de interrupção da IRQ3. Para o PIC2, o mesmo procedimento é aplicado. Se a IRQ10 requer atendimento, então será enviado 01110010, que representa a interrupção 72h. A IRQ10 está conectada a IR2 no segundo PIC, desta forma os bits 010 são usados como bits menos significativos. Uma vez que a ISR tenha efetuado todas as tarefas necessárias, esta envia um sinal de final de interrupção EOI par ao PIC, o qual resetará o seu In-Service Register. No caso de que a requisição tenha partido do PIC2, então a EOI deverá ser enviada a ambos os PICs. O PIC então determinará a próxima interrupção com mais alta prioridade e repetirá desta forma todo o processo. Se não houver outras requisições de interrupção, então o PIC esperará pela próxima requisição antes de interromper o processador novamente.

17.7.1.

Redirecionamento IRQ2/IRQ9

O redirecionamento da IRQ2 ocasiona alguma confusão, e será discutida nesta seção. Nos equipamentos originais XT, existia somente um PIC, implementando somente oito IRQs. Os usuários rapidamente esgotaram os recursos, de forma que mais um PIC com 8 IRQs foi adicionado ao PC. Isto envolveu a conexão de um outro chip PIC com o já existente no XT. A compatibilidade sempre ocasiona problemas como nesta nova configuração que tinha que ser compatível com o velho software e hardware. A “nova” configuração é mostrada na figura que segue.

278

17

I N T E R R U P Ç Õ E S

17

Figura 17-2 – Redirecionamento de IRQ2/IRQ9

A CPU somente possui uma linha de interrupção, de forma que o segundo controlador tinha que ser conectado com o primeiro, em uma configuração de mestreescravo. A IRQ2 foi selecionada para isto. Pela utilização da IRQ2 pelo segundo controlador, sendo que nenhum outro dispositivo poderia utilizar a IRQ2, que aconteceria com todos os dispositivos que utilizavam a IRQ2 ? A resposta é nada, já que a linha de requisição de interrupção localizada no barramento, foi simplesmente desviada como entrada da IRQ9. Como nenhum dispositivo utilizado até então ainda usava o segundo PIC ou IRQ9, isto poderia ser feito sem problemas. O problema seguinte foi que os dispositivos de hardware que utilizavam a IRQ2 deveriam instalar as suas ISRs nas INT 0x0A. Então uma rotina ISR foi utilizada em INT 71h, que enviaria a EOI para o PIC2 e então chamaria a ISR na INT 0x0A. Caso seja dessasemblada a ISR para a IRQ9, pareceria com o seguinte código: MOV AL,20 OUT A0,AL ; Envia EOI para PIC2 INT 0A ; Chama a ISR para a IRQ2 IRET

Esta rotina somente tinha que enviar a EOI para o PIC2, como era esperado que a rotina ISR escrita para a IRQ2 enviaria o EOI para o PIC1. O exemplo destrói os conteúdos do registrador AL, de forma que para evitar isto, deve ser copiado antes na pilha. Como o PIC2 é inicializado como escravo em IRQ2, qualquer requisição no PIC2 não chamará as rotinas ISR da IRQ2. Um apontador de 8 bits será enviado pelo PIC2.

279

I N T E R R U P Ç Õ E S

17.8. Endereços dos Controladores Programáveis de Interrupção Os dois PICs encontrados em um sistema IBM compatível, são inicializados através da BIOS, de forma que não é necessário se preocupar com todos os seus registradores. De qualquer forma para algumas pessoas, que possuem mentes inquisitivas, a informação que segue pode ser de alguma utilidade, para re-programar a BIOS por exemplo. A seguir é mostrada uma tabela de todas as palavras de comando do PIC 8259 e compatíveis, enquanto a tabela seguinte à primeira mostra os endereços do PIC2. Endereço 20h

21h

Leitura/Escrita Escrita Escrita Escrita Leitura Leitura Escrita Escrita Escrita Leitura/Escrita

Função Initialization Command Word 1 (ICW1) Operation Command Word 2 (OCW2) Operation Command Word 3 (OCW3) Interrupt Request Register (IRR) In-Service Register (ISR) Operation Command Word 2 (OCW2) Operation Command Word 3 (OCW3) Operation Command Word 4 (OCW4) Interrupt Mask Register (IMR)

Tabela 17-4 – Endereços/Registradores para o PIC1 Endereço A0h

A1h

Leitura/Escrita Escrita Escrita Escrita Leitura Leitura Escrita Escrita Escrita Leitura/Escrita

Função Initialization Command Word 1 (ICW1) Operation Command Word 2 (OCW2) Operation Command Word 3 (OCW3) Interrupt Request Register (IRR) In-Service Register (ISR) Operation Command Word 2 (OCW2) Operation Command Word 3 (OCW3) Operation Command Word 4 (OCW4) Interrupt Mask Register (IMR)

Tabela 17-5 – Endereços/Registradores para o PIC2

O PIC 8259 oferece várias outras características que não são utilizadas pelo PC. Este também oferece suporte para os microprocessadores MCS-80/85. Todo o cuidado que se deve ter com o seu uso nos PCs é se o sistema está sendo executado no modo de PIC único, ou no modo Cascateado (mais de um PIC), e se a ICW4 é necessária. Caso o ICW4 não esteja sendo utilizado, então todos os seus bits devem ser setados para zero. No caso de estar utilizando no modo 8086, deve ser enviado um ICW4.

17.8.1.

Initialization Command Word 1 (ICW1)

Caso o PIC tenha sido resetado, deverá ser inicializado com os comandos de inicialização 2 a 4 (Initialization Command Words - ICW) antes que este aceite e processe as requisições de interrupção. A Tabela 17-6 mostra as possibilidades de programação de ICW1. Bit(s) 7:5 4 3 2 1 0

Função Modo de Vetor de Endereços de Interrupção para MCS 80/85 Deve ser setado para 1 para ICW1 1 Interrupções disparadas por nível 0 Interrupções disparadas por borda 1 Intervalo entre endereços de 4 0 Intervalo entre endereços de 8 1 PIC único 0 PIC cascateado 1 ICW4 deve ser enviado

280

17

I N T E R R U P Ç Õ E S

0

ICW4 não necessário Tabela 17-6 – ICW1

17.8.2.

Initialization Command Word 2 (ICW2)

A Initialization Command Word 2 (ICW2) seleciona qual informação do vetor será liberada no barramento, durante o segundo pulso INTA. Usando no modo 8086, somente os bits 7:3 serão necessários. No caso 00001000 (0x08) para o PIC1 e 01110000 (0x70) para o PIC2. No caso em que seja necessário realocar a Tabela de Vetor de IRQ, poderá ser utilizado este registrador. Bit 7 6 5 4 3 2 1 0

Modo 8086/80/8080 I7 I6 I5 I4 I3 -

Modo MCS 80/85 A15 A14 A13 A12 A11 A10 A9 A8

Tabela 17-7 – ICW2

17.8.3.

Initialization Command Word 3 (ICW3)

Existem dois diferentes ICW3s. Uma é utilizada, se o PIC é mestre, enquanto que a outra é utilizada pelos escravos. A tabela a seguir mostra o ICW3 para o mestre. Bit 7 6 5 4 3 2 1 0

Função IR7 está IR6 está IR5 está IR4 está IR3 está IR2 está IR1 está IR0 está

conectado conectado conectado conectado conectado conectado conectado conectado

num num num num num num num num

escravo escravo escravo escravo escravo escravo escravo escravo

Tabela 17-8 – ICW3 para o PIC Mestre

Para o dispositivo escravo: Bits 7 6 5 4 3 2:0

Função Reservado. Setado para Reservado. Setado para Reservado. Setado para Reservado. Setado para Reservado. Setado para Identificação do Escravo 000 Escravo 0 001 Escravo 1 010 Escravo 2 011 Escravo 3 100 Escravo 4 101 Escravo 5 110 Escravo 6 111 Escravo 7

zero zero zero zero zero

Tabela 17-9 – ICW3 para dispositivos escravos

281

17

I N T E R R U P Ç Õ E S

17.8.4.

Initialization Command Word 4 (ICW4)

Como foi visto anteriormente, muitas das funções especiais do PIC 8259 não são utilizadas em um PC. Não é utilizado o modo Special Fully Nested Mode, de forma que o bit é setado em zero. Assim também é utilizado o modo não-bufferizado e EOI normal, setando os bits correspondentes em zero. O único item que deve ser setado é o modo 8086/8080 Mode, que está localizado no bit 0. Bits 7 6 5 4 3:2

1 0

Função Reservado. Setado para zero Reservado. Setado para zero Reservado. Setado para zero 1 Specially Fully Nested Mode 0 Not Specially Fully Nested Mode 0x Non-Buffered Mode 10 Buffered Mode Slave 11 Buffered Mode Master 1 Auto EOI 0 Normal EOI 1 8086/8080 Mode 0 MCS-80/85 Tabela 17-10 – ICW4

17.8.5.

Operation Control Word 1 (OCW1)

Uma vez que tenham sido enviadas todas as palavras de comando de inicialização para o PIC, então podem-se enviar as palavras de controle de operação (Operation Control Words), em qualquer ordem e a qualquer momento durante a operação do PIC. Estas palavras de comandos de controle são mostradas nas seguintes seções. A Operation Control Word 1 mostrada a seguir, é utilizada para mascarar as entradas do PIC. Bit 7 6 5 4 3 2 1 0

PIC2 Mascara Mascara Mascara Mascara Mascara Mascara Mascara Mascara

IRQ15 IRQ14 IRQ13 IRQ12 IRQ11 IRQ10 IRQ09 IRQ08

PIC1 Mascara Mascara Mascara Mascara Mascara Mascara Mascara Mascara

IRQ7 IRQ6 IRQ5 IRQ4 IRQ3 IRQ2 IRQ1 IRQ0

Tabela 17-11 – OCW1

17.8.6.

Operation Control Word 2 (OCW2)

O registrador Operation Control Word 2 seleciona como o funcionará o Fechamento de Interrupção (End of Interrupt – EOI). A única coisa que interessa realmente neste registrador é o comando EOI não-específico, o qual deve ser enviado na finalização das ISRs novas. Bits 7:5

Função 000 001 010 011

Rotate in Auto EOI Mode (Clear) Non specific EOI Reserved Specific EOI

282

17

I N T E R R U P Ç Õ E S

4 3 2:0

100 Rotate on Auto EOI Mode (Set) 101 Rotate on Non-Specific EOI 110 Set Priority Command (Use bits 2:0) 111 Rotate on Specific EOI (Use bits 2:0) Deve ser zero Deve ser zero 000 Act on IRQ 0 or 8 001 Act on IRQ 1 or 9 010 Act on IRQ 2 or 10 011 Act on IRQ 3 or 11 100 Act on IRQ 4 or 12 101 Act on IRQ 5 or 13 110 Act on IRQ 6 or 14 111 Act on IRQ 7 or 15 Tabela 17-12 – OCW2

17.8.7.

Operation Control Word 3 (OCW3)

Os bits 0 e 1 do Operation Control Word 3 são os mais importantes para quem programa o PC. Estes dois bits habilitam a leitura do status do registrador de requisição de interrupção, Interrupt Request Register (IRR) e do In-Service Register (ISR). Isto é feito setando os bits apropriados de forma correta, e pela leitura do registrador no endereço de Base. Por exemplo, se for necessária a leitura do ISR (InService Register), então pode-se setar ambos os bits 1 e 0 para 1. A leitura seguinte no registrador de base, (0x20 para o PIC1 ou 0xA0 para o PIC2) retornará o status do registrador In-Service. Bits Função 7 Deve ser setado para zero 6:5 00 Reservado 01 Reservado 10 Reset Special Mask 11 Set Special Mask 4 Deve ser setado para zero 3 Deve ser setado para zero 2 1 Poll Command 0 No Poll Command 1:0 00 Reservado 01 Reservado 10 Next Read Returns Interrupt Request Register 11 Next Read Returns In-Service Register Tabela 17-13 – OCW3

17.9.

Programação do Timer do PC

Observar o seguinte exemplo de programação do timer do PC, para gerar interrupções em intervalos constantes de tempo. Este tipo de rotina é adequado para efetuar tarefas de forma periódica tais como transmissão e aquisição de dados, e temporizações especiais. #include #include #include /*.........................................................................*/ /* Variaveis e definicoes globais */ /* Programacao do timer 8253 040h - counter 0 041h - counter 1 042h - counter 2

283

17

I N T E R R U P Ç Õ E S

043h - control register Programacao da 8259 020h 021h - mascara de interrupcoes: 0-habilita, 1-mascara. */ #define #define #define #define

INTMASK 0x021 /* Localizacao da mascara de interrupcoes da 8259 TTICK 0x01C /* Localizacao do vetor de int da IRQ0 (timer tick) CTRL_TIMER_PORT 0x043 /* Porta de controle do timer 8253 DATA_TIMER0_PORT 0x040 /* Porta de dados do timer 0 do 8253

*/ */ */ */

void ConfigTimer(unsigned int); void RestoreConfig(void); unsigned int hbyte,ch; static char flag = 0 ;

/* Usados apenas nas IRQ

*/

17

void main(void){ unsigned int i = 0; unsigned int segundo = 0; ConfigTimer(100);

//

while(!kbhit()){ if(flag){ printf("%u\n",i); i++; flag = 0; if(i==99) { printf("Segundo:%u\n",segundo++); i = 0; } } } RestoreConfig();

} /* Funcao: IRQ0 */ /* Entrada: nada */ /* Proposito: atender interrupcao IRQ0 gerada pelo timer do PC */ void interrupt IRQ0 (void){ flag = 1; } /*........................................................................*/ /* Funcao: ConfigTimer Configura o timer 0 para gerar interrupcoes em intervalos constantes. Reprograma a frequencia do timer 0 do 8253 do XT. Atencao: esta rotina altera o relogio de tempo real do DOS, para voltar a ter a hora certa, resetar o micro. Desvia vetor de interrupcao (001Ch : timer tick) da IRQ 0 para a rotina IRQ0. Entrada: frequencia de aquisicao desejada (19Hz = 2 && IRQ =12k

Tabela 20-1 – Comparação entre sistemas balanceados e desbalanceados

Drivers de Linha Desbalanceados Cada sinal transmitido em um sistema de transmissão desbalanceado RS-232, aparece no conector de interface como um nível de tensão, referenciado ao sinal de terra. Por exemplo, o dado transmitido (TD) a partir de um dispositivo DTE3 aparecerá na diferença de potencial entre os pinos 2 (TX) e 7 (GND) de um conector DB-25. Esta diferença de potencial será negativa se a linha estiver inativa (idle) e alternará entre os níveis negativos e positivos enquanto estiverem sendo enviados os dados, entre níveis de ±5 a ±15 volts. Um receptor RS-232 típico, opera dentro da faixa de tensões de +3 a +12 volts, e de –3 a –12 volts. O padrão RS-232 estabelece a faixa de níveis negativos como representação para o 1 lógico, e os níveis positivos para a representação do 0 lógico, como mostra a Figura 20-3. Interface RS-232

D

R

+25V

Faixa para o nível lógico 0 (Space) +3V Região de Transição

-3V Faixa para o nível lógico 1 (Mark) -25V

Figura 20-3 – Circuito de Interface RS-232

3

DTE: Data Terminal Equipment

336

Faixa do Receptor – Faixa máxima de operação

A

A P Ê N D I C E

A

-

P A D R Õ E S

D E

T R A N S M I S S Ã O

S E R I A L

Drivers de Linha Balanceados Num sistema diferencial balanceado, as tensões produzidas pelo driver aparecem através de um par de linhas de sinal que transmitem somente um sinal. A Figura 20-4 seguir mostra o símbolo esquemático de um driver de linha balanceado e as tensões esperadas. Um driver de linha balanceado pode produzir tensões de 2 a 6 volts entre os terminais de saída A e B, e ainda possuindo uma conexão como o sinal de terra (C). Embora seja apropriada uma conexão com o sinal de terra, esta não é utilizada pelo driver de linha balanceado na determinação do estado lógico da linha. Um driver de linha balanceado poderá ter também um sinal de entrada para habilitação, denominado sinal de ENABLE. O propósito deste sinal é o de permitir a conexão do driver com os pinos de saída A e B. Se o sinal de ENABLE estiver inativo, pode-se considerar que o driver está desconectado da linha de transmissão. Um driver RS-485 deverá ter obrigatoriamente o sinal de controle ENABLE. Um driver RS-422 poderá ter este sinal, mas nem sempre é necessário. A condição de desconectado (ou desabilitado) do driver, é referenciada como sendo uma condição de tristate ou seja, em alta impedância. +6V Faixa permissível

A

+2V

Tens ão VAB

B Habilita (Opcional para RS-422 Obrigatório para RS485)

C

-2V

Faixa permissível -6V

Figura 20-4 – Driver de Linha Diferencial Balanceado

Receptores Balanceados Um receptor de linha diferencial balanceada detecta o nível de tensão da linha de transmissão através de duas linhas de entrada, A e B. Este também possui um sinal de terra (C) que é necessário para efetuar uma conexão apropriada com a interface. A Figura 20-5 mostra o esquema de um receptor de linha diferencial balanceado. Neste esquema podem ser observados os níveis de tensão de operação. Se a tensão de entrada diferencial Vab for maior que +200 mV, o receptor reconhecerá um estado lógico específico no seu terminal de saída. Se a tensão de entrada estiver menor que –200 mV, o receptor criará uma tensão de estado lógico inverso no seu terminal de saída. Na figura são mostrados os níveis de tensão de entrada do receptor. Para prever atenuações na linha de transmissão, é requerida uma faixa de operação entre 200 mV e 6 V.

337

A

A P Ê N D I C E

A

½Vi

½Vi

-

P A D R Õ E S

D E

T R A N S M I S S Ã O

S E R I A L

A

+6V

+Vi

B

+200mV VCM

C -200mV

-Vi

VCM = Tensão de entrada de Modo comum Faixa permitida para VCM : -7V < VCM < +7

-6V

Figura 20-5 – Receptor de Linha Diferencial Balanceado

Padrões de Transmissão TIA/EIA A Electronic Industry Association (EIA) e a Telecommunications Industry Association (TIA) são as associações que desenvolveram padrões para simplificar as interfaces nos sistemas de comunicação de dados. Os padrões são destinados ao uso de interfaces em Data Terminal Equipment/Data Circuit-terminating Equipment (DTE/DCE - Equipamentos terminais de dados). O exemplo clássico de uma interface DTE/DCE é uma interface de um terminal para uma interface serial de modem. Embora, os padrões não são limitados ao uso exclusivo das interfaces DTE/DCE. De fato, muitos dos padrões são usualmente utilizados em uma ampla variedade de aplicações. Alguns exemplos incluem as interfaces de discos rígidos, barramentos de controle de chão-de-fábrica, e barramentos genéricos de I/O. Inicialmente a EIA classificou os padrões com o prefixo "RS", que os identificava como Recommended Standard (padrão recomendado). Atualmente o prefixo foi substituído como "TIA/EIA", para ajudar a identificar a fonte do padrão. Além disto foi colocada uma letra no sufixo representando o nível de revisão do padrão. Por exemplo, TIA/EIA-232-E representa a quinta revisão do RS-232. Os padrões de transmissão de dados TIA/EIA cobrem as seguintes áreas: Padrões Completos de interface, Padrões Elétricos e Padrões de Qualidade do sinal. Os padrões Completos definem as especificações funcionais, mecânicas e elétricas. Os padrões Elétricos, como seu nome indica, definem as especificações elétricas. Os padrões de Qualidade do Sinal definem os termos e métodos para a medição da qualidade do sinal. Exemplos de cada tipo são listados abaixo. Padrões de Interface DTE/DCE Completos TIA/EIA-232-F TIA/EIA-530-A TIA/EIA-561 TIA/EIA-574 TIA/EIA-613 TIA/EIA-687 TIA/EIA-688 TIA/EIA-723 Padrões Elétricos Padrões Desbalanceados TIA/EIA-232-F (Seção 2) TIA/EIA-423-B TIA/EIA-562 338

A

A P Ê N D I C E

A

-

P A D R Õ E S

D E

T R A N S M I S S Ã O

S E R I A L

TIA/EIA-694 Padrões Balanceados TIA/EIA-422-B TIA/EIA-485-A TIA/EIA-612 TIA/EIA-644 Signal Quality Standards EIA-334-A EIA-363 EIA-404-A

Os padrões RS-232, RS-422 e RS-485 implementam sistemas digitais de transmissão de dados, sendo RS-232 um sistema desbalanceado, enquanto que os dois últimos, diferenciais balanceados. O propósito deste capítulo é o de descrever os principais elementos dos padrões RS-232, RS-422 e RS-485.

Padrões TIA/EIA Desbalanceados

Padrão TIA/EIA-232-F (RS-232) TIA/EIA-232-F é o padrão de interface mais antigo e mais amplamente conhecido. Este é um padrão Completo especificando os requisitos mecânicos (conectores), elétricos (características driver/receptor), e funcional (definição dos circuitos) para uma interface binária serial. Nas especificações elétricas, a norma especifica uma interface desbalanceada, unidirecional para comunicações ponto a ponto. O driver apresenta um slew-rate controlado, permitindo que o cabo seja visto como uma carga no lugar de uma linha de transmissão. Isto é devido ao tempo de transição do driver ser substancialmente maior que o atraso do cabo (velocidade x comprimento). A caga máxima capacitiva vista pelo driver é especificada como sendo de 2500 pF. A norma permite a operação de até 20 Kbps (19.2 Kbps). Para taxas maiores de transmissão são recomendadas as normas TIA/EIA-562 ou TIA/EIA-423-B. A Figura 20-6 ilustra uma aplicação típica, e a Tabela 20-2 lista os principais requisitos elétricos. Algumas características importantes deste padrão são: Terminação Única Interface Ponto a Ponto Grande faixa de saída entre uma polaridade e outra Slew-rate controlado Interface totalmente definida Taxa máxima de transmissão de 20 Kbps.

Figura 20-6 - Aplicação Típica TIA/EIA-232-F

339

A

A P Ê N D I C E

A

-

P A D R Õ E S

D E

Parâmetro

T R A N S M I S S Ã O

S E R I A L

EIA RS-232 Condições

Min

Tensão de Saída a circuito aberto Tensão de saída com carga Resistência de saída do driver, Desconectado Corrente de saída do driver de curtocircuito Slew Rate da saída do driver Capacitância máxima de carga Resistência de entrada do receptor

3 KΩ \n"); while (!kbhit()) { CONVERSIONS = CONVERSIONS + 1; /* CONTINUOUSLY READ CHANNEL0 */ outportb(PORTB, 7); /* RD, CS, WR ALL HIGH */ delay(1); outportb(PORTB, 3); /* BRING CS LOW */ delay(1); outportb(PORTB, 2); /* BRING RD LOW */ delay(1); outportb(PORTB, 0); /* BRING WR LOW */ delay(1); /* ADC'S INTERRUPT SHOULD GO PULSE, I.E. HIGH TO LOW */ /* RESULT OF PREVIOUS CONVERSION ON D0-D7 */ outportb(PORTB, 2); /* SET WR HIGH */ delay(1); outportb(PORTB, 3); /* SET RD HIGH TOO */ delay(1); outportb(PORTB, 7); /* SET CS HIGH TOO */ delay(1);

509

Luis Fernando Espinosa Cocian

A P Ê N D I C E

F

-

E X E M P L O S

D E

A P L I C A Ç Ã O

/* ADC'S INTERRUPT WILL GO HIGH TO LOW BACK TO HIGH */ outportb(PORTB, 3); /* BRING CS LOW */ delay(1); outportb(PORTB, 2); /* BRING RD LOW */ delay(1); /*

ADC'S INTERRUPT WILL GO LOW TO HIGH */

outportb(PORTB, 3); delay(1); outportb(PORTB, 7); delay(1);

/* BRING RD HIGH AGAIN */ /* BRING CS HIGH TOO */

/* READING THE RESULT OF LAST CONVERSION */ CHANNEL0 = inportb(PORTA); delay(1); VOLTAGE0 = CHANNEL0 / 255.0 * RV; TEMP0 = VOLTAGE0 * 100.0; /* SINCE LM34 IS 100 DEG.F PER VOLT */ gotoxy(1,12); cprintf("CHANNEL 0 READS = %d\n", CHANNEL0); gotoxy(1,13); cprintf("VOLTMETER READS = %+3.3f V", VOLTAGE0); gotoxy(1,14); cprintf("TEMPERATURE IS = %+3.3f DEG F", TEMP0); delay(10); /* 10 msec delay */ gotoxy(1,16); cprintf("NO. OF CONVERSIONS = %d", CONVERSIONS); }; gotoxy(1,20); cprintf("FINISHED\n"); }; /* end of main */ void LoadMux(int PORTA, outportb(PORTA, 8); outportb(PORTB, 7); outportb(PORTB, 3); delay(1); outportb(PORTB, 1); delay(1); outportb(PORTB, 3); delay(1); outportb(PORTB, 7);

int PORTB) { /* load MUX onto ADC, ch 0, single-ended = 8 dec */ /* RD, WR, CS all high */ /* CS brought low */ /* now WR brought low */ /* now WR broght hi */ /* now XS brough hi, MUX should be on ADC */

/* NB: ADC interrupt will pulse low then high */ /* this pulses C.6 (ACK) and toggles 8255's ACK line */ delay(1); }; /* end of LoadMux */ void StartFirst(int PORTA, int PORTB) { /* Start 1st convers., read PORT A */ float RV; /* USES A +5V REFERENCE VOLTAGE ON ADC */ int CHANNEL0; /* Temperature sensor on channel 0 */ float VOLTAGE0; /* Analog voltage read on channel 0 */ RV = 5.0; gotoxy(1,5); cprintf("STARTING FIRST CONVERSION...\n"); outportb(PORTB, 3); /* BRING CS LOW */ delay(1); outportb(PORTB, 2); /* BRING RD LOW */ delay(1); outportb(PORTB, 3); /* BRING RD HIGH */ delay(1); outportb(PORTB, 7); /* BRING CS HIGH */ delay(1); CHANNEL0 = inportb(PORTA); VOLTAGE0 = (CHANNEL0 / 255.0) * RV; gotoxy(1,6); cprintf("CHANNEL 0 READS = %d", CHANNEL0); gotoxy(1,7); cprintf("VOLTMETER READS = %+3.3f V", VOLTAGE0); gotoxy(1,9); cprintf("\n"); getche(); }; /* end of StartFirst */ Código 25-1 – Programa ADC

F 510

A P Ê N D I C E

F

-

E X E M P L O S

D E

A P L I C A Ç Ã O

DAC Este programa pede a inserção de um número decimal. O valor é enviado para uma porta onde deverá estar devidamente conectado um conversor D/ª /* FILE: DAC.C DESC: Prompt user for decimal word. Returns associated analog voltage */ #include #include #include #include

/* outportb, inportb defined here */ /* formatted text functions defined here */

void main(void) { int Volt; int BASEADDR; int PORTA, PORTB, PORTC; int CNTRL; int Choice; int PORT; clrscr(); /* clear screen */ window(5,5,75,30); /* set up text window */ gotoxy(1,1); cprintf("Enter Base Address (decimal) e.g. 608\n"); gotoxy(1,2); scanf("%d", &BASEADDR); PORTA = BASEADDR; PORTB = BASEADDR + 1; PORTC = BASEADDR + 2; CNTRL = BASEADDR+3; outportb(CNTRL, 128); /* configure all ports for output */ do { gotoxy(1,4); cprintf("Enter Port Choice\n"); gotoxy(1,5); cprintf("(1) Port A\n"); gotoxy(1,6); cprintf("(2) Port B\n"); gotoxy(1,7); cprintf("(3) Port C\n"); gotoxy(1,8); scanf("%d", &Choice); if(Choice < 1 || Choice > 3) { clrscr(); gotoxy(1,1); cprintf("Enter 1, 2 or 3\n"); }; } while (Choice < 1 || Choice > 3); switch (Choice) { case 1 : PORT = PORTA; break; case 2 : PORT = PORTB; break; case 3 : PORT = PORTC; break; }; gotoxy(1,18); cprintf("Enter 999 to quit\n"); gotoxy(1,10); cprintf("Input Decimal word (0 = -5V, 255= +5V \n"); gotoxy(1,11); while(1) { scanf("%d", &Volt); if(Volt == 999) { clrscr(); gotoxy(1,1); cprintf("Goodbye!\n"); outportb(PORT, 0); /* quitting */ exit(0); }; outportb(PORT, Volt); }; } /* end of main */ Código 25-2 – Programa DAC

Teclado Efetua a leitura de um teclado telefônico conectado à porta paralela. /* FILE: KEYPAD.C

511

F

A P Ê N D I C E

F

-

E X E M P L O S

DESC: Reads keypad */ #include #include #include #include

D E

A P L I C A Ç Ã O

/* outportb, inportb defined here */ /* formatted text functions defined here */

void WhichKey(int); void main(void) { int BASEADDR; int PORTA, PORTB, PORTC; int CNTRL; int NUMBER; clrscr(); /* clear screen */ window(5,5,75,30); /* set up text window */ gotoxy(1,1); cprintf("Enter Base Address (decimal) e.g. 608\n"); gotoxy(1,2); scanf("%d", &BASEADDR); PORTA = BASEADDR; PORTB = BASEADDR + 1; PORTC = BASEADDR + 2; CNTRL = BASEADDR+3; outportb(CNTRL, 155); /* configure all ports for input */ gotoxy(1,15); cprintf("Press ANY key on your keyboard to quit\n"); gotoxy(1,4); cprintf("HIT A KEY ON YOUR KEYPAD\n"); while(!kbhit()) { do { NUMBER = inportb(PORTC); } while ( (NUMBER 100) { DutyCycle = 100; gotoxy(1,20); cprintf("Can't go faster"); delay(200); gotoxy(1,20); cprintf(" "); }; gotoxy(1,13); cprintf("Going faster...\n"); Enable = 1; pwm(PORTA, DutyCycle, Enable, Phase); break; case 115

: /* 115 ASCII is s */ /* decrease speed by 10% DC */ DutyCycle = DutyCycle - 5; if(DutyCycle < 0) { DutyCycle = 0; gotoxy(1,20); cprintf("Can't go slower"); delay(200); gotoxy(1,20); cprintf(" "); }; gotoxy(1,13); cprintf("Going slower...\n"); Enable = 1; pwm(PORTA, DutyCycle, Enable, Phase); break;

case 114 : /* 114 ASCII is r */ /* reverse direction at present DC */ Enable = 1; if(Phase == 0) { Phase = 2; } else if(Phase ==2) { Phase = 0; }; pwm(PORTA, DutyCycle, Enable, Phase); gotoxy(1,13); cprintf("Reversing.....\n"); break; case 113 : /* 113 ASCII is q */ gotoxy(1,22); cprintf("Quitting"); outportb(PORTA, 0); outportb(PORTB, 0); outportb(PORTC, 0); exit(0); break; }; /* end of switch */ gotoxy(14,9); } while(1); /* end of do */ }; /* end of main */ void pwm(int PORTA, int DutyCycle, int Enable, int Phase) { int OnTime, OffTime, TotalTime; TotalTime = 100; /* 100 msec */ OnTime = (int)(TotalTime * DutyCycle / 100); OffTime = (int)(TotalTime - OnTime); outportb(PORTA, Enable+Phase); delay(OnTime); Enable = 0; outportb(PORTA, Enable+Phase); delay(OffTime); gotoxy(1,10); cprintf("Duty Cycle is %3d", DutyCycle); return; }; /* end of pwm */ Código 25-5 – Programa PWM

515

F

A P Ê N D I C E

F

-

E X E M P L O S

D E

A P L I C A Ç Ã O

Relé Utiliza um latch 74LS374 para ligar um relé na porta paralela. /* FILE: RELAY.C DESC: Uses the 74374 latch to turn on a relay linked with port A.0 */ #include #include #include #include

/* outportb, inportb defined here */ /* formatted text functions defined here */

void main(void) { int Sgnal; int BASEADDR; int PORTA, PORTB, PORTC; int CNTRL; clrscr(); window(5,5,75,30);

/* clear screen */ /* set up text window */

gotoxy(1,1); cprintf("Enter Base Address (decimal) e.g. 608\n"); gotoxy(1,2); scanf("%d", &BASEADDR); PORTA = BASEADDR; PORTB = BASEADDR + 1; PORTC = BASEADDR + 2; CNTRL = BASEADDR + 3; outportb(CNTRL, 128); /* configure all ports for output */ outportb(PORTB, 2); /* (B.0) CLK low and (B.1) OE is high */ while(1) { gotoxy(1,4); cprintf("Port A.1 has normally open relay\n"); gotoxy(1,5); cprintf("Enter (1) to turn on\n"); gotoxy(1,6); cprintf("Enter (2) to turn off\n"); gotoxy(1,7); cprintf("Enter (3) to turn off and quit\n"); gotoxy(1,8); cprintf("Selection => "); scanf("%d", &Sgnal); switch (Sgnal) { case 1 : outportb(PORTA, 0); /* A.0 is low thus relay enabled */ outportb(PORTB, 1); /* CLK high and OE low */ gotoxy(1,10); cprintf("Load (Motor) is on \n"); break; case 2 : outportb(PORTA, 1); /* A.0 is high thus relay off */ outportb(PORTB, 2); /* CLK low and OE high */ gotoxy(1,10); cprintf("Load (Motor) is off\n"); break; case 3 : outportb(PORTB, 2); /* OE is now high */ gotoxy(1,20); cprintf("Exiting\n"); exit(0); break; }; /* end of select */ if(Sgnal3) { gotoxy(1,15); cprintf("Enter 1, 2 or 3\n"); }; }; /* end of while */ }; /* end of main */ Código 25-6 – Programa Relé

Motor de Passo Controla um motor de passo /* FILE: STEPPER.C DESC: Speed and Positioning options for Stepper Motor Port A has 5 lines attached and described as follows: OP = PHASE Line A.0 1 enable / 0 disable HS = HALF STEP Line A.1 2 enable / 0 disable SI = STEP INPUT Line A.2 4 enable / 0 disable

516

F

A P Ê N D I C E

F

-

E X E M P L O S

DR = DIRECTION OE : OUTPUT ENABLE

D E

Line A.3 Line A.4

A P L I C A Ç Ã O

8 enable / 0 disable 16 enable / 0 disable

*/

#include #include #include #include

/* outportb, inportb defined here */ /* formatted text functions defined here */

int Calibrate(int); void StepTheMotor(int, int, int); void Selection(int, int, int); void MoveToFixedAngle(int, int, int); void Continuous(int, int, int); void main(void) { int Sgnal; int BASEADDR; int PORTA, PORTB, PORTC; int CNTRL; int Choice; int StepsPerRev; int DR = 0; clrscr(); /* clear screen */ window(5,5,75,30); /* set up text window */ gotoxy(1,1); cprintf("Enter Base Address (decimal) e.g. 608\n"); gotoxy(1,2); scanf("%d", &BASEADDR); PORTA = BASEADDR; PORTB = BASEADDR + 1; PORTC = BASEADDR + 2; CNTRL = BASEADDR + 3; outportb(CNTRL, 128); /* configure all ports for output */ outportb(PORTB, 0); /* Ports B and C not used, so just set to 0 */ outportb(PORTC, 0); StepsPerRev = Calibrate(PORTA); Selection(PORTA, StepsPerRev, DR); } /* end of main */ int Calibrate(int PORTA) { int GetKey; int StepsPerRev; int DR = 0; int WaitSomeTime = 0; /* determine how many steps per revolution stepper motor */ gotoxy(1,5); cprintf("--CALIBRATION--\n"); gotoxy(1,7); cprintf("Hit the key to step the motor.\n"); gotoxy(1,9); cprintf("Count the number of times you hit \n"); gotoxy(1,10); cprintf("for motor to rotate 1 revolution\n"); gotoxy(1,12); cprintf("Hit q then to quit\n"); do { StepTheMotor(PORTA, DR, WaitSomeTime); gotoxy(1,14); GetKey = getch(); } while (GetKey != 113 && GetKey != 81); /* 113 is ASCII q */ gotoxy(1,16); cprintf("Number of times did you hit => \n"); gotoxy(40,16); scanf("%d", &StepsPerRev); gotoxy(1,18); cprintf("Is %d Correct? (y)es, (n)o \n", StepsPerRev); gotoxy(30,18); GetKey = getche(); if(GetKey == 121 || GetKey == 89) { /* 121 is y and 89 is Y in ASCII */ clrscr(); return(StepsPerRev); } else { clrscr(); Calibrate(PORTA); }; }; /* end of Calibrate */ void Selection(int PORTA, int StepsPerRev, int DR) { /* Motor speed and position options */ int DegPerStep; int Choice; clrscr(); gotoxy(1,4); cprintf("Motor requires %d steps per rev\n", StepsPerRev);

517

F

A P Ê N D I C E

F

-

E X E M P L O S

D E

A P L I C A Ç Ã O

DegPerStep = (int)(360 / StepsPerRev); gotoxy(40,4); cprintf(" => thus 1 step = %d degrees\n", DegPerStep); do { gotoxy(1,6); cprintf("(1) To rotate to a certain angle clockwise\n"); gotoxy(1,7); cprintf("(2) To rotate to a certain angle counter-clockwise\n"); gotoxy(1,8); cprintf("(3) To rotate continuously - with speed options\n"); gotoxy(1,9); cprintf("(4) To quit\n"); gotoxy(1,10); cprintf("Selection =>\n"); gotoxy(14,10); scanf("%d", &Choice); switch(Choice) { case 1 : DR = 0; MoveToFixedAngle(PORTA, DR, DegPerStep); break; case 2 : DR = 8; MoveToFixedAngle(PORTA, DR, DegPerStep); break; case 3 : Continuous(PORTA, DR, StepsPerRev); break; case 4 : outportb(PORTA, 16); /* shutdown all signals */ gotoxy(1,22); cprintf("Quitting\n"); exit(0); default : gotoxy(1,14); cprintf("Choose 1, 2, 3, or 4\n"); break; }; /* end select */ } while (1); /* can only exit Selection if user selects 4 */ }; /* end of Selection */

void MoveToFixedAngle(int PORTA, int DR, int DegPerStep) { int Degrees; int NumberOfSteps; char *GetKey[2]; int WaitSomeTime = 0; int i; clrscr(); if(DR == 0) { gotoxy(1,4); cprintf("Will step CW fixed number of degrees\n"); } else { /* DR is 8 */ gotoxy(1,4); cprintf("Will step CCW fixed number of degrees\n"); }; gotoxy(1,5); cprintf("Enter number of degrees => "); gotoxy(28,5); scanf("%d", &Degrees); gotoxy(1,7); cprintf("Will step %d degrees", Degrees); gotoxy(1,8); cprintf("Hit a key to start"); while (!kbhit()); NumberOfSteps = (int)(Degrees / DegPerStep); for(i = 1; i = 100) { WaitSomeTime = 100; gotoxy(1,10); cprintf("Can't go faster"); SpeedGrade = 20; } else { gotoxy(1,10); cprintf("Going faster..."); SpeedGrade = SpeedGrade + 1; }; gotoxy(1,12); cprintf("speed grade = %2d", SpeedGrade); StepTheMotor(PORTA, DR, WaitSomeTime); break; case 115 : /* hit s key */ WaitSomeTime = WaitSomeTime - 5; if(WaitSomeTime