Lição 2: Painel de Instrumentos

Narrativa

Parabéns, Piloto! Você completou o treinamento básico de comunicação. Agora é hora de entrar na cabine e aprender a ler o painel de instrumentos. Cada mecha da Academia Æther possui um painel complexo que exibe diversos tipos de dados — desde temperaturas até velocidades, desde status binários até identificadores de combustível.

Um bom Piloto precisa interpretar cada instrumento corretamente. A temperatura do núcleo é medida em graus Celsius (números inteiros), a velocidade em km/h (números com decimais), o status do escudo é ativo ou inativo (verdadeiro ou falso), e o tipo de combustível é identificado por uma letra. Cada tipo de dado tem seu propósito específico e deve ser tratado de forma adequada.

Conceito

Rust é uma linguagem fortemente tipada, o que significa que cada valor tem um tipo específico que determina o que pode ser feito com ele. Nesta lição, vamos explorar os tipos simples (primitivos) mais comuns:

Inteiros (i32, i64, u8, etc.): Números sem parte decimal. O prefixo i indica que pode ser negativo (signed), enquanto u indica apenas positivos (unsigned). O número indica quantos bits ocupam:

• i32: Inteiro com sinal de 32 bits (ex: -100, 0, 100)
• i64: Inteiro com sinal de 64 bits (ex: -9999999999, 0, 9999999999)
• u8: Inteiro sem sinal de 8 bits (ex: 0 a 255)

Ponto Flutuante (f32, f64): Números com casas decimais. f64 é mais preciso e é o padrão recomendado:

• f64: Ponto flutuante de 64 bits (ex: 3.14159, -0.5, 98.6)

Booleano (bool): Representa verdadeiro ou falso:

• true: Sim, ativo, ligado
• false: Não, inativo, desligado

Caractere (char): Representa um único caractere Unicode:

• 'A', 'b', '7', 'ñ', '日'

Requisitos

• Entrada: Valores de diferentes tipos primitivos
• Processamento: Converter entre tipos, validar intervalos, calcular valores
• Saída: Resultados processados no tipo adequado para cada operação

Design de Dados

Esta lição trabalha exclusivamente com tipos primitivos. Não usamos structs ou coleções — apenas valores escalares que representam leituras de instrumentos:

// Funções de processamento de instrumentos
pub fn converter_celsius_para_fahrenheit(celsius: i32) -> f64;
pub fn validar_numero_portas(numero: u8) -> bool;
pub fn calcular_area_circulo(raio: f64) -> f64;
pub fn verificar_status_escudo(energia: i32, limiar: i32) -> bool;
pub fn obter_tipo_combustivel(tipo: char) -> &'static str;

Cada função demonstra operações típicas com tipos específicos: conversão de temperatura (i32 → f64), validação de intervalos (u8 → bool), cálculos matemáticos (f64 → f64), comparações lógicas (i32 comparado com i32 → bool), e pattern matching em caracteres (char → &str).

Diagrama Conceitual

flowchart TD
    A[Leitura do Sensor] --> B{Tipo de Dado}
    B -->|Inteiro| C[i32, i64, u8]
    B -->|Decimal| D[f64]
    B -->|Lógico| E[bool]
    B -->|Símbolo| F[char]
    C --> G[Operações Aritméticas]
    D --> G
    C --> H[Comparações]
    D --> H
    E --> I[Tomada de Decisão]
    F --> J[Identificação]
    G --> K[Resultado]
    H --> K
    I --> K
    J --> K

Funções e Módulos

//! Lição 2: Painel de Instrumentos
//!
//! Aprendendo a ler os diferentes tipos de dados do painel.

/// Converte temperatura de Celsius para Fahrenheit
pub fn converter_celsius_para_fahrenheit(celsius: i32) -> f64;

/// Valida se o número de portas está dentro do intervalo aceitável (2 a 5)
pub fn validar_numero_portas(numero: u8) -> bool;

/// Calcula a área de um círculo dado o raio
pub fn calcular_area_circulo(raio: f64) -> f64;

/// Verifica se o escudo está ativo baseado na energia disponível
pub fn verificar_status_escudo(energia: i32, limiar: i32) -> bool;

/// Retorna o nome do combustível baseado no tipo (caractere)
pub fn obter_tipo_combustivel(tipo: char) -> &'static str;

Exemplo do Conceito

// Inteiros - contagens e identificadores discretos
let temperatura: i32 = 25;           // Temperatura em graus
let contagem: u8 = 3;                // Número de itens (sempre positivo)

// Ponto flutuante - medições contínuas
let velocidade: f64 = 85.5;          // Velocidade com precisão decimal
let pi: f64 = 3.14159;               // Constante matemática

// Booleano - estados lógicos
let escudo_ativo: bool = true;       // Escudo está ligado
let motor_ligado: bool = false;      // Motor está desligado

// Caractere - identificadores únicos
let combustivel: char = 'G';         // G = Gasolina
let classe: char = 'A';              // Classe do mecha

// Operações entre tipos
let temp_fahrenheit = converter_celsius_para_fahrenheit(temperatura);
let area = calcular_area_circulo(2.5);
let pode_abrir = validar_numero_portas(contagem);

Explicação:

• Linha 2: i32 é ideal para temperaturas que podem ser negativas
• Linha 3: u8 garante que a contagem nunca seja negativa (0 a 255)
• Linha 6: f64 fornece precisão para medições contínuas
• Linha 10: bool representa estados binários (ligado/desligado)
• Linha 14: char armazena um único caractere Unicode
• Linhas 18-20: Funções convertem e processam os valores conforme necessário

Missão

1. Implementar converter_celsius_para_fahrenheit: Converta uma temperatura em Celsius (i32) para Fahrenheit (f64). Fórmula: F = C × 9/5 + 32
2. Implementar validar_numero_portas: Verifique se o número de portas está no intervalo válido de 2 a 5 (inclusive)
3. Implementar calcular_area_circulo: Calcule a área de um círculo dado o raio. Use std::f64::consts::PI para o valor de π. Fórmula: A = π × r²
4. Implementar verificar_status_escudo: Retorne true se a energia for maior ou igual ao limiar, false caso contrário
5. Implementar obter_tipo_combustivel: Dado um caractere, retorne o tipo de combustível: 'E'/'e' = "Etanol", 'G'/'g' = "Gasolina", 'D'/'d' = "Diesel", qualquer outro = "Desconhecido"

Diagrama de Fluxo da Missão

flowchart TD
    A[Tarefa: Ler Painel] --> B[Implementar converter_celsius_para_fahrenheit]
    B --> C[Implementar validar_numero_portas]
    C --> D[Implementar calcular_area_circulo]
    D --> E[Implementar verificar_status_escudo]
    E --> F[Implementar obter_tipo_combustivel]
    F --> G[Testes verificam]
    G --> H{Clippy limpo?}
    H -->|Sim| I[Concluído]
    H -->|Não| J[Corrigir warnings] --> G

Como Executar

# Executar testes
cargo test

# Verificar lint
cargo clippy -- -D warnings

# Formatar código
cargo fmt --check

Dicas

• Use as f64 para converter i32 para f64 quando necessário
• O operador ..= cria um intervalo inclusivo (ex: 2..=5 inclui 2 e 5)
• Para elevar ao quadrado, multiplique a variável por ela mesma ou use .powi(2)
• Use .to_ascii_uppercase() ou pattern matching com múltiplos casos para tratar 'e' e 'E'
• &'static str é o tipo de retorno para strings literais conhecidas em tempo de compilação
• Teste casos limite: temperaturas negativas, raio zero, energia igual ao limiar