Escolar Documentos
Profissional Documentos
Cultura Documentos
Niterói
2016
HUGO DE FREITAS BERETA
Orientador(a):
Rafael Burlamaqui Amaral
NITERÓI
2016
Ficha Catalográfica elaborada pela Biblioteca da Escola de Engenharia e Instituto de Computação da UFF
CDD 005.741
HUGO DE FREITAS BERETA
Banca Examinadora:
_________________________________________
Prof. Rafael Burlamaqui Amaral, Msc. – Orientador
CEFET/RJ - Centro Federal de Educação Tecnológica Celso Suckow da Fonseca
_________________________________________
Prof. Ubiratam Carvalho de Paula Junior, Dr. – Avaliador
UFRRJ - Universidade Federal Rural do Rio de Janeiro
_________________________________________
Prof. Gleiph Ghiotto Lima de Menezes, Msc. – Avaliador
UFF - Universidade Federal Fluminense
Dedico este trabalho à meus pais, esposa e
filho, que sempre almejaram por mais essa
realização.
AGRADECIMENTOS
RESUMO......................................................................................................................7
ABSTRACT...................................................................................................................8
LISTA DE ILUSTRAÇÕES............................................................................................9
LISTA DE TABELAS...................................................................................................10
LISTA DE GRÁFICOS................................................................................................11
LISTA DE ABREVIATURAS E SIGLAS......................................................................12
1 INTRODUÇÃO.....................................................................................................15
2 TRABALHOS RELACIONADOS..........................................................................19
2.1 TUKOLK........................................................................................................19
2.2 ETS2 TELEMETRY WEB SERVER 3.2.5 & MOBILE DASHBOARD..........20
3 FUNDAMENTAÇÃO TEÓRICA...............................................................................22
3.1 O KIT DE DESENVOLVIMENTO DE SOFTWARE (SDK)...........................22
3.2 A API DE TELEMETRIA................................................................................25
3.3 ARDUINO E A COMUNICAÇÃO SERIAL.....................................................28
3.3.1 O ARDUINO.........................................................................................29
3.3.2 A COMUNICAÇÃO SERIAL................................................................30
4 O PLUGIN...............................................................................................................35
4.1 O JOGO E A API DE TELEMETRIA.............................................................36
4.2 A INICIALIZAÇÃO DO PLUGIN....................................................................38
4.3 O PLUGIN E A COMUNICAÇÃO SERIAL....................................................47
5 A PLACA CONTROLADORA ARDUINO.................................................................50
5.1 RECEPCIONANDO OS DADOS da porta serial..........................................50
5.2 EXIBINDO AS INFORMAÇÕES DE TELEMETRIA.....................................52
5.2.1 O COMPUTADOR DE BORDO...........................................................53
5.2.2 O GERENCIAMENTO DE LEDS DO PAINEL.....................................54
5.2.3 COMPONENTES ANALÓGICOS.......................................................59
5.3 ENVIANDO COMANDOS AO JOGO............................................................60
6 O PROTÓTIPO........................................................................................................64
6.1 O CIRCUITO DE SAÍDA...............................................................................65
6.1.1 O SISTEMA DE LEDS.........................................................................66
6.1.2 OS INSTRUMENTOS..........................................................................67
6.1.3 O COMPUTADOR DE BORDO...........................................................68
6.2 O CIRCUITO DE ENTRADA.........................................................................69
6.3 UMA VISÃO GERAL DA ESTRUTURA DO PROTÓTIPO...........................70
CONCLUSÕES E TRABALHOS FUTUROS.............................................................73
REFERÊNCIAS BIBLIOGRÁFICAS...........................................................................75
APÊNDICE.................................................................................................................80
APÊNDICE A..............................................................................................................80
APÊNDICE B..............................................................................................................81
15
1 INTRODUÇÃO
2 TRABALHOS RELACIONADOS
2.1 TUKOLK
vasta seção de projetos em Arduino, traz uma grande quantidade de jogos similares
ao TuKolk, criados com a plataforma de desenvolvimento de hardware livre, dos
mais variados tipos e com os mais variados componentes eletrônicos e sensores
compatíveis com a placa[36].
O ponto de convergência entre o TuKolk e este trabalho consiste na
criação de um dispositivo de jogo criado com Arduino e componentes eletrônicos
acessíveis, que pode até mesmo ser montado pelo próprio jogador interessado.
Embora o TuKolk tenha essa proposta interessante de criação de um console e jogo
com a plataforma Arduino, a motivação de uso da plataforma neste trabalho diverge
por visar a confecção de um controlador que gerencie comandos e informações de
um simulador de caminhões com um grau considerável de complexidade, onde
recomenda-se o uso de um computador com 6GB de memória RAM e um
processador Quad-Core 3.0 GHz[33].
como uma das principais produções de sucesso criadas por jogadores que utilizam o
SDK fornecido pela empresa para melhorar a experiência dos jogadores com o jogo.
O trabalho de Funbit consiste em um plugin escrito em C++ que se utiliza
do SDK fornecido pela SCS Software para ler informações do ETS2 e disponibilizá-
las a um Web Server, escrito em C#, que exibe os dados ao jogador de forma
amigável em qualquer navegador de internet disponível, seja em dispositivos móveis
ou até mesmo em outros computadores. O sistema utiliza skins (opções diferentes
de visuais para o programa) que simulam um painel de caminhão no navegador e
possibilita a personalização pelo jogador.
O plugin desenvolvido para o projeto envia os dados de telemetria para o
servidor web através de arquivos mapeados na memória (Memory-Mapped File), ou
seja, cria-se um arquivo mapeado na memória virtual que possibilita que vários
processos escrevam e leiam dados neste[24].
A ideia de criação de um painel externo, ainda que virtual, a utilização de
um plugin escrito com o SDK fornecido para criar o enlace entre jogo e dispositivo
são os pontos em comum com este trabalho de conclusão. O ponto de divergência
deste trabalho em relação ao projeto do Funbit consiste na criação de um dispositivo
físico (painel de instrumentos), onde a técnica de compartilhamento das informações
de telemetria via arquivo mapeado em memória deixa de ser a mais viável e é
substituída pela comunicação serial entre o PC que roda o simulador e a placa
Arduino. Ressalta-se, ainda, que o dispositivo aqui criado não se limita a receber
informações do jogo, mas também envia comandos àquele.
22
3 FUNDAMENTAÇÃO TEÓRICA
DLL Aplicação
Função da DLL Ponteiro para a
Callback
Implementação
da Callback
Uma vez que plugin tenha extraído os dados de telemetria, pode realizar
algum processamento local (gestão de logs, por exemplo) ou enviá-los a algum outro
componente de software ou hardware conforme o objetivo proposto. Por exemplo, o
projeto do jogador Funbit, descrito no Capítulo 2 deste trabalho, utiliza-se de técnica
de arquivos mapeados em memória para fornecer os dados a um servidor web que,
por sua vez, disponibiliza-os via conexão TCP para acesso via navegador de
internet[20]. A SCS Software também disponibiliza junto a o seu kit de
desenvolvimento alguns exemplos de manipulação dos dados extraídos do jogo,
demonstrando o uso em arquivos de log e como distribuir os dados através do uso
de arquivos mapeados em memória.
No entanto, como o objetivo neste trabalho é utilizar os dados obtidos do
jogo para gerenciar um painel de comandos para o mesmo, uma nova abordagem
foi utilizada. Uma placa controladora conectada a uma porta USB do computador
onde o jogo roda recebe os dados do plugin via comunicação serial e os utiliza para
gerenciar o painel de comandos. A placa escolhida para o projeto foi a Arduino.
29
3.3.1 O ARDUINO
O plugin criado enviará os dados obtidos do jogo para uma placa Arduino.
Os dados serão transmitidos através de comunicação serial utilizando uma conexão
USB. A comunicação serial detém um conceito bem simples, que a diferencia
essencialmente da comunicação paralela. A porta serial envia e recebe bytes de
informações, um bit por vez[26], conforme ilustra a Figura 2, enquanto a paralela
envia 8 bits (1 byte) de uma só vez, conforme ilustra a Figura 3. Logo, a paralela tem
condições de enviar uma maior quantidade de dados em um menor tempo, porém
está limitada a curtas distâncias de conexões. Já a serial, envia uma menor massa
de dados em uma fração de tempo, mas permite conexões mais distantes devido à
característica do sinal[26].
Conexão Serial
Sentido da Transmissão
TX RX
Origem dos Destino dos
Dados bits Dados
TX RX
bits
Figura 3: Conexão paralela
4 O PLUGIN
Foi dito na Seção 3.1 do Capítulo 3 que os plugins escritos com o SDK
fornecido pela SCS Software para seus jogos devem ser implementados como uma
DLL. O sistema de modificações através de plugins criados pela empresa requer a
simples cópia da DLL criada para uma pasta pré-definida dentro do diretório raiz do
jogo. Ao ser inicializado, o jogo carrega todas as bibliotecas que estiverem naquela
pasta e exibe uma mensagem de alerta/confirmação de utilização de recursos do
SDK conforme a Figura 7, extraída diretamente do jogo. A partir de então, quando o
jogo quer acionar a API, ele efetua uma chamada à função de inicialização para o
plugin, o qual exporta uma série de funções requeridas pela API (callbacks).
Uma vez que o jogo esteja em execução, com o plugin carregado, é
possível reiniciar a API ou mesmo descarregar o plugin para carregar nova versão,
utilizando-se de linhas de comandos dentro do jogo. Isso permite manipular ou
atualizar o plugin para testes sem ser necessário fechar o jogo[15].
37
tenha sido executada com sucesso, o jogo então executa uma chamada à função de
finalização encerrando o ciclo da API de Telemetria.
segundo as especificações da versão 2.5 da UML[27]. Como seu nome bem sugere,
essa estrutura detém os parâmetros comuns de inicialização e callbacks para a
versão 1.00 da API de Telemetria. Sua primeira relação de dependência,
representada com uso de linha contínua, é de herança (generalização) com a
estrutura scs_telemetry_init_params_t, cujo objetivo é demonstrar que não se trata
de uma struct em C e que, portanto, é permitido conter métodos em sua definição. A
segunda relação de dependência, representada com uso de linha tracejada, ocorre
devido ao atributo common da estrutura de dados
scs_telemetry_init_params_v100_t ser definido pela também estrutura de dados
scs_sdk_init_params_v100_t[[27], p.38].
Os métodos contidos na estrutura de dados
scs_telemetry_init_params_v100_t são callbacks responsáveis pelo registro (ou
cancelamento de um registro) de eventos e canais de telemetria, possibilitando a
devida troca de informações com o jogo.
passa uma série de ponteiros para funções que estão contidas em seu código que
retornam as informações de telemetria ao plugin. Graças a esse nível
encapsulamento proporcionado pelo jogo e seu SDK, o desenvolvedor do plugin
pode registrar, por exemplo, um evento do jogo apenas utilizando parâmetros para a
callback respectiva, sem se importar em como o motor implementa esse método.
Porém, é importante ressaltar que uma callback também pode ser utilizada
no sentido inverso, ou seja, da DLL para o jogo. Para tanto, a DLL disponibiliza ao
jogo ponteiros para funções implementadas em seu corpo de código, ainda que não
exportadas pela via convencional (dllexport, em C++). A prática do uso de callback
no lugar de exportar funções é indicada para situações em que as tarefas são
executadas repetidamente[25].
Diante desse paradigma de implementação, quando a função de
inicialização da API é chamada, o plugin deve registrar as callbacks necessárias
para seu contexto de funcionamento. Isso se dá em duas etapas: a etapa de registro
dos eventos que se deseja capturar e a etapa de registro dos canais de telemetria
que se deseja obter.
O registro de eventos é efetuado através da callback “register_for_event”
contida nos parâmetros passados na função de inicialização. Com esse método,
escolhe-se o evento a ser registrado pelo plugin. Os eventos possíveis são cinco:
• Frame Start: Evento gerado antes dos dados de telemetria serem
incluídos no frame (quadro) de dados;
• Frame End: Evento gerado depois de todos os dados de telemetria
forem incluídos no frame de dados;
• Paused: Evento gerado quando o jogo é pausado (por exemplo,
quando está no menu do jogo), indicando que o jogo parou de
enviar dados de telemetria;
• Started: Evento gerado quando o jogador entra no modo de “dirigir”
no jogo, seja no início ou após efetuar uma pausa no jogo; e
• Configuration: Evento gerado quando alguma configuração do jogo
ou do veículo é alterada.
42
plugin para aquele evento específico. Em outras palavras, criar um registro para um
evento é passar ao motor do jogo ponteiros para funções contidas no plugin que
devem ser executadas quando um determinado evento ocorrer.
O diagrama de sequência contido na Figura 11 modela uma abstração da
tarefa de registro de eventos. Nos sequenciais 3 e 4 do diagrama, os parâmetros
event e callback da função register_for_event definem, respectivamente, o evento a
ser registrado pelo plugin e o ponteiro para uma função (callback) que o jogo deve
executar quando este evento ocorrer. Em caso de sucesso no registro do evento, a
função retorna a constante SCS_RESULT_ok, que equivale a 0. Um valor diferente
de zero indica uma falha no registro do evento. O registro de um único evento pode
ser suficiente, dependendo do objetivo do plugin. Portanto, o registro de eventos
adicionais é opcional, conforme demonstrado no diagrama.
com o valor hexadecimal 0xFF (255, em decimal). Esse byte tem a função de marcar
o início do pacote, otimizando o uso do buffer da porta serial e evitando possíveis
erros de leitura e de estouro de buffer. O segundo byte contém a versão do pacote
(PACKET_VER), a fim de garantir que emissor e receptor estejam manipulando a
mesma versão de pacote de dados. O terceiro byte (API_STATE) contém o estado
da API de Telemetria, indicando se está rodando ou em pausa. Se a API estiver
rodando, o plugin envia um byte chamado de STARTED_BYTE. Caso esteja em
pausa, o byte enviado é o PAUSED_BYTE. Este byte permite à placa receptora
Arduino identificar o estado da API e, a partir deste estado, definir seu
comportamento.
Após o cabeçalho, o restante das informações de telemetria são
adicionadas ao pacote, byte a byte. As informações booleanas de telemetria, que
indicam um estado (ligado ou desligado, conectado ou desconectado, etc), são
tratadas cada uma como um bit e empacotadas de 8 em 8 para serem enviadas em
um único byte.
Utilizando esta forma de empacotamento de bits, o plugin envia um byte
contendo o estado das luzes do veículo, como beacon, luz de estacionamento, seta
à esquerda, seta à direita, farol baixo, farol alto, luz de freio e luz de ré. Em outro
byte, ele envia o estado das luzes de advertência, tais como freio de
estacionamento, freio motor, pressão do ar baixa, pressão do ar em estado de
emergência, baixo nível de combustível, bateria em baixa voltagem, pressão do óleo
baixa, alerta de temperatura da água. Um terceiro byte fica responsável por
informações gerais do veículo, como uma indicação se o reboque está ou não
conectado, o estado dos limpadores de para-brisa, se a parte elétrica do caminhão
está ligada ou não e se o motor está em funcionamento ou não.
4
PWM, ou Pulse Width Modulation (Modulação por largura de pulso) é uma técnica para obter
resultados analógicos por meios digitais. Saiba mais em: https://www.arduino.cc/en/Tutorial/PWM
51
5
Saiba mais sobre bit shift com Arduino em <https://www.arduino.cc/en/Reference/Bitshift>
6
Saiba mais sobre bit wise com Arduino em <http://playground.arduino.cc/Code/BitMath>
53
estes 16 pinos livres, nenhum outro componente eletrônico poderia mais ser
conectado, visto que esgotaram-se os as entradas e saídas da placa.
Ao se deparar com o problema acima, alguns jogadores que vêm
desenvolvendo painéis semelhantes cujos projetos podem ser encontrados na
Internet, adicionam placas extras ao sistema ou optam por placas com maior
quantidade de pinos, como a Arduino Mega. Tais soluções não são ideais, visto que
adicionar placas extras ao sistema, além de encarecê-lo, vai ocasionar maior
trabalho e custo de recursos para tratar a troca de informações entre as placas, além
de prováveis ajustes na implementação do plugin. E optar por placas como Arduino
Mega, levaria à perda do recurso de simulação de mouse, teclado ou joystick, já que
este modelo não emula tais recursos.
Para resolver tal questão, a solução escolhida neste projeto foi utilizar um
conjunto de circuitos integrados (CI) para expandir as portas do Arduino. Para o caso
dos LEDs, o CI utilizado foi o 74HC595. Este CI tem como função, converter uma
entrada de 8 bits serial em uma saída de 8 bits serial ou paralela, atuando como um
registrador de deslocamento (shift register).
Um shift register é um dispositivo que possibilita expandir entradas e
saídas de um microcontrolador. Em outras palavras, um microcontrolador se
comunica com um shift register utilizando informação serializada e este se encarrega
de disponibilizar essa informação de forma paralela em suas saídas. O contrário
também é verdadeiro, quando um shift register lê informações paralelas através de
suas entradas e disponibiliza-as ao microcontrolador de forma serializada[49].
Existem basicamente dois tipos de shift register, que são os do tipo SIPO
(Serial-In-Parallel-Out) e os do tipo PISO (Parallel-In-Serial-Out). O CI 74HC595 é do
tipo SIPO, ou seja, entrada serial com saída paralela. Ele é constantemente utilizado
para controlar um grande número de saídas, tais como LEDs. O tipo PISO, como o
CI 74HC165, é ideal para ler um conjunto de entradas de forma paralela (ex.:
botões) e disponibilizar os dados ao microcontrolador de forma serial[49].
Esses circuitos integrados são chamados de registradores de
deslocamento (shift register) devido à forma como os dados se deslocam através de
56
7
Circuitos sequenciais elementares capazes de armazenar a informação contida, ou seja,
funcionam como um elemento de memória que armazena um bit (nível lógico)
temporariamente[43].
57
antecessor na direção do bit menos significativo, ocupando seu lugar. Uma vez que
todos os bits tenham sido transmitidos ao registrador, um pulso na porta latch faz
com que os estados (HIGH ou LOW) de cada bit sejam devidamente entregues aos
respectivos pinos da saída paralela do registrador, apresentando o byte de uma só
vez[7].
A IDE do projeto Arduino possui a função nativa ShiftOut que encapsula o
procedimento acima descrito, simplificando a utilização do registrador de
deslocamento[10]. Portanto, é utilizando esse recurso de registradores de
deslocamento que a placa Arduino gerencia os LEDs responsáveis pelas
informações de luzes, indicadores e alertas do veículo. O painel conta com um
circuito criado com 3 CI 74HC595, o que representa um total de 24 saídas digitais. O
circuito é alimentado por uma fonte externa e as saídas são ativadas por meio de
transistores.
externa, enquanto a placa Arduino apenas gerencia sua entrada de sinal. Importante
ressaltar que os conectores de terra da fonte de tensão externa e da placa Arduino
devem estar conectados[9].
O protótipo deste trabalho utiliza dois servomotores para exibir as
informações de velocidade do caminhão (speed) e rotação do motor (engine_rpm).
Ambos são alimentados por uma fonte externa. A placa Arduino recebe as
informações do plugin e as coloca no servomotor convertidas em graus de rotação,
obedecidas as restrições de giro do eixo do motor.
Uma das propostas deste trabalho é que o painel criado não só receba as
informações do jogo, mas que também envie comandos para aquele, como
acionamento de freios auxiliares, freio de estacionamento, sinal de alerta, partida do
veículo, etc. Como o jogo não implementa uma API que receba comandos externos,
uma maneira viável de prover essa função seria emular o teclado e enviar as teclas
para o jogo, como se o jogador estivesse acionando-as via teclado. A placa Arduino
Leonardo já possui esse recurso nativo em seu microcontrolador. Porém, a proposta
neste trabalho é que a placa emule um joystick, de forma que o jogo o identifique
como um controlador e permita configurar seus comandos, independente de como
está a configuração do teclado no jogo.
Em 19 de novembro de 2015, o desenvolvedor Matthew Heironimous
(conhecido como Matthew H.) disponibilizou em seu blog sobre programação um
tutorial de como fazer para que a placas Arduino baseadas no microcontrolador
ATmega32u4 fossem detectadas pelo sistema operacional Windows como um joy-
stick e funcionasse como tal[18].
O simples download e inclusão da biblioteca desenvolvida por Matthew já
é suficiente para que a placa Arduino Leonardo seja detectada como um joystick e
possa ser normalmente configurado no sistema operacional e no jogo. No entanto,
61
para que a placa envie os comandos para o jogo, é necessário que os botões sejam
mapeados via código.
6 O PROTÓTIPO
necessário para uso antes mesmo de criar o modelo físico para experimentação.
Aliados à este modelo 3D criado, a criação de esquemas elétricos, simulação de
circuitos e experimentos com componentes eletrônicos através das ferramentas Ev-
ery Circuit8, Autodesk Circuits9 e Fritzing10, viabilizaram a elaboração dos circuitos
elétricos, inclusive facilitando os cálculos envolvendo os circuitos, componentes e
demais variáveis, sem exigências de profundos conhecimentos em eletrônica.
Para alimentação dos circuitos elétricos, foi utilizada uma fonte de
computador ATX. A vantagem de utilização desta fonte é que ela provê tensões
estratégicas para o projeto, como 3.3v, 5v e 12v, com corrente suficiente para o
sistema criado. Como essas fontes são feitas para rodarem dentro de um gabinete,
ligadas apenas quando o botão de power é acionado, uma adaptação faz-se
necessária para que elas liguem externamente. É necessário, para tanto, criar um
jumper entre fios específicos que armam a fonte. Em fontes ATX, geralmente os fios
são verde (PS_ON) e preto (COM ou Terra). Neste caso, uma chave foi colocada
entre o fio de ativação (cor verde) e um dos fios terra da fonte para controlar o
processo de ligar e desligar.
8
Saiba mais em http://everycircuit.com
9
Saiba mais em https://circuits.io/
10
Saiba mais em http://fritzing.org/home/
66
6.1.2 OS INSTRUMENTOS
A Figura 28, por fim, traz uma foto da visão frontal do painel, em
funcionamento, aguardando dados do jogo. Nessa foto, é possível observar todos os
72
REFERÊNCIAS BIBLIOGRÁFICAS
[1] ABECASIS, David. Telemetria – Conceitos e Aplicações. Disponível em
<http://cfrg.ccmar.ualg.pt//documents/Telemetry%20concepts%20and
%20applications.pdf> Acesso em 21 set. 2016.
[2] AFONSO, Diógenes. Radicais Greco-Latinos. Disponível em
<http://www.educacional.com.br/upload/blogsite/5094/5094442/9140/radicais
%20greco-latinos.pdf> Acesso em 21 set. 2016.
[3] ANTONIO, Marco. Apostila de programação de microcontroladores PIC
usando linguagem C. Disponível em
<http://www.pictronics.com.br/downloads/apostilas/Apostila-Pic-C.pdf> Acesso
em 08 out. 2016.
[4] Arduino Website. SN74HC165N. Disponível em
<http://playground.arduino.cc/Code/ShiftRegSN74HC165N> Acesso em 02
dez. 2016.
[5] Arduino Website. Arduino - Introduction. Disponível em
<https://www.arduino.cc/en/Guide/Introduction> Acesso em 30 set. 2016.
[6] Arduino Website. Arduino Leonardo – Overview. Disponível em
<https://www.arduino.cc/en/Main/ArduinoBoardLeonardo> Acesso em 29 nov.
2016.
[7] Arduino Website. Arduino Playground – LearningShiftOut. Disponível em
<http://playground.arduino.cc/Portugues/LearningShiftOut> Acesso em 01
dez. 2016.
[8] Arduino Website. Serial. Disponível em
<http://playground.arduino.cc/Referencia/Serial> Acesso em 29 nov. 2016.
[9] Arduino Website. Servo. Disponível em
<https://www.arduino.cc/en/Reference/Servo> Acesso em 02 dez. 2016.
[10] Arduino Website. ShiftOut(). Disponível em
<https://www.arduino.cc/en/Reference/shiftOut> Acesso em 01 dez. 2016.
[11] Atmel Website. ATmega32u4 Datasheet. Disponível em
<http://www.atmel.com/Images/Atmel-7766-8-bit-AVR-ATmega16U4-
32U4_Datasheet.pdf> Acesso em 01 dez. 2016.
76
Legenda de componentes:
1. Chave de acionamento dos faróis;
2. Botão de acionamento da luz giratória (beacon);
3. Luz indicadora de funcionamento do beacon;
4. Conta-giros;
5. Servomotor do conta-giros;
6. Luz indicadora de direção à esquerda (seta esquerda);
7. Luz indicadora do farol alto;
8. Luz indicadora do farol baixo;
9. Luz indicadora do farol de estacionamento;
10. Luz indicadora de direção à direita (seta direita);
11. Servomotor da velocidade;
12. Velocímetro;
13. Luz indicadora de conexão com reboque;
14. Chave de trava do reboque;
15. Chave de acionamento do freio de mão;
82