UC02915

Desenvolver algoritmos e rotinas de otimização para desenho automático

Fluxogramas, variáveis e ciclos em VBA, rotinas de desenho automático e transferência de dados entre CAD e ficheiros externos

Curso profissional · 25h · Técnico de Desenho e Projeto/Design Industrial

Plano

  1. Da tarefa repetitiva à rotina automática
  2. Fluxogramas: desenhar o algoritmo antes de o codificar
  3. Tipos de variáveis em VBA
  4. Operações com variáveis e ciclos de programação
  5. Algoritmos de otimização para desenho automático
  6. Interfaces VBA com CAD e folhas de cálculo
  7. Rotinas de desenho automático
  8. Inquirir dados de modelos CAD 2D e 3D
  9. Exportar informação do CAD
  10. Importar informação para o CAD
  11. Normas de segurança e saúde no trabalho

Bloco 1 · Da tarefa repetitiva à rotina automática

Porque automatizar o desenho

Num gabinete de desenho e projeto há tarefas que se repetem: desenhar a mesma família de furos, gerar a mesma vista, preencher a mesma lista de materiais. Fazê-las à mão, peça a peça, é lento e é onde nascem os erros por distração.

  • Uma rotina é um programa curto, escrito em VBA (Visual Basic for Applications) ou equivalente, que o software de CAD corre por nós.
  • Automatizar não é um luxo: é uma aptidão da profissão de técnico de desenho e projeto/design industrial.
  • Aplica-se a qualquer contexto de design, conceção e fabrico de peças.

Analisar os requisitos e as especificações do desenho

Antes de escrever uma linha de código, analisa-se a tarefa: o que o desenho tem de ter, que variáveis mudam de peça para peça, e que restrições o desenho tem de respeitar (normas, tolerâncias, materiais).

  • Requisito: o que o cliente ou o processo de fabrico exige (ex.: furos de fixação normalizados).
  • Especificação: o valor concreto de cada requisito (ex.: círculo de furação de 100 mm, 8 furos, M6).
  • Sem esta análise, a rotina automatiza o desenho errado, depressa e muitas vezes.

Avaliar a viabilidade: vale a pena automatizar?

Nem toda a tarefa repetitiva compensa automatizar. Compara-se o tempo poupado ao longo do tempo com o custo de desenvolver a rotina, que só se paga uma vez.

def vale_a_pena_automatizar(frequencia_semana, tempo_manual_min,
                             tempo_dev_min, semanas=52):
    if frequencia_semana <= 0 or tempo_manual_min <= 0:
        return False, 0.0
    ocorrencias = round(frequencia_semana * semanas)
    poupanca = ocorrencias * tempo_manual_min - tempo_dev_min
    return poupanca > 0, poupanca

Resultado real (executado): tarefa 3×/semana, 8 min à mão, 90 min a programar → compensa, poupa 1158 minutos/ano. Tarefa rara (~1×/ano) com o mesmo custo de desenvolvimento → não compensa (poupança de −75 min).

Bloco 2 · Fluxogramas: desenhar o algoritmo antes de o codificar

O que é um fluxograma

Um fluxograma representa a lógica de uma rotina em símbolos normalizados, antes de escrever código. Serve para garantir a estrutura e a sequência das operações a automatizar, um critério de desempenho explícito desta UC.

Símbolo Significado
Oval início / fim
Retângulo uma ação (ex.: "calcular furo")
Losango uma decisão (sim/não)
Seta o sentido do fluxo

Um fluxograma mal desenhado dá origem a uma rotina com a lógica errada, mesmo que o código "corra" sem erros.

Exemplo: fluxograma de uma rotina de furação

Fluxograma da rotina "desenhar N furos num círculo de fixação":

(Início)
   │
   ▼
[Ler N, diâmetro, x0, y0]
   │
   ▼
<N > 0?> ──não──► (Fim, sem furos)
   │ sim
   ▼
[i = 0]
   │
   ▼
<i < N?> ──não──► (Fim)
   │ sim
   ▼
[calcular ângulo, x, y]
   │
[desenhar furo em (x, y)]
   │
[i = i + 1] ──► volta a <i < N?>

O losango logo a seguir à leitura dos dados é o caso limite: sem ele, N = 0 tentaria desenhar um furo inexistente.

