Aula de Manipulação de dados em Python

Arquivos CSV

Um arquivo CSV (Comma-Separated Values) é um formato simples e muito usado para armazenar e trocar dados em forma de tabela. Nele, cada linha representa um registro e cada coluna é separada por vírgula (,), ponto e vírgula (;) ou outro delimitador.

✨ Principais características:

• É um arquivo de texto puro, fácil de abrir em qualquer editor ou programa.
• Pode ser lido e escrito por diversos sistemas e linguagens de programação.
• É amplamente usado para importar e exportar dados entre bancos de dados, planilhas (como Excel) e softwares.

📌 Exemplo de CSV:

nome,idade,cidade
Maria,25,São Paulo
João,30,Rio de Janeiro
Ana,22,Belo Horizonte

👉 Nesse exemplo:

• A primeira linha traz o cabeçalho (nomes das colunas).
• As linhas seguintes são os dados.

💡 Por ser simples e leve, o CSV é ideal quando precisamos de compatibilidade e portabilidade de dados, mas não traz recursos avançados como fórmulas ou formatação, presentes em arquivos de planilha.

Como criar um arquivo CSV

Entre no notepad++ e crie um novo arquivo.

Copie o seguinte conteúdo.

nome,idade,cidade
Maria,25,São Paulo
João,30,Rio de Janeiro
Ana,22,Belo Horizonte

Em seguida salve como listagem.csv

Pronto voce tem um arquivo csv válido.

Usando o Pandas

Pandas é uma biblioteca do Python muito usada para análise e manipulação de dados. Ele facilita o trabalho com tabelas, planilhas e arquivos CSV, oferecendo estruturas como DataFrame (que parece uma tabela do Excel dentro do Python).

📌 Explicação simplificada:

• O pandas permite ler arquivos CSV com apenas um comando.
• Depois de carregado, os dados ficam em um DataFrame, onde podemos visualizar, filtrar, ordenar e até realizar cálculos.
• É uma das bibliotecas mais usadas em ciência de dados e análise de dados.

---

Exemplo em Python usando o listagem.csv:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Exibe o conteúdo do arquivo
print(df)

✨ O código faz o seguinte:

1. Importa o pandas.
2. Usa pd.read_csv() para ler o arquivo chamado listagem.csv.
3. Guarda os dados no DataFrame df.
4. Imprime todo o conteúdo do arquivo.

💡 Assim, você consegue transformar seu CSV em uma tabela bem estruturada para manipulação dentro do Python.

Varrendo os registros de um CSV.

Depois de carregar o CSV no Pandas, você pode percorrer os registros linha a linha usando o método iterrows(). Assim, cada linha é lida como um índice e uma série de dados.

📌 Aqui está a continuação do programa:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Exibe todo o conteúdo do arquivo
print("Conteúdo completo do arquivo:\n")
print(df)

print("\nVarredura linha a linha:\n")
# Percorre cada linha do DataFrame
for index, row in df.iterrows():
    print(f"Linha {index}: {row.to_dict()}")

---

✨ O que esse código faz:

1. Lê o listagem.csv no DataFrame df.
2. Mostra o conteúdo completo.
3. Varre linha por linha do DataFrame.
4. Para cada linha, imprime um dicionário com os nomes das colunas e os valores.

📌 Exemplo de saída (supondo o CSV com nome,idade,cidade):

Linha 0: {'nome': 'Maria', 'idade': 25, 'cidade': 'São Paulo'}
Linha 1: {'nome': 'João', 'idade': 30, 'cidade': 'Rio de Janeiro'}
Linha 2: {'nome': 'Ana', 'idade': 22, 'cidade': 'Belo Horizonte'}

---

Quer que eu prepare uma versão onde, ao invés de imprimir o dicionário inteiro, já traga cada campo formatadinho, tipo:
👉 Maria - 25 anos - São Paulo?

Verificando informações com PANDAS

Podemos deixar o programa interativo: ele pergunta ao usuário uma faixa de idade (mínimo e máximo) e depois filtra as pessoas do listagem.csv que estão dentro desse intervalo.

Aqui está o código:

import pandas as pd

# Lê o arquivo CSV
df = pd.read_csv("listagem.csv")

# Pergunta ao usuário a faixa de idade
idade_min = int(input("Digite a idade mínima: "))
idade_max = int(input("Digite a idade máxima: "))