Bloco 3 · Tipos de variáveis em VBA

Declarar variáveis: Dim e os tipos principais

Em VBA, cada variável guarda um tipo de dado. Declarar o tipo certo evita erros de arredondamento, de memória e de conversão.

Tipo VBA Guarda Exemplo
Integer inteiro pequeno (−32768 a 32767) número de furos
Long inteiro grande um contador com muitas iterações
Double número real, dupla precisão uma coordenada em mm
String texto a referência da peça, "PC-001"
Boolean verdadeiro/falso "a peça está conforme?"
Variant qualquer tipo, decidido em execução um valor lido de uma célula Excel
Object uma referência a um objeto do CAD ou do Excel ThisDrawing, Worksheet 
Dim nFuros As Integer
Dim diametro As Double
Dim referencia As String
Dim oDoc As Object   ' referência a um objeto do CAD

Variáveis dinâmicas e o âmbito (scope)

Uma variável dinâmica é a que muda de valor ao longo da execução da rotina (o contador de um ciclo, a coordenada do furo atual), ao contrário de uma constante.

  • Âmbito local (Dim dentro de uma Sub): só existe enquanto a rotina corre.
  • Âmbito de módulo (Dim no topo do módulo): partilhada por várias rotinas do mesmo ficheiro.
  • Um critério de desempenho desta UC exige adequar o tipo de variável dinâmica à tipologia da rotina: um contador de furos é Integer/Long, uma coordenada é Double, uma referência de peça é String.

Escolher mal o tipo não impede a rotina de correr uma vez, mas pode falhar silenciosamente com outros dados de entrada.

Bloco 4 · Operações com variáveis e ciclos de programação

Operações com variáveis: o cuidado com a divisão

As operações aritméticas em rotinas de desenho (soma, subtração, multiplicação, divisão) têm um erro clássico: confundir divisão real com divisão inteira ao calcular quantidades.

comprimento_disponivel_mm = 2500
comprimento_peca_mm = 400
kerf_mm = 3

# errado como contagem de peças:
n_pecas_errado = comprimento_disponivel_mm / (comprimento_peca_mm + kerf_mm)
# → 6.2034... (uma peça "meia" não existe)

# correto: divisão inteira (piso) para contar peças
n_pecas_certo = comprimento_disponivel_mm // (comprimento_peca_mm + kerf_mm)
sobra_mm = comprimento_disponivel_mm - n_pecas_certo * (comprimento_peca_mm + kerf_mm)
# → 6 peças, sobram 82 mm (executado e confirmado)

Em VBA, o equivalente à divisão inteira é o operador \ (n = disponivel \ (peca + kerf)), diferente de /.

Ciclos: For, Do While e Do Until

Um ciclo repete um bloco de instruções, a base de qualquer rotina de desenho automático com N elementos.

' For: quando se sabe à partida quantas vezes repetir
For i = 0 To nFuros - 1
    ' desenhar furo i
Next i

' Do While: repete enquanto a condição for verdadeira
Do While i < nFuros
    i = i + 1
Loop

' Do Until: repete até a condição se tornar verdadeira
Do Until i = nFuros
    i = i + 1
Loop

A lógica equivalente, testada em Python (gerar furos alinhados com espaçamento fixo):

def furos_em_linha(n_furos, espaco_mm, x0=0.0):
    if n_furos <= 0:
        return []
    return [round(x0 + i * espaco_mm, 2) for i in range(n_furos)]

furos_em_linha(5, 40, x0=10)   # → [10, 50, 90, 130, 170] (executado)
furos_em_linha(0, 40)          # → []  (caso limite: sem furos)

Bloco 5 · Algoritmos de otimização para desenho automático

O que significa "otimizar" numa rotina de corte

Otimizar é escolher, de entre várias soluções válidas, a que minimiza (ou maximiza) uma medida concreta, sob uma restrição. Numa rotina de corte de barras:

  • O que se otimiza: o número de barras de stock consumidas (menos barras = menos desperdício e menos custo).
  • A restrição: nenhuma peça cortada pode exceder o comprimento da barra, e cada corte perde uma folga de serra (kerf).
  • Como se sabe que é melhor: compara-se o número de barras entre duas estratégias, com os mesmos dados de entrada.