# Filtra os registros que estão na faixa
resultado = df[(df['idade'] >= idade_min) & (df['idade'] <= idade_max)]

# Mostra o resultado
print("\nPessoas dentro da faixa etária escolhida:\n")
if resultado.empty:
    print("Nenhuma pessoa encontrada nessa faixa de idade.")
else:
    for index, row in resultado.iterrows():
        print(f"{row['nome']} - {row['idade']} anos - {row['cidade']}")

✨ O que acontece aqui:

1. Lê o CSV no DataFrame.
2. Pede ao usuário a idade mínima e máxima.
3. Usa um filtro lógico para selecionar apenas quem está entre os dois valores.
4. Mostra o resultado de forma organizada.

📌 Exemplo de saída:

Digite a idade mínima: 20
Digite a idade máxima: 25

Pessoas dentro da faixa etária escolhida:

Maria - 25 anos - São Paulo
Ana - 22 anos - Belo Horizonte

Outras funcionalidades do pandas

O Pandas é super poderoso e tem muitas funcionalidades além de só ler e filtrar CSV. Vou te mostrar algumas das mais usadas com exemplos práticos:

---

📌 1. Mostrar só algumas linhas

print(df.head())   # primeiras 5 linhas
print(df.tail())   # últimas 5 linhas

---

📌 2. Ver informações rápidas do DataFrame

print(df.info())     # mostra colunas, tipos e nulos
print(df.describe()) # estatísticas (média, desvio, min, max, etc.)

---

📌 3. Selecionar colunas específicas

print(df['nome'])          # apenas a coluna "nome"
print(df[['nome', 'idade']])  # duas colunas

---

📌 4. Filtrar com condições

# Pessoas acima de 25 anos
print(df[df['idade'] > 25])

# Pessoas da cidade "São Paulo"
print(df[df['cidade'] == "São Paulo"])

---

📌 5. Ordenar registros

print(df.sort_values(by="idade"))              # do mais novo para o mais velho
print(df.sort_values(by="idade", ascending=False))  # do mais velho para o mais novo

---

📌 6. Agrupar dados

# Média de idade por cidade
print(df.groupby("cidade")["idade"].mean())

---

📌 7. Contar ocorrências

# Quantas pessoas por cidade
print(df["cidade"].value_counts())

---

📌 8. Criar ou modificar colunas

# Criar coluna com idade em meses
df["idade_meses"] = df["idade"] * 12
print(df)

---

📌 9. Exportar resultados

# Salvar em outro CSV
df.to_csv("resultado.csv", index=False)

---

✨ Ou seja, o Pandas serve não só para ler arquivos CSV, mas também para explorar, analisar e transformar dados de forma rápida e prática.

Buscar dados e analise dos dados.

Existem locais que se pode buscar dados abertos, em geral. O governo fornece diversas bases de dados para que seja utilizada por alunos e profissionais a fim de analise de dados.

https://arquivos.receitafederal.gov.br/dados/cnpj/dados_abertos_cnpj/2025-08

Se olharmos estes dados podemos verificar o cnae de diversos produtos.

0111301″;”Cultivo de arroz”
“0111302”;”Cultivo de milho”
“0111303”;”Cultivo de trigo”
“0111399”;”Cultivo de outros cereais não especificados anteriormente”
“0112101”;”Cultivo de algodão herbáceo”
“0112102”;”Cultivo de juta”
“0112199”;”Cultivo de outras fibras de lavoura temporária não especificadas anteriormente”
“0113000”;”Cultivo de cana-de-açúcar”
“0114800”;”Cultivo de fumo”
“0115600”;”Cultivo de soja”
“0116401”;”Cultivo de amendoim”
“0116402”;”Cultivo de girassol”
“0116403”;”Cultivo de mamona”
“0116499”;”Cultivo de outras oleaginosas de lavoura temporária não especificadas anteriormente”
“0119901”;”Cultivo de abacaxi”
“0119902”;”Cultivo de alho”
“0119903”;”Cultivo de batata-inglesa”
“0119904”;”Cultivo de cebola”
“0119905”;”Cultivo de feijão”

O CNAE significa Classificação Nacional de Atividades Econômicas.

📌 Ele é um padrão oficial no Brasil criado pelo IBGE e utilizado pela Receita Federal, juntas comerciais, prefeituras e outros órgãos para identificar e categorizar a atividade econômica de empresas e profissionais.