A estratégia usada aqui chama-se First Fit Decreasing (FFD): ordenar as peças da maior para a menor antes de as ir encaixando na primeira barra onde caibam.

Exemplo executado: cortar barras de alumínio

Estrutura com 6 reforços horizontais (831 mm) e 4 verticais (1597 mm), barra de stock de 2500 mm, kerf de 3 mm.

def cortar_barras(pecas_mm, barra_mm, kerf_mm=3):
    barras = []
    for p in pecas_mm:
        necessario = p + kerf_mm
        for i, livre in enumerate(barras):
            if necessario <= livre:
                barras[i] -= necessario
                break
        else:
            barras.append(barra_mm - necessario)
    return barras
Ordem das peças Barras usadas Desperdício
Ordem de produção (chegam por tipo) 7 6096 mm
FFD (maior → menor) 5 1096 mm

Poupança real: 28,6% menos barras (7 → 5), calculada a partir da execução do código, não estimada.

Testar e validar um algoritmo de otimização

Um algoritmo de otimização só se considera pronto depois de testado nos casos limite, não só no caso "normal":

  • Lista vazia de peças → zero barras usadas, sem erro.
  • Peça maior do que a barra → tem de ser sinalizada, não tentada encaixar num ciclo infinito.
  • Uma só peça → uma barra, com o desperdício esperado.
  • Todas as peças iguais → o resultado não deve depender da ordem.

Estes quatro casos foram corridos e confirmados no código desta UC (assert no fim do script). Uma rotina que só foi testada com dados "bonitos" falha na primeira peça fora do previsto, em produção.

Bloco 6 · Interfaces VBA com CAD e folhas de cálculo

Como o VBA fala com o CAD

O VBA corre dentro do software de CAD e acede aos seus objetos através de uma interface de automação (API). É pseudocódigo de referência (não corre fora do CAD):

' VBA (referência, depende da aplicação de CAD instalada)
Sub DesenharFuroExemplo()
    Dim oDoc As Object
    Set oDoc = ThisDrawing                     ' documento ativo
    Dim centro(2) As Double
    centro(0) = 50: centro(1) = 0: centro(2) = 0
    oDoc.ModelSpace.AddCircle centro, 3         ' furo Ø6 mm
End Sub

A lógica (calcular o centro do furo) é a parte testável e independente do CAD; a chamada à API (AddCircle) é específica do software e só corre lá dentro. Separar as duas é o que torna a rotina fácil de depurar.

Funções de interface com folhas de cálculo

Para ligar o VBA a uma folha de cálculo (Excel), usam-se funções de interface que abrem a aplicação, leem ou escrevem células:

' VBA (referência)
Dim oExcel As Object
Set oExcel = CreateObject("Excel.Application")
oExcel.Workbooks.Open "C:\projeto\lista_materiais.xlsx"
Dim valor As Double
valor = oExcel.Sheets(1).Cells(2, 3).Value      ' ler a célula C2
oExcel.Sheets(1).Cells(2, 4).Value = valor * 1.23  ' escrever com IVA

A mesma operação de leitura e escrita, na parte que é lógica pura (calcular o valor com IVA), testa-se sem Excel nem CAD:

preco_sem_iva = 14.50
preco_com_iva = round(preco_sem_iva * 1.23, 2)   # → 17.84 (executado)

Bloco 7 · Rotinas de desenho automático

Definir uma rotina de desenho automático

Uma rotina de desenho automático junta tudo o que já vimos: lê parâmetros, aplica um ciclo, desenha os elementos e, se necessário, otimiza. O fluxo típico:

1. Ler parâmetros de entrada (N, dimensões, material)
2. Validar (caso limite: N <= 0, dimensão negativa)
3. Calcular geometria em ciclo (For/Do)
4. Desenhar cada elemento via API do CAD
5. Aplicar regras de otimização se aplicável (bloco 5)
6. Confirmar (mensagem, contagem de elementos criados)

Exemplo aplicado: uma flange com círculo de furação (bolt circle), tarefa muito comum em peças mecânicas e de mobiliário técnico.

Exemplo executado: furos num círculo de fixação

import math

def furos_em_circulo(n_furos, diametro_mm, x0=0.0, y0=0.0, angulo_inicial=0.0):
    if n_furos <= 0:
        return []
    raio = diametro_mm / 2
    passo = 360 / n_furos if n_furos > 1 else 0
    pontos = []
    for i in range(n_furos):
        ang = math.radians(angulo_inicial + i * passo)
        x = round(x0 + raio * math.cos(ang), 2) + 0.0
        y = round(y0 + raio * math.sin(ang), 2) + 0.0
        pontos.append((x, y))
    return pontos

Flange com 8 furos, círculo de furação de Ø100 mm: furos_em_circulo(8, 100) devolveu, entre outros, (50.0, 0.0) e (0.0, 50.0) (verificados por cálculo trigonométrico manual). Com n_furos = 0 devolve []; com n_furos = 1, um único ponto no ângulo inicial, sem dividir 360°.

Verificar as regras de desenho automaticamente

Depois de gerar o desenho, uma rotina de verificação automática de regras (design rule check) confirma que cada peça cumpre as regras do gabinete, antes de seguir para produção.

def verificar_regras(pecas, espessura_min_mm=2.0, furo_min_dist_borda_mm=5.0):
    problemas = []
    for peca in pecas:
        if peca["espessura_mm"] < espessura_min_mm:
            problemas.append(f"{peca['nome']}: espessura abaixo do mínimo")
        if peca["dist_furo_borda_mm"] < furo_min_dist_borda_mm:
            problemas.append(f"{peca['nome']}: furo demasiado perto da borda")
    return problemas

Executado com duas peças, devolveu 1 problema (espessura de 1,5 mm abaixo do mínimo de 2,0 mm) e nenhum para a peça conforme; com [] devolve [].

Bloco 8 · Inquirir dados de modelos CAD 2D e 3D

Rotinas de inquirição: extrair dados do modelo

Inquirir um modelo é ler as suas propriedades (área, perímetro em 2D; volume, massa, centro de gravidade em 3D) por rotina, em vez de as medir manualmente. Aplica-se a fabrico, orçamentação e planeamento da produção.

Em VBA, isto vem de propriedades de massa do próprio CAD (referência, não executável aqui):

' VBA (referência, depende do CAD instalado)
Dim volume As Double
volume = oPeca.MassProperties.Volume   ' em mm3, por exemplo

A lógica que transforma esse volume num orçamento é independente do CAD e testa-se em qualquer linguagem.

Exemplo executado: orçamentar uma peça a partir do volume

DENSIDADES_KG_M3 = {"aluminio": 2700, "aco": 7850, "pla": 1240}

def orcamentar_peca(volume_cm3, material, preco_kg_eur,
                     tempo_maquina_min, custo_hora_maquina_eur):
    volume_m3 = volume_cm3 / 1_000_000
    massa_kg = volume_m3 * DENSIDADES_KG_M3[material]
    custo_material = massa_kg * preco_kg_eur
    custo_maquina = (tempo_maquina_min / 60) * custo_hora_maquina_eur
    return massa_kg, custo_material + custo_maquina

Suporte em alumínio, volume = 145 cm³ (inquirido do modelo 3D): massa = 0,392 kg, custo total (material a 4,80 €/kg + 18 min de máquina a 35 €/h) = 12,38 € (executado e confirmado por cálculo manual).

Bloco 9 · Exportar informação do CAD

Exportar do CAD para ficheiro externo

Exportar é escrever, a partir do modelo CAD, um ficheiro que outra aplicação (folha de cálculo, ERP) consegue ler. O formato mais universal é o CSV (valores separados por vírgula), que qualquer folha de cálculo importa sem conversão.

import csv

def exportar_bom(pecas, caminho):
    with open(caminho, "w", newline="", encoding="utf-8") as f:
        campos = ["codigo", "descricao", "quantidade", "preco_unit_eur"]
        w = csv.DictWriter(f, fieldnames=campos)
        w.writeheader()
        for p in pecas:
            w.writerow(p)

Isto satisfaz a realização "transferir informações entre sistemas CAD e outros documentos": a lista de materiais (BOM) sai do CAD e chega a quem orçamenta ou compra.

Bloco 10 · Importar informação para o CAD