✨ Principais pontos:

• Cada atividade econômica tem um código numérico único (exemplo: comércio de roupas, consultoria em TI, fabricação de móveis etc.).
• É usado em cadastros fiscais (como o CNPJ) e em registros de empresas.
• Serve para padronizar estatísticas e informações econômicas em nível nacional.
• Impacta diretamente em tributos e enquadramento fiscal (pois a atividade define impostos e obrigações).

---

📌 Exemplo de código CNAE:

• 62.01-5/01 → Desenvolvimento de programas de computador sob encomenda.
• 47.54-7/01 → Comércio varejista de móveis.

---

Ou seja, o CNAE funciona como um RG da atividade da empresa, identificando exatamente o que ela faz.

Tarefa.

Buscar atividades relacionadas que contem a palavra açaí.

Desenvolva um programa que pega a lista de CNAI e dado uma palavra busca todos os que tiverem aquela palavra.

Trabalho de Programação em Python

Objetivo do trabalho:

O objetivo deste trabalho é criar um arquivo para impressão 3D.

Visão sobre o projeto e informações sobre o ambiente

🟦 O que é CNC?

✨ CNC significa Controle Numérico Computadorizado (Computer Numerical Control).

• É a automação de máquinas (fresadoras, tornos, impressoras 3D, cortadoras a laser, etc.).
• No lugar de um operador manual girando manivelas, o computador controla os motores.
• O programa informa onde a ferramenta deve ir, a velocidade e o que fazer.

➡️ Resultado: peças produzidas com mais precisão, repetibilidade e velocidade.

Exemplos de máquinas CNC:

• Fresadora CNC (corta metal ou madeira).
• Torno CNC (peças cilíndricas).
• Impressora 3D (constrói objetos em camadas).
• Router CNC (corte em madeira e acrílico).
• Laser CNC (gravação/corte de chapas).

---

🟦 O que é G-code?

✨ O G-code é a linguagem usada pelas máquinas CNC.

Cada linha é uma instrução que a máquina entende.

É formado por códigos de duas letras (como G1, M104) seguidos de números (coordenadas, temperaturas, velocidades).

🟦 Como nasce uma peça CNC

1. O engenheiro desenha em CAD (3D).
2. O software CAM (fatiador, slicer, etc.) gera o G-code.
3. O G-code é enviado para a máquina CNC.
4. A máquina executa linha a linha e cria a peça.

---

🟦 Por que é importante aprender?

• O CNC está presente em indústria, medicina, aeronáutica, prototipagem e design.
• Entender G-code é como entender a “gramática” das máquinas.
• Mesmo que existam softwares automáticos, saber G-code permite:
  • Ajustar peças.
  • Corrigir erros.
  • Criar trajetórias personalizadas.

Qual o GCode da Ender-3

O padrão de G-code da Ender-3 é o Marlin/RepRap flavor, não FANUC, Mitsubishi ou Siemens. Eles são todos “G-code”, mas os dialetos são diferentes.

🔹 Diferença principal:

• A Ender-3 segue o padrão Marlin/RepRap (open-source) → voltado para impressoras 3D, bem simplificado.
• Já os CNC industriais (FANUC, Mitsubishi, Siemens) usam dialetos diferentes de ISO G-code, com foco em fresadoras, tornos e centros de usinagem, que possuem muitos recursos que uma impressora 3D não precisa (offsets, ciclos fixos, compensações de ferramenta, etc).

📌 Comparativo resumido:

Sistema	Padrão/Dialeto G-code	Usado em
Ender-3	Marlin/RepRap (G0, G1, G28, M104…)	Impressoras 3D
FANUC	ISO G-code (muitos ciclos fixos, G71, G81, etc)	CNC industrial (torno/fresa)
Mitsubishi	Próprio dialeto ISO compatível, similar ao FANUC	CNC industrial
Siemens	Sinumerik (ISO G-code, mas com macros próprios e ciclos especiais)	CNC industrial

Comandos GCode básico.

🟦 Configuração inicial

• G21 → Define as unidades em milímetros (a Ender-3 trabalha sempre em mm).
• G90 → Define o modo absoluto de posicionamento (as coordenadas X/Y/Z são relativas ao 0,0 da mesa).
• M82 → Define a extrusão em modo absoluto (valores de E sempre crescem).
• G28 → Faz o homing de todos os eixos (leva X, Y e Z até os switches de fim de curso).