Importar de ficheiro externo para o CAD

Importar é o caminho inverso: ler dados de um ficheiro de texto ou folha de cálculo e usá-los para gerar ou atualizar o desenho, garantindo a transferência bidirecional exigida pelo referencial.

def importar_bom(caminho):
    pecas = []
    with open(caminho, encoding="utf-8") as f:
        for linha in csv.DictReader(f):
            linha["quantidade"] = int(linha["quantidade"])
            linha["preco_unit_eur"] = float(linha["preco_unit_eur"])
            pecas.append(linha)
    return pecas

Executado com a BOM exportada no bloco anterior: os 4 artigos e o custo total de 82,80 € vieram de volta idênticos ao original, confirmado por comparação direta no código (assert). Isto é o que valida uma rotina de importação: os dados não podem mudar na viagem de ida e volta.

Bloco 11 · Normas de segurança e saúde no trabalho

Segurança ao automatizar e ao operar o posto de trabalho

Automatizar não dispensa as normas de segurança e saúde no trabalho, uma das aptidões avaliadas nesta UC:

  • Ergonomia do posto: ecrã à altura dos olhos, pausas regulares, boa iluminação, evitar posturas fixas prolongadas.
  • Uma rotina automática executa muitas ações em segundos: nunca a corras num ficheiro sem cópia de segurança, um erro na lógica repete-se em todas as peças de uma vez.
  • Validar antes de produzir: confirma o resultado da rotina num único elemento antes de a aplicares à série completa, sobretudo se ela vai gerar ficheiros para máquinas de corte ou impressão.
  • Manter plotters e impressoras de grandes formatos com a manutenção e a sinalética de segurança em dia.

Recapitulando

  • Antes de automatizar: analisar requisitos, desenhar o fluxograma e avaliar se compensa (poupança > custo de desenvolvimento).
  • Em VBA: escolher o tipo de variável certo, dominar operações e ciclos (For, Do While, Do Until).
  • Otimizar é minimizar uma medida sob uma restrição, e provar isso com números reais, testados nos casos limite.
  • Interfaces ligam o VBA ao CAD e ao Excel; rotinas de desenho juntam tudo; inquirição liga o modelo a fabrico e orçamento.
  • Exportar e importar fecham o ciclo entre o CAD e os ficheiros externos, sempre com dados verificados.

Próximo: fichas e mini-projeto, construir uma rotina de raiz.

NOTAS DO PROFESSOR - Enfatizar: automatizar é uma competência do referencial desta UC, não um "extra" para quem gosta de programar. - Erro comum: achar que só se automatiza o que é complexo. O que compensa automatizar é o que se **repete muitas vezes**, seja simples ou não. - Exemplo: uma chapa com 40 furos desenhados um a um demora horas e qualquer furo pode ficar mal alinhado; uma rotina desenha-os todos em segundos, sempre iguais.

NOTAS DO PROFESSOR - Enfatizar: requisito é o "quê" (tem furos de fixação), especificação é o "quanto" (8 furos, Ø100 mm). Confundir os dois é o erro mais comum. - Pergunta: "se automatizarmos sem confirmar a especificação, o que acontece a uma peça já fabricada com o erro?" (Resposta: o erro repete-se em todas as peças da série.) - Analogia: é como escrever a receita antes de cozinhar em série; sem ela, cada tacho sai diferente.

NOTAS DO PROFESSOR - Enfatizar: o critério de decisão é objetivo (comparar poupança acumulada com o custo de desenvolver), não uma impressão. - Erro comum: programar uma rotina para uma tarefa que só acontece uma vez. O tempo de desenvolvimento nunca se paga. - Exemplo: os dois casos do código foram mesmo corridos; o resultado muda de "compensa" para "não compensa" só por mudar a frequência.

NOTAS DO PROFESSOR - Enfatizar: o fluxograma separa o "o que fazer" (lógica) do "como escrever" (sintaxe do VBA). Pensar primeiro na lógica poupa tempo a depurar depois. - Erro comum: começar a escrever código sem desenhar o fluxograma e perder-se a meio de um ciclo com uma condição mal pensada. - Analogia: o fluxograma é a planta da rotina, tal como o desenho técnico é a planta da peça.

NOTAS DO PROFESSOR - Enfatizar: todo o ciclo tem de ter uma condição de paragem clara (aqui, "i < N?"); sem ela, a rotina nunca termina. - Erro comum: esquecer o caso N = 0 ou N negativo. É o primeiro caso limite a testar em qualquer rotina. - Pergunta: "o que aconteceria se trocássemos 'i < N' por 'i <= N'?" (Resposta: desenhava-se um furo a mais, fora do padrão.)

NOTAS DO PROFESSOR - Enfatizar: `Integer` e `Double` não são intermutáveis, uma coordenada em milímetros com casas decimais tem de ser `Double`, nunca `Integer`. - Erro comum: declarar tudo como `Variant` "para não ter de pensar". Funciona, mas gasta mais memória e esconde erros de tipo que só aparecem em produção. - Exemplo: um `Integer` a contar mais de 32767 furos rebenta; nesse caso usa-se `Long`.

NOTAS DO PROFESSOR - Enfatizar: "dinâmica" aqui significa que o valor muda durante a execução, não que o tipo é indefinido. - Erro comum: reutilizar a mesma variável para dois fins diferentes (ex.: um contador de furos e depois um contador de peças) sem a reiniciar. - Pergunta: "porque é que uma referência de peça como '007' deve ser String e não Integer?" (Resposta: perderia o zero à esquerda se fosse número.)

NOTAS DO PROFESSOR - Enfatizar: a divisão inteira arredonda sempre para baixo; uma peça que "quase cabe" não conta. - Erro comum: usar `/` (divisão real) para contar peças e a rotina "desenhar" 6,2 peças, o que não existe fisicamente. - Exemplo: os números 6 peças e 82 mm de sobra vieram mesmo de correr o código, não são inventados.

NOTAS DO PROFESSOR - Enfatizar: `For` usa-se quando o número de repetições é conhecido (N furos); `Do While`/`Do Until` quando depende de uma condição (ex.: "até a folha acabar"). - Erro comum: esquecer de atualizar o contador dentro de um `Do While`, criando um ciclo infinito que trava o CAD. - Pergunta: "o que devolve `furos_em_linha` com N = 0?" (Resposta: lista vazia, é o caso limite tratado no código.)

NOTAS DO PROFESSOR - Enfatizar: otimizar sem dizer o que se otimiza e sob que restrição não é otimizar, é só "mudar por mudar". - Erro comum: comparar duas rotinas sem correr as duas com os mesmos dados de entrada, o que invalida a comparação. - Analogia: é como arrumar uma mala, as peças grandes primeiro deixam menos espaço desperdiçado do que enfiar as pequenas antes.

NOTAS DO PROFESSOR - Enfatizar: os números 7, 5 e 28,6% vieram de correr mesmo o código com os mesmos dados; a rotina não muda, só a ordem das peças à entrada. - Erro comum: assumir que qualquer reordenação melhora o resultado. Aqui melhora porque as peças grandes "sobram" menos espaço morto quando entram primeiro. - Pergunta: "porque é que ordenar por tamanho ajuda mais do que ordenar por código de peça?" (Resposta: o tamanho é o que determina se cabe ou não numa barra; o código de peça é irrelevante para o corte.)

NOTAS DO PROFESSOR - Enfatizar: testar casos limite não é perfecionismo, é o que distingue uma rotina fiável de uma que falha na primeira exceção real. - Erro comum: testar só com o exemplo "de propaganda" e nunca com dados vazios ou extremos. - Exemplo: uma peça de 3000 mm pedida para uma barra de 2500 mm tem de dar um aviso claro, nunca um ciclo sem fim.

NOTAS DO PROFESSOR - Enfatizar: nunca se testa a chamada à API fora do CAD, mas a lógica de cálculo (coordenadas, contagens, decisões) testa-se sempre à parte, como fizemos nos blocos anteriores. - Erro comum: misturar cálculo e chamadas à API na mesma linha, o que torna impossível testar o cálculo sem abrir o CAD. - Analogia: é como separar a receita (lógica) do forno (API): a receita pode ser revista no papel, o forno só se testa a sério a assar.

NOTAS DO PROFESSOR - Enfatizar: `CreateObject` é a função que "liga" o VBA a outra aplicação (Excel, outro CAD); sem ela não há interface. - Erro comum: esquecer de fechar a aplicação Excel aberta pela rotina (`oExcel.Quit`), o que deixa processos "fantasma" na memória. - Pergunta: "porque separar o cálculo do IVA da leitura da célula Excel?" (Resposta: o cálculo pode ser testado sem abrir nada; só a leitura depende do Excel.)

NOTAS DO PROFESSOR - Enfatizar: a estrutura em seis passos é sempre a mesma, muda o que se desenha (furos, cotas, vistas, legendas). - Erro comum: saltar o passo de validação "para ir mais depressa" e a rotina desenhar lixo quando alguém introduz um valor inesperado. - Exemplo: ligar este fluxo ao fluxograma do Bloco 2, é a mesma lógica, agora com os passos escritos por extenso.

NOTAS DO PROFESSOR - Enfatizar: o passo angular só faz sentido dividir por N se N > 1; com um furo só, não há "distribuição" a calcular. - Erro comum: não tratar N = 1 como caso especial e obter uma divisão por zero ao calcular 360/N... não, division by zero seria N=0, mas o erro típico é o aluno esquecer de testar N=1 e assumir que o furo fica sempre no mesmo sítio por coincidência. - Pergunta: "se mudarmos o ângulo inicial de 0° para 45°, o que muda?" (Resposta: todos os furos rodam 45° em bloco, o padrão mantém-se.)

NOTAS DO PROFESSOR - Enfatizar: esta rotina não desenha nem otimiza, só classifica; é o "controlo de qualidade" automático do desenho. - Erro comum: só verificar visualmente algumas peças da série "por amostragem" quando a rotina pode verificar todas em segundos. - Exemplo: mandar fabricar sem correr esta verificação é como imprimir 500 folhas sem rever a primeira.

NOTAS DO PROFESSOR - Enfatizar: a rotina não "adivinha" a massa, lê-a das propriedades geométricas do modelo, que dependem só da forma desenhada. - Erro comum: orçamentar "a olho" a partir do desenho em vez de inquirir o volume real do modelo 3D. - Exemplo: duas peças com a mesma silhueta 2D mas espessuras diferentes têm massas muito diferentes; só o 3D dá o volume certo.

NOTAS DO PROFESSOR - Enfatizar: mudar o material (dicionário de densidades) muda logo a massa e o custo, sem tocar no resto da rotina. - Erro comum: usar a densidade errada (confundir alumínio com aço) e o orçamento sair 3× mais caro ou mais barato do que devia. - Pergunta: "o que acontece se pedirmos um material que não está no dicionário?" (Resposta: a rotina tem de falhar com um aviso claro, não calcular um valor absurdo.)

NOTAS DO PROFESSOR - Enfatizar: o CSV é texto simples, sem formatação, por isso é lido por praticamente qualquer programa, do Excel ao ERP da empresa. - Erro comum: exportar números como texto com vírgula decimal portuguesa (1,35) para um sistema que espera ponto (1.35), o que gera erros de leitura silenciosos. - Exemplo: a BOM de uma estante (painéis, prateleiras, dobradiças, puxador) exportada para CSV é o que o departamento de compras usa para pedir os materiais.

NOTAS DO PROFESSOR - Enfatizar: importar sem validar o tipo de cada campo (aqui, converter texto para número) deixa tudo como texto e as contas seguintes falham. - Erro comum: assumir que o ficheiro de entrada está sempre bem formatado; uma rotina de produção verifica antes de calcular. - Pergunta: "porque testámos a ida e volta (exportar depois importar) em vez de só a exportação?" (Resposta: só assim se prova que nenhum dado se perde ou corrompe na transferência.)

NOTAS DO PROFESSOR - Enfatizar: o maior risco de uma rotina automática não é físico, é o de replicar um erro em toda uma série de peças antes de alguém dar por isso. - Erro comum: correr uma rotina nova diretamente sobre o ficheiro final, sem testar primeiro numa cópia. - Exemplo: uma rotina de furação com o diâmetro errado, corrida sobre 200 peças antes de ser travada, obriga a refazer a série toda; um teste de 1 peça teria apanhado o erro em segundos.