---

🟦 Aquecimento (opcional)

• M104 S200 → Seta a temperatura do bico em 200 °C, mas não espera aquecer.
• M140 S60 → Seta a temperatura da mesa em 60 °C, mas também não espera.
• M109 S200 → Define o bico em 200 °C e espera até atingir antes de continuar.
• M190 S60 → Define a mesa em 60 °C e espera até atingir.

(Esses eu deixei comentados, caso queira imprimir de fato, não só movimentar.)

---

🟦 Movimentação inicial

• G1 Z0.20 F1200 → Move o bico para a altura de 0.20 mm acima da mesa, na velocidade de 1200 mm/min.
• G1 X110 Y110 F6000 → Leva o bico até o centro da mesa (coordenada X110 Y110), rápido.
• G1 X130 Y110 F3000 → Move até a posição inicial do círculo (20 mm à direita do centro).

---

🟦 Configuração de extrusão

• M83 → Define a extrusão como relativa (cada valor de E representa apenas o incremento de filamento).
• G92 E0 → Zera o contador de extrusão (dizendo ao firmware que estamos em E=0).
• G1 F1200 → Define a velocidade padrão (feedrate) de 1200 mm/min para os próximos movimentos.

---

🟦 Desenhando o círculo

• G2 → Faz um movimento circular horário (clockwise).
• X... Y... → Define o ponto final do arco.
• I... J... → Define o centro do arco em relação ao ponto inicial.
• E... → Quantidade de filamento extrudido durante o arco.

No código:

1. G2 X90 Y110 I-20 J0 E2.10 → Desenha meia-volta (da direita pro lado esquerdo do círculo), extrudindo 2.1 mm de filamento.
2. G2 X130 Y110 I20 J0 E2.10 → Fecha a volta (do lado esquerdo de volta à direita), extrudindo mais 2.1 mm.

---

🟦 Finalização

• G1 Z5 F3000 → Levanta o bico 5 mm para não arranhar a peça.
• M84 → Desliga os motores (desenergiza os steppers).

Exemplo de Código na Ender-3

; ===== Círculo Ender-3 (Marlin/RepRap) =====
; Raio: 20 mm | Centro: X110 Y110 | Camada: 0.20 mm | Largura: 0.40 mm
; Filamento: 1.75 mm | Extrusão total aprox: 4.20 mm

G21                 ; mm
G90                 ; coordenadas absolutas
M82                 ; extrusão absoluta por padrão
G28                 ; home X Y Z

; (opcional) aquecer
; M104 S200         ; bico 200°C
; M140 S60          ; mesa 60°C
; M109 S200         ; aguarda bico
; M190 S60          ; aguarda mesa

G1 Z0.20 F1200      ; altura de primeira camada (ajuste se quiser)
G1 X110 Y110 F6000  ; vai ao centro da mesa
G1 X130 Y110 F3000  ; vai ao ponto inicial do círculo (raio 20 mm à direita)

M83                 ; extrusão relativa
G92 E0              ; zera extrusor
G1 F1200            ; feed para impressão

; Círculo completo em duas meias-voltas (G2 = horário)
; Meia-volta 1: de (130,110) até (90,110) com centro em (110,110) => I=-20 J=0
G2 X90  Y110 I-20 J0 E2.10

; Meia-volta 2: de (90,110) até (130,110) com centro em (110,110) => I=+20 J=0
G2 X130 Y110 I20  J0 E2.10

; fim
G1 Z5 F3000         ; levanta
M84                 ; desativa motores
; ============================================

Visualizando o arquivo

O usuário pode verificar o arquivo, copiando o mesmo para o site:

https://ncviewer.com

Click em Novo arquivo, e copie o fonte

Neste exemplo criamos apenas uma camada. Onde incluímos e verificamos o desenho.

Agora iremos mostrar como fica o gcode com multiplas camadas.

; ===== Ender-3 | Cilindro oco (raio 10mm, altura 5mm, camada 0.20mm) =====
; Centro: X110 Y110 | Bico: 0.4 | Parede ≈ 0.8 mm (2 voltas por camada)
; Material sugerido: PLA (200/60). Ajuste se necessário.

G21                 ; mm
G90                 ; posicoes absolutas em X/Y/Z
M82                 ; extrusao absoluta por padrao
G28                 ; homing

; --- Aquecimento (descomente para imprimir de verdade) ---
; M104 S200          ; bico 200°C (nao espera)
; M140 S60           ; mesa 60°C (nao espera)
; M109 S200          ; bico 200°C (espera)
; M190 S60           ; mesa 60°C (espera)

G0 Z0.20 F1200      ; primeira camada
G0 X110 Y110 F6000  ; vai ao centro da mesa
G0 X120 Y110 F6000  ; ponto inicial do circulo (raio 10 mm para a direita)

M83                 ; extrusao relativa (E incrementa por trecho)
G92 E0              ; zera extrusor
G1 F1200            ; feed de impressao (~20 mm/s)

; Observacao: cada meia-volta extrude ~1.05 mm (estimado p/ bico 0.4, camada 0.2)

; ---------------------- Camada 1 (Z=0.20) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.40 F1200

; ---------------------- Camada 2 (Z=0.40) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.60 F1200

; ---------------------- Camada 3 (Z=0.60) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z0.80 F1200

; ---------------------- Camada 4 (Z=0.80) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.00 F1200

; ---------------------- Camada 5 (Z=1.00) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.20 F1200

; ---------------------- Camada 6 (Z=1.20) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.40 F1200

; ---------------------- Camada 7 (Z=1.40) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.60 F1200

; ---------------------- Camada 8 (Z=1.60) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z1.80 F1200

; ---------------------- Camada 9 (Z=1.80) ----------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.00 F1200

; ---------------------- Camada 10 (Z=2.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.20 F1200

; ---------------------- Camada 11 (Z=2.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.40 F1200

; ---------------------- Camada 12 (Z=2.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.60 F1200

; ---------------------- Camada 13 (Z=2.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z2.80 F1200

; ---------------------- Camada 14 (Z=2.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.00 F1200

; ---------------------- Camada 15 (Z=3.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.20 F1200

; ---------------------- Camada 16 (Z=3.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.40 F1200

; ---------------------- Camada 17 (Z=3.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.60 F1200

; ---------------------- Camada 18 (Z=3.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z3.80 F1200

; ---------------------- Camada 19 (Z=3.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.00 F1200

; ---------------------- Camada 20 (Z=4.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.20 F1200

; ---------------------- Camada 21 (Z=4.20) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.40 F1200

; ---------------------- Camada 22 (Z=4.40) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.60 F1200

; ---------------------- Camada 23 (Z=4.60) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z4.80 F1200

; ---------------------- Camada 24 (Z=4.80) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05
G1 Z5.00 F1200

; ---------------------- Camada 25 (Z=5.00) ---------------------
G2 X100 Y110 I-10 J0 E1.05
G2 X120 Y110 I10  J0 E1.05

; --- Finalizacao ---
G1 Z10 F3000        ; afasta o bico
; M104 S0           ; desligar bico (descomente se aqueceu)
; M140 S0           ; desligar mesa (descomente se aqueceu)
M84                 ; motores off
; =================================================================

O arquivo pode ser baixado aqui.

Como fica o arquivo pronto.

Base do Python

📘 Como criar e gravar um arquivo com Python

Em Python, para criar um arquivo de texto usamos a função open().

• O primeiro parâmetro é o nome do arquivo (ex.: "cilindro.gcode").
• O segundo parâmetro é o modo de abertura:
  • "w" → escrever (se já existir, sobrescreve).
  • "a" → acrescentar no final (append).
  • "r" → apenas leitura.

Depois usamos o método .write() para gravar conteúdo no arquivo.
No final, usamos .close() (ou o with que fecha automaticamente).

# Criar e gravar um arquivo de texto em Python

# Abre (ou cria) o arquivo chamado "cilindro.gcode" no modo escrita ("w")
with open("cilindro.gcode", "w", encoding="utf-8") as arquivo:
    # Grava apenas uma linha de texto no arquivo
    arquivo.write("G21 ; usar milimetros\n")

print("Arquivo 'cilindro.gcode' criado com sucesso!")

🔹 O que acontece aqui?

1. O Python cria um novo arquivo chamado cilindro.gcode na pasta onde o script está rodando.
2. Escreve dentro dele a linha: G21 ; usar milimetros
3. Fecha o arquivo automaticamente (porque usamos with).
4. Agora esse arquivo pode ser aberto em qualquer editor de texto.

Criando o programa em python com 10 camadas.

# -*- coding: utf-8 -*-
# Gera G-code para um cilindro (tubo) com 10 camadas – Ender-3 / Marlin
# Saída: cilindro_10camadas.gcode

import math

# ===== Parâmetros =====
RAIO_MM       = 10.0         # raio do cilindro (mm)
CAMADAS       = 10           # quantidade de camadas solicitada
ALTURA_CAM_MM = 0.20         # espessura da camada (mm) → 10 camadas = 2,0 mm
CENTRO_X      = 110.0        # centro aproximado da Ender-3
CENTRO_Y      = 110.0
LARG_LINHA    = 0.40         # ~bico 0.4
VEL_IMPR      = 1200         # mm/min (~20 mm/s)
VEL_VIAGEM    = 6000         # mm/min
SEGMENTOS     = 120          # segmentos para aproximar o círculo

# Extrusão (E relativo) – modelo simples
FILAMENTO_D   = 1.75
AREA_FILA     = math.pi * (FILAMENTO_D/2.0)**2  # mm²

def e_para_trecho(compr_mm: float) -> float:
    """Converte o comprimento do trecho em mm do filamento a extrudar (E)."""
    volume = LARG_LINHA * ALTURA_CAM_MM * compr_mm   # mm³
    return volume / AREA_FILA                        # mm de filamento

def anel_g1(z: float, raio: float, nseg: int) -> list[str]:
    """Retorna linhas G-code (G1) aproximando um círculo com 'nseg' segmentos."""
    linhas = []
    # vai ao ponto inicial (ângulo 0) sem extrudar
    x0 = CENTRO_X + raio
    y0 = CENTRO_Y
    linhas.append(f"G0 X{x0:.3f} Y{y0:.3f} Z{z:.3f} F{VEL_VIAGEM}")

    ang_step = 2 * math.pi / nseg
    x_prev, y_prev = x0, y0
    for i in range(1, nseg + 1):
        ang = i * ang_step
        x = CENTRO_X + raio * math.cos(ang)
        y = CENTRO_Y + raio * math.sin(ang)
        L = math.hypot(x - x_prev, y - y_prev)
        e = e_para_trecho(L)
        linhas.append(f"G1 X{x:.3f} Y{y:.3f} E{e:.5f} F{VEL_IMPR}")
        x_prev, y_prev = x, y

    return linhas

# ===== Montagem do G-code =====
g = []
g.append("; ===== Ender-3 | Cilindro (tubo) – 10 camadas =====")
g.append(f"; Raio={RAIO_MM} mm | Camadas={CAMADAS} | h={ALTURA_CAM_MM} mm | centro=({CENTRO_X},{CENTRO_Y})")
g.append("G21            ; mm")
g.append("G90            ; posicoes absolutas")
g.append("M82            ; extrusao absoluta (padrão)")
g.append("G28            ; homing")
# Aquecimento opcional – descomente se for imprimir de verdade
#g.append("M104 S200      ; bico 200C (nao espera)")
#g.append("M140 S60       ; mesa 60C (nao espera)")
#g.append("M109 S200      ; bico 200C (espera)")
#g.append("M190 S60       ; mesa 60C (espera)")

g.append("G0 Z0.20 F1200 ; primeira camada")
g.append(f"G0 X{CENTRO_X:.3f} Y{CENTRO_Y:.3f} F{VEL_VIAGEM}")
g.append(f"G0 X{CENTRO_X+RAIO_MM:.3f} Y{CENTRO_Y:.3f} F{VEL_VIAGEM}")
g.append("M83            ; extrusao relativa")
g.append("G92 E0         ; zera extrusor")
z = ALTURA_CAM_MM

for camada in range(1, CAMADAS + 1):
    g.append(f"; --- Camada {camada}/{CAMADAS} (Z={z:.2f}) ---")
    g.extend(anel_g1(z, RAIO_MM, SEGMENTOS))
    if camada < CAMADAS:
        z += ALTURA_CAM_MM
        g.append(f"G0 Z{z:.3f} F{VEL_VIAGEM}")

# Finalização
g.append("G0 Z10 F3000   ; afasta a peça")
#g.append("M104 S0        ; desliga bico (se aqueceu)")
#g.append("M140 S0        ; desliga mesa (se aqueceu)")
g.append("M84            ; motores off")
g.append("; ================================================")

with open("cilindro_10camadas.gcode", "w", encoding="utf-8") as f:
    f.write("\n".join(g))

print("OK: arquivo gerado 'cilindro_10camadas.gcode'")

🔹 Conclusão

✅ Pontos positivos do que foi apresentado

• Você aprendeu que o G-code é apenas um arquivo texto, criado em qualquer editor ou até gerado automaticamente com Python.
• Vimos como montar um cilindro simples na Ender-3: cada camada é um círculo (ou anel) e, ao empilhar, formamos a peça 3D.
• O exercício mostrou que é possível entender a lógica por trás dos slicers (Cura, PrusaSlicer), ou seja, como os softwares de fatiamento transformam o modelo 3D em comandos de máquina.
• A integração com Python abriu espaço para automatizar a criação de trajetórias, o que pode ser aplicado tanto no ensino quanto em projetos reais.

---

🔧 O que pode ser melhorado no código

• Hoje usamos uma aproximação simples da extrusão. Podemos melhorar:
  • Calibrando melhor a relação entre comprimento da linha e extrusão (considerando fluxo real da impressora).
  • Adicionando duas ou mais paredes e infill (preenchimento interno) para criar cilindros sólidos.
  • Gerando movimentos de skirt/brim (bordas externas) para melhorar a aderência na mesa.
  • Inserindo parâmetros configuráveis como temperaturas, velocidades, e altura de camada em variáveis globais.
• Outra evolução seria criar uma função para gerar qualquer geometria básica (quadrados, triângulos, espirais) — ótimo como exercício de programação para alunos.

---

🏭 Como as empresas usam essa técnica em projetos avançados

• Na indústria 4.0, G-code é usado em usinagem CNC (torno, fresadora, router) para fabricar peças metálicas e plásticas com altíssima precisão.
• Em empresas de impressão 3D, o código é gerado automaticamente por slicers avançados, mas muitos engenheiros ainda ajustam o G-code manualmente para:
  • Criar estruturas de suporte inteligentes.
  • Controlar velocidades diferentes por região da peça.
  • Inserir pausas programadas (para troca de cor, inserir peças metálicas, sensores, etc).
• Em projetos mais complexos, o G-code pode ser integrado com simulações digitais (digital twins), verificando antes se a trajetória da ferramenta será eficiente, segura e otimizada.
• Grandes empresas usam até G-code adaptativo: a máquina lê sensores em tempo real (vibração, temperatura, pressão) e ajusta o código dinamicamente, algo que está evoluindo em direção à manufatura inteligente e autônoma.

---

👉 Ou seja, o que fizemos aqui — gerar um cilindro simples em Python — é uma porta de entrada para entender como máquinas e softwares conversam.
O conceito de criar e manipular arquivos de texto está presente em praticamente toda a computação:

• Impressão 3D e CNC → geração de arquivos G-code.
• Programação → arquivos usados por compiladores (código-fonte em C, Java, Python).
• Escritório → planilhas eletrônicas (CSV, XLSX), processadores de texto (DOCX, ODT, RTF) e apresentações (PPTX) são, na essência, arquivos de texto ou estruturados.
• Web → arquivos HTML, CSS e JSON, que formam sites e APIs.
• Banco de dados → exportação de informações em CSV, SQL scripts.
• Ciência de dados → geração automática de relatórios, datasets em TXT/CSV para análise.
• Automação → scripts Python criam logs de sistemas, arquivos de configuração e até relatórios prontos em PDF.

Assim, usar Python para construir e manipular arquivos não se limita ao G-code: abre uma gama enorme de aplicações, como:

• Criar relatórios automáticos de uma pesquisa.
• Gerar gráficos e salvar em arquivos para apresentação.
• Simular experimentos e salvar resultados em planilhas.
• Desenvolver conversores (por exemplo, transformar dados em XML, JSON ou YAML).
• Automatizar tarefas repetitivas em empresas, economizando tempo e reduzindo erros.

Esse mesmo raciocínio — simples, mas poderoso — é o que sustenta desde projetos escolares até sistemas industriais complexos, permitindo que a programação conecte ideias a resultados práticos no mundo real.

Este blog foi gerado com auxilio do CHATGPT 5.

Será utilizado em treinamento no curso técnico da Escola Estadual Diva Tarlá, em Ribeirão Preto.