PDS e Metodologias Ágeis
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.

PDS e Metodologias Ágeis
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:

SistemaPadrão/Dialeto G-codeUsado em
Ender-3Marlin/RepRap (G0, G1, G28, M104…)Impressoras 3D
FANUCISO G-code (muitos ciclos fixos, G71, G81, etc)CNC industrial (torno/fresa)
MitsubishiPróprio dialeto ISO compatível, similar ao FANUCCNC industrial
SiemensSinumerik (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.

Blog Dicas
Instalar o CH340 no UBUNTU

1) Pré-requisitos

Instale ferramentas de compilação e cabeçalhos do kernel:

sudo apt update
sudo apt install -y git build-essential dkms \
  linux-headers-$(uname -r) kmod mokutil

O dkms é opcional, mas útil para recompilar o módulo após atualização de kernel.

2) Baixar o código-fonte

git clone -b ubuntu https://github.com/juliagoda/CH341SER.git
cd CH341SER

3) Compilar

make

Se tudo der certo, será gerado ./ch34x.ko.

4) (Opcional) Assinar o módulo para Secure Boot

Se o Secure Boot estiver ativado, o kernel só carrega módulos assinados.

4.1) Tentar assinar com MOK existente

Se seu sistema já possui uma chave MOK instalada (caminho padrão do Ubuntu):

sudo kmodsign sha512 \
  /var/lib/shim-signed/mok/MOK.priv \
  /var/lib/shim-signed/mok/MOK.der \
  ./ch34x.ko

4.2) Se não existir MOK (arquivos ausentes)

Crie e insira uma MOK (vai pedir senha e requer reboot para concluir o enrolment):

sudo mokutil --import /var/lib/shim-signed/mok/MOK.der
# ou gere uma nova chave:
# sudo update-secureboot-policy --new-key
sudo reboot

Depois do reboot (MOK enrolada), volte à pasta do projeto e rode a assinatura (4.1).


5) Carregar o módulo

sudo make load

Isso deve carregar ch34x (e usbserial como dependência).
Para descarregar depois: sudo make unload ou sudo rmmod ch34x usbserial.


6) Verificar se o dispositivo apareceu

  1. Conecte seu Arduino/dispositivo CH341 na USB.
  2. Verifique logs e dispositivos:
dmesg | tail -n 50
lsmod | grep ch34
ls -l /dev/ttyUSB*

Você espera ver algo como ttyUSB0 sendo criado.


7) Tornar persistente (opcional)

Alguns Makefiles têm alvo install. Se existir:

sudo make install
sudo depmod -a

Sem install, você pode copiar manualmente e carregar no boot:

sudo mkdir -p /lib/modules/$(uname -r)/extra
sudo cp ./ch34x.ko /lib/modules/$(uname -r)/extra/
sudo depmod -a
echo ch34x | sudo tee /etc/modules-load.d/ch34x.conf

Com DKMS (se suportado pelo repo), o módulo recompila após updates de kernel. Este projeto não traz dkms.conf oficial; dá para criar um, mas mantendo simples, o passo acima resolve.


Compatibilidade

  • Não é compatível com a placa Olimex ESP32-POE rev C.

Solução de Problemas

A) dmesg não mostra ttyUSB*, apenas:

usbserial: USB Serial support registered for ch34x
ch34x 3-2:1.0: ch34x converter detected

Possíveis causas e correções:

  1. Dependências ausentes (compilação incompleta)
    • Refaça os passos 1 e 3, garantindo build-essential e linux-headers-$(uname -r) instalados.
  2. Conflito de hardware (protoboard)
    • Se o Arduino está ligado a uma protoboard com jumpers, desconecte os fios (curto/conexão indevida pode impedir a enumeração correta). Conecte apenas via USB, teste novamente.
  3. Cabeçalhos do kernel faltando
    • Instale linux-headers-$(uname -r) e recompile: sudo apt install -y linux-headers-$(uname -r) make clean && make
  4. Secure Boot bloqueando o módulo
    • Assine o módulo (Seção 4) e recarregue: sudo make unload sudo kmodsign sha512 /var/lib/shim-signed/mok/MOK.priv /var/lib/shim-signed/mok/MOK.der ./ch34x.ko sudo make load
  5. Kernel sem CONFIG_USB_SERIAL_CH341 (desativado/ausente)
    • Verifique a config do kernel: zcat /proc/config.gz | grep CH341 # ou grep CH341 /boot/config-$(uname -r)
    • Se estiver desabilitado, o módulo externo ch34x.ko deve suprir. Se ainda assim não carregar, revise mensagens do dmesg e confirme a versão do kernel/headers.
  6. Permissões/Regra udev
    • Adicione seu usuário ao grupo dialout e reconecte: sudo usermod -aG dialout $USER sudo reboot
    • Depois do reboot, teste novamente ls -l /dev/ttyUSB*.

B) Comando úteis de diagnóstico

modinfo ./ch34x.ko
sudo modprobe ch34x
dmesg | tail -n 100
journalctl -k -b | grep -i ch34

Dicas finais

  • Sempre teste com outro cabo USB e outra porta.
  • Evite hubs USB sem alimentação ao usar placas que consomem mais corrente.
  • Para Arduino: desconecte tudo da protoboard, conecte apenas USB, identifique ttyUSB*, e só então reconecte os periféricos.

Este tutorial foi baseado na seguinte referencia.

https://github.com/juliagoda/CH341SER?tab=readme-ov-file#tutorial-on-ubuntu

Dicas
Instalar o USB VGA no Ubuntu

Nota o Fresco Logic FL200/FL2000DX VGA/DVI/HDMI Adapter não funciona com este procedimento.

É possível instalar um monitor adicional no linux, usando um adaptador USB/VGA conforme o da foto.

O DisplayLink permite utilizar monitores adicionais através de conexões USB em docks, adaptadores e monitores compatíveis. No Ubuntu, há duas formas de instalar o driver:

  1. Repositório APT da Synaptics (recomendado, pois permite atualizações automáticas junto com o sistema).
  2. Instalador Standalone (instalação manual).

O procedimento abaixo descreve como instalar em uma maquina linux ubuntu.


✅ Método 1: Instalação via Repositório APT da Synaptics (Recomendado)

Esse método facilita atualizações e integração com o sistema.

Passo 1 – Baixar o pacote do repositório

Faça o download do pacote synaptics-repository-keyring.deb no site oficial da Synaptics.

https://www.synaptics.com/sites/default/files/Ubuntu/pool/stable/main/all/synaptics-repository-keyring.deb

O arquivo geralmente será salvo na pasta Downloads.

Passo 2 – Instalar o repositório

No terminal, execute (ajuste o caminho se necessário):

sudo apt install ./Downloads/synaptics-repository-keyring.deb

Passo 3 – Atualizar o cache do APT

Depois de adicionar o repositório, atualize os pacotes:


sudo apt update

Passo 4 – Instalar o driver DisplayLink

Agora instale o driver:

sudo apt install displaylink-driver

Pronto! O driver será instalado e integrado ao sistema.

⚠️ Atenção: se você já instalou a versão standalone anteriormente, desinstale-a primeiro antes de usar esse método.


✅ Método 2: Instalação com o Standalone Installer

Se preferir instalar manualmente:

Passo 1 – Baixar o instalador

Baixe o pacote mais recente do DisplayLink para Ubuntu diretamente no site oficial.

Passo 2 – Instalar o driver

No terminal, acesse a pasta onde está o arquivo e execute:

sudo apt install ./displaylink-driver-x.x.xx-xubuntu-x.deb

(Substitua o nome do arquivo pelo que você baixou.)


ℹ️ Observações Importantes

Alguns fabricantes podem não oferecer suporte técnico caso você use o driver genérico.

Esse é um driver genérico de referência. O fabricante do seu dock, monitor ou adaptador USB pode fornecer drivers específicos no site deles.

A DisplayLink recomenda sempre verificar primeiro com o fabricante do equipamento se há um driver atualizado.

Este artigo foi baseado no artigo a baixo, e foi usado IA para auxiliar no preparo:

https://www.synaptics.com/products/displaylink-graphics/downloads/ubuntu

Fila
Nova Versão do Fila

Na versão 1.22 do fila, incluímos muitas evoluções.

Alem do visual melhorado, tambem incluimos versões desktop para o painel de senhas, bem como funcionalidades melhoradas no guichê e no fila.

Por ultimo, incluímos a versão Linux do Guichê que contará com atualizações para windows e Linux.

O instalador do guich}

https://github.com/marcelomaurin/fila

TreinamentoIA
Projeto: Chatbot Inteligente para Processos e Procedimentos com Atualização Automática e Fallback para ChatGPT (Base MySQL)

1. Introdução

Este projeto propõe o desenvolvimento de um chatbot inteligente voltado para dúvidas sobre processos e procedimentos, utilizando exclusivamente um banco de dados relacional (MySQL) como fonte principal de consulta, sem uso de bancos vetoriais como ChromaDB. O sistema será capaz de pesquisar documentos, apresentar respostas, registrar feedback dos usuários e, em caso de respostas insuficientes, recorrer à API do ChatGPT como fallback.


2. Objetivos

  • Automatizar o atendimento a dúvidas sobre processos e procedimentos documentados.
  • Permitir atualização automática diária do conhecimento do chatbot com novos documentos.
  • Garantir precisão e cobertura das respostas, recorrendo ao ChatGPT em caso de dúvidas não solucionadas localmente.
  • Permitir avaliação do usuário e contínua evolução do sistema.

3. Arquitetura e Frameworks Utilizados

3.1 Principais Frameworks e Bibliotecas

  • Python 3.9+: Linguagem principal do sistema.
  • MySQL: Banco relacional para armazenar documentos, textos extraídos, logs, feedback e metadados.
  • mysql-connector-python ou SQLAlchemy: Conexão e manipulação do MySQL em Python.
  • pdfminer.six: Extração de texto de PDFs.
  • python-docx: Extração de texto de arquivos Word.
  • OpenAI (API): Integração com ChatGPT para fallback.
  • Unstructured (opcional): Para leitura flexível de múltiplos formatos.
  • Streamlit ou Flask (opcional): Interface web para interação com usuário e avaliação de respostas.
  • Agendador de tarefas (cron, Task Scheduler): Para automação da ingestão e atualização diária de documentos.

4. Metodologias Utilizadas

  • Busca textual clássica (SQL): As perguntas dos usuários são tratadas como consultas de texto, usando buscas por palavra-chave (LIKE, FULLTEXT).
  • Fallback Inteligente: Caso nenhuma resposta relevante seja localizada no MySQL, a pergunta é repassada ao ChatGPT via API.
  • Ciclo de Aprendizagem Contínua: Feedback do usuário para identificar perguntas mal respondidas e melhorar a base.
  • Automação de atualização diária: Script agendado para processar novos documentos e atualizar o banco de dados.

5. Etapas do Projeto

5.1 Planejamento e Levantamento de Requisitos

  • Definição dos tipos de documentos a serem processados (PDF, DOCX, TXT).
  • Estruturação das pastas: /docs_novos/ para documentos a indexar, /docs_indexados/ para documentos já processados.
  • Estruturação do banco MySQL: tabelas para documentos, logs, feedback, usuários.

5.2 Ambiente e Infraestrutura

  • Instalação do Python e bibliotecas necessárias.
  • Instalação e configuração do MySQL Server.
  • Criação do banco de dados e tabelas.

5.3 Processamento e Indexação de Documentos

  • Extração de texto de PDFs e Word usando pdfminer.six e python-docx.
  • Inserção dos textos extraídos na tabela de documentos do MySQL, com campos como: ID, nome do arquivo, texto, data, usuário, etc.

5.4 Desenvolvimento do Chatbot

  • Recebimento da pergunta do usuário via interface CLI, Web ou API.
  • Consulta ao MySQL utilizando SQL FULLTEXT SEARCH (ou LIKE) para encontrar o(s) documento(s) mais relevante(s).
  • Exibição da resposta ao usuário.
  • Caso a resposta seja vazia ou não satisfatória, consulta à API do ChatGPT.
  • Registro da interação e da avaliação do usuário.

5.5 Automatização da Atualização Diária

  • Script automatizado, agendado, para processar novos documentos diariamente:
    • Extração do texto.
    • Inserção no banco de dados.
    • Movimentação dos arquivos para pasta de processados.

5.6 Interface com o Usuário e Feedback

  • (Opcional) Interface web para consulta e avaliação das respostas.
  • Registro do feedback do usuário em tabela específica para análise futura.

5.7 Testes e Validação

  • Testes unitários dos scripts de processamento.
  • Testes de busca e precisão de respostas.
  • Testes de fallback e integração com ChatGPT.

5.8 Documentação e Treinamento

  • Documentação detalhada do sistema, scripts e uso.
  • Treinamento dos usuários e administradores do sistema.

6. Considerações Técnicas

6.1 Limitações da Busca no MySQL

  • Busca por palavra-chave: O MySQL não realiza buscas semânticas, ou seja, depende da correspondência exata ou parcial das palavras da pergunta com o texto dos documentos.
  • Alternativa: É possível usar o recurso FULLTEXT do MySQL para buscas em campos grandes (LONGTEXT), mas não substitui a busca vetorial.
  • Melhoria futura: Caso necessário, pode-se integrar futuramente um banco vetorial para busca semântica avançada.

7. Estrutura Sugerida de Tabelas MySQL

sqlCopiarEditarCREATE TABLE documentos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nome_arquivo VARCHAR(255),
    texto LONGTEXT,
    data_upload DATETIME,
    usuario VARCHAR(100)
);

CREATE TABLE interacoes (
    id INT AUTO_INCREMENT PRIMARY KEY,
    id_documento INT,
    pergunta TEXT,
    resposta TEXT,
    foi_fallback BOOLEAN,
    data DATETIME,
    FOREIGN KEY (id_documento) REFERENCES documentos(id)
);

CREATE TABLE feedback (
    id INT AUTO_INCREMENT PRIMARY KEY,
    id_interacao INT,
    avaliacao ENUM('boa','ruim'),
    comentario TEXT,
    data DATETIME,
    FOREIGN KEY (id_interacao) REFERENCES interacoes(id)
);

8. Resumo dos Frameworks e Bibliotecas

Framework/BibliotecaFunção
Python 3.9+Linguagem principal
MySQLBanco relacional, principal repositório
mysql-connector-pythonConexão Python-MySQL
pdfminer.sixLer PDF
python-docxLer Word
OpenAI (API)ChatGPT (fallback)
UnstructuredLer múltiplos formatos (opcional)
Streamlit/Flask (opcional)Interface web

9. Metodologias

  • Busca textual clássica (FULLTEXT/LIKE)
  • Fallback Inteligente
  • Aprendizagem Contínua (feedback)
  • Automação de ingestão de dados

10. Considerações Finais

O projeto propõe uma solução prática, fácil de gerenciar e com requisitos tecnológicos acessíveis, usando o MySQL como núcleo do sistema. Garante automatização da base de conhecimento, integração com IA de ponta (ChatGPT), avaliação do usuário e flexibilidade para futuras expansões.


PDS e Metodologias Ágeis
🔬💡 Projeto/Prática: Como um Sistema Computacional Pode Resolver Problemas de Eletrônica – O Cálculo da Resistência de um LED Usando Python

🔋💡 História: A Lâmpada Misteriosa de Lucas

Lucas tem 16 anos, é curioso e adora desmontar coisas. Um dia, enquanto mexia numa caixa de sucata do avô, encontrou uma pequena lâmpada de LED vermelha e uma bateria de 9V.

“Será que consigo acender isso?”, pensou, empolgado.

Ele conectou o LED direto na bateria. Por um instante, ele brilhou forte… e depois queimou!

“Mas por que isso aconteceu? Não era só ligar e pronto?”

Frustrado, Lucas correu até sua irmã Ana, que estava estudando para a prova de física. Ela olhou para ele e sorriu:

Ana: “Lucas, você acabou de aprender na prática o que eu estudei hoje: Lei de Ohm e eletricidade básica.”


🔌 Capítulo 1 – A Descoberta da Eletricidade

Ana pegou um papel e começou a desenhar:

Ana: “Lembra que a gente aprendeu que a eletricidade é o movimento dos elétrons?
Na escola, estudamos tensão (voltagem), que é como a pressão da água num cano, e corrente, que é como o fluxo dessa água. E tem também a resistência, que é como se fosse um aperto no cano que controla o fluxo.”

Lucas, curioso, respondeu:
Lucas: “Ah, então quando liguei o LED direto na bateria, era como jogar um jato de água sem controle?”

Ana: “Exatamente! O LED não aguenta toda essa ‘pressão’. É por isso que ele queimou.”


📐 Capítulo 2 – A Lei de Ohm

Ana escreveu a fórmula da Lei de Ohm no caderno: V=R⋅IV = R \cdot IV=R⋅I

Ana: “Olha só: se reorganizarmos, podemos calcular a resistência necessária:” R=Vfonte−VLEDILEDR = \frac{V_\text{fonte} – V_\text{LED}}{I_\text{LED}}R=ILED​Vfonte​−VLED​​

Lucas ficou intrigado.
Lucas: “Então preciso de um resistor para proteger o LED?”

Ana: “Sim! Isso é exatamente o que aprendemos em física: controlar a corrente usando resistência.”

Ela explicou que cada cor de LED tem uma queda de tensão típica. Pegou uma tabela na internet:

Cor do LEDTensão típica (V)
🔴 Vermelho2,0 V
🟢 Verde2,2 V
🔵 Azul3,0 V
⚪ Branco3,2 V

💻 Capítulo 3 – O Computador como Ferramenta

Lucas, empolgado, disse:
Lucas: “Mas calcular isso toda hora é chato. Vou programar isso!”

Ele abriu o notebook e escreveu em Python:

def calcular_resistencia(v_fonte, v_led, i_led_mA):
    """
    Calcula a resistência ideal para um LED usando a Lei de Ohm.
    v_fonte: tensão da fonte (Volts)
    v_led: tensão típica do LED (Volts)
    i_led_mA: corrente do LED (miliamperes)
    """
    i_led = i_led_mA / 1000  # converte mA para A
    return (v_fonte - v_led) / i_led

print("=== Sistema Computacional: Cálculo de Resistor para LED ===")
v_fonte = float(input("Digite a tensão da fonte (V): "))
v_led = float(input("Digite a tensão do LED (V): "))
i_led_mA = float(input("Digite a corrente do LED (mA): "))

resistor = calcular_resistencia(v_fonte, v_led, i_led_mA)
print(f"\n🔧 Resistor recomendado: {resistor:.2f} Ω")
print("Use o valor comercial mais próximo.")

Ele digitou os valores:

  • Fonte: 9V
  • LED vermelho: 2V
  • Corrente: 20mA

O computador respondeu:

Resistor recomendado: 350.00 Ω

Lucas ficou maravilhado:
Lucas: “Então com um resistor de 350Ω, meu LED vai funcionar sem queimar?”

Ana: “Sim! E olha como você aplicou física e programação juntas. Isso é exatamente o que estamos aprendendo no segundo grau: usar conceitos teóricos para resolver problemas práticos.”


🔬 Capítulo 4 – A Experiência Prática

No dia seguinte, Lucas levou o circuito para a escola. Na aula de física, a professora pediu que os alunos montassem o mesmo experimento em protoboards.

Eles testaram resistores diferentes:

  • Com 330Ω: LED brilhante, seguro.
  • Com 1kΩ: LED fraco, mas protegido.
  • Sem resistor: queimou na hora.

A turma riu quando viram o LED queimando sem resistor, e todos compreenderam de forma prática o motivo da existência dos resistores.


🎓 Conclusão da História

Ao final da aula, a professora disse:

“O que Lucas fez foi criar um sistema computacional para resolver um problema real de eletrônica. Ele aplicou conceitos de física (Lei de Ohm), eletrônica (uso de resistores) e programação (Python) de forma integrada.”

Lucas sorriu. Agora, sempre que via um LED acender — seja na TV, no celular ou até no semáforo — ele lembrava que havia ciência e cálculo por trás daquele simples pontinho de luz.


🧩 Plano Prático para Aplicação

Inspirado na história de Lucas, você fará o mesmo em sala de aula:

  1. Revisar física básica: tensão, corrente e resistência.
  2. Aprender a Lei de Ohm: com exemplos simples e analogias.
  3. Programar em Python: criar o cálculo automático do resistor.
  4. Montar o circuito: usar LED, bateria e resistores em protoboard.
  5. Testar valores diferentes: ver o LED acender, ficar fraco ou queimar.
  6. Discutir resultados: refletir sobre como ciência e tecnologia se complementam.

Vamos a prática

🔧 Multímetro

O multímetro é uma ferramenta essencial para medir e testar circuitos elétricos. Ele será usado no projeto para:

  • Medir a tensão da fonte (V): verificar se a bateria ou fonte realmente fornece 9V (ou o valor configurado).
  • Medir a resistência do resistor (Ω): confirmar se o resistor utilizado tem o valor correto, conforme a tabela de cores.
  • Verificar continuidade: testar se as ligações na protoboard estão corretas e sem falhas.

📌 Aplicação no projeto: Antes de ligar o LED, os alunos vão usar o multímetro para conferir a voltagem da fonte e o valor do resistor escolhido. Isso evita erros e garante segurança.


🔌 Protoboard

A protoboard será o espaço para montar e testar o circuito do LED sem necessidade de solda.

  • Permite inserir a bateria, resistor e LED facilmente.
  • Possui trilhas internas conectadas que facilitam a montagem e modificação rápida do circuito.
  • Ideal para experimentação, como trocar resistores e observar o efeito no brilho do LED.

📌 Aplicação no projeto: Os alunos irão montar o circuito calculado (Fonte → Resistor → LED) na protoboard e testar os diferentes valores de resistência.


🎨 Tabela de Cores dos Resistores

Os resistores têm faixas coloridas que indicam seu valor em Ohms. Essa tabela será usada para identificar e confirmar os resistores corretos para o projeto.

CorNúmero
Preto0
Marrom1
Vermelho2
Laranja3
Amarelo4
Verde5
Azul6
Violeta7
Cinza8
Branco9
  • Duas primeiras cores: dígitos do valor.
  • Terceira cor: multiplicador.
  • Quarta cor: tolerância (ex.: dourado = ±5%).

📌 Aplicação no projeto: Após calcular o valor com Python, os alunos vão:

  1. Consultar a tabela de cores para escolher o resistor adequado.
  2. Conferir com o multímetro se o valor está correto.
  3. Montar na protoboard e observar o LED funcionando.

🔬 Fluxo Prático no Projeto

1️⃣ Calcular no Python o valor do resistor.
2️⃣ Identificar o resistor pela tabela de cores.
3️⃣ Medir no multímetro para confirmar o valor.
4️⃣ Montar o circuito na protoboard com a fonte, resistor e LED.
5️⃣ Ligar e observar: testar brilho e segurança do LED.
6️⃣ Experimentar resistores de valores diferentes e anotar os resultados.


🧪 Apresentação da Prática: Cálculo e Montagem de Circuito com LED e Resistor

🎯 Objetivo da Prática

  • Compreender na prática a relação entre tensão, corrente e resistência usando a Lei de Ohm.
  • Utilizar Python para calcular o resistor ideal para um LED.
  • Aprender a identificar resistores pela tabela de cores e confirmar seu valor com um multímetro.
  • Montar um circuito real em uma protoboard e testar seu funcionamento.

🗂 Etapas da Apresentação

🔹 1. Introdução Teórica (15 min)

Objetivo: Relembrar conceitos fundamentais e contextualizar o experimento.

  • Início lúdico: Mostrar imagens de LEDs em objetos do dia a dia (TVs, semáforos, celulares).
  • Explicar rapidamente os conceitos de tensão (voltagem), corrente elétrica e resistência, usando a analogia da água em um cano:
    • Tensão = pressão da água.
    • Corrente = fluxo da água.
    • Resistência = estreitamento no cano que limita o fluxo.
  • Introduzir a Lei de Ohm e sua fórmula: V=R⋅I⇒R=Vfonte−VLEDILEDV = R \cdot I \quad \Rightarrow \quad R = \frac{V_\text{fonte} – V_\text{LED}}{I_\text{LED}}V=R⋅I⇒R=ILED​Vfonte​−VLED​​
  • Mostrar a tabela de tensões dos LEDs (diferentes cores, diferentes tensões).

🔹 2. Demonstração de Ferramentas (15 min)

Objetivo: Familiarizar os alunos com os instrumentos e componentes.

  • Protoboard: Mostrar como é a distribuição interna de trilhas (linhas horizontais e verticais).
  • Multímetro:
    • Demonstrar como medir tensão da fonte (modo Volts DC).
    • Demonstrar como medir resistência de resistores (modo Ohms).
  • Tabela de cores de resistores:
    • Explicar como identificar resistores com base nas faixas coloridas.
    • Exemplo prático: um resistor vermelho-violeta-marrom-dourado é 270Ω ±5%.

🔹 3. Programação do Cálculo (20 min)

Objetivo: Aplicar programação para automatizar o cálculo do resistor.

  • Apresentar o código Python para cálculo do resistor.
  • No computador ou Google Colab, pedir para os alunos executarem:
    • Fonte: 9V
    • LED: Vermelho (2V)
    • Corrente: 20mA
  • O programa retorna: 350Ω.
  • Discutir sobre o resistor comercial mais próximo (330Ω).

🔹 4. Identificação e Teste do Resistor (15 min)

Objetivo: Relacionar cálculo teórico com identificação prática.

  • Cada grupo escolhe um resistor conforme o cálculo.
  • Usar a tabela de cores para identificar o valor correspondente.
  • Confirmar com o multímetro se o valor bate com o esperado.

🔹 5. Montagem na Protoboard (20 min)

Objetivo: Aplicar física e programação para criar o circuito.

  • Montar o circuito:
    • Fonte (bateria de 9V ou fonte de bancada).
    • Resistor calculado.
    • LED conectado na posição correta (anodo e catodo).
  • Conferir as conexões com o multímetro (continuidade).
  • Ligar o circuito e observar o LED acendendo.

🔹 6. Testes Experimentais (20 min)

Objetivo: Observar efeitos práticos de diferentes resistências.

  • Trocar o resistor por valores diferentes:
    • Menor valor: LED mais brilhante (risco de queimar).
    • Maior valor: LED mais fraco, mas protegido.
    • Sem resistor: LED queimando (feito com um LED de demonstração pelo professor).
  • Discutir o efeito de cada mudança e como a resistência controla a corrente.

🔹 7. Encerramento e Discussão (15 min)

Objetivo: Consolidar os conceitos.

  • Revisar:
    • Como a Lei de Ohm foi aplicada.
    • Como o Python ajudou no cálculo automático.
    • O uso do multímetro para validar componentes.
    • A importância da protoboard para testes seguros.
  • Relacionar com situações do cotidiano (fontes de energia, carregadores de celular, luzes LED em carros).
  • Convidar os alunos a criar novos cálculos e testar LEDs de diferentes cores.

🧩 Materiais Necessários

  • Protoboard.
  • LEDs de diferentes cores.
  • Resistores variados.
  • Fonte de alimentação (bateria 9V ou fonte regulada).
  • Multímetros digitais (um por grupo).
  • Computador ou celular com Python (Google Colab).
  • Tabela de cores de resistores impressa.

🔬 Resultados Esperados

  • Compreensão clara de como calcular e testar resistores.
  • Capacidade de usar ferramentas práticas como multímetro e protoboard.
  • Entender a integração entre física teórica e aplicação prática.
  • Visualizar como programação ajuda a resolver problemas reais de eletrônica.
Sem categoria
Trabalho de Computação para lancamento de dados
class LancadorDeDados:
def init(self, nro_lancamentos):
self.nro_lancamentos = nro_lancamentos
self.nro_ocorrencias = 6 # dado com 6 faces

def calculaPercentual(self):
"""Calcula o percentual usando a fórmula: (1/nro_ocorrencias)^nro_lancamentos."""
return (1 / self.nro_ocorrencias) ** self.nro_lancamentos * 100

def mostrar_percentual(self):
"""Mostra o resultado do cálculo."""
percentual = self.calculaPercentual()
print(f"Lançamentos: {self.nro_lancamentos} → Percentual: {percentual:.4f}%")

==========================

Programa principal no Colab

==========================

for n in range(1, 6): # Calcula de 1 até 5 lançamentos consecutivos
dado = LancadorDeDados(nro_lancamentos=n)
dado.mostrar_percentual()

🎲 Probabilidade de Lançamentos Consecutivos de um Dado

Este programa calcula a probabilidade percentual de ocorrer uma sequência específica de resultados ao lançar um dado de 6 faces diversas vezes de forma consecutiva.

Ele utiliza a fórmula de probabilidade para eventos independentes:

Percentual = (1 / nro_faces) ^ nro_lancamentos × 100


🧠 Conceito por trás do cálculo

Cada lançamento de um dado justo de 6 faces possui probabilidade igual de 1/6 para cada face.

Como os lançamentos são eventos independentes, a chance de obter o mesmo resultado consecutivamente é dada pela multiplicação das probabilidades.

Para transformar isso em percentual, multiplicamos o resultado por 100.

Exemplos:

1 lançamento:

P = (1 / 6) × 100 ≈ 16,67%

2 lançamentos consecutivos iguais:

P = (1 / 6)² × 100 ≈ 2,78%

3 lançamentos consecutivos iguais:

P = (1 / 6)³ × 100 ≈ 0,46%

🖥️ O que o programa faz

  1. Define uma classe chamada LancadorDeDados.
  2. Recebe como parâmetro o número de lançamentos consecutivos que será analisado.
  3. Aplica a fórmula de probabilidade usando o número de faces do dado (6) e a quantidade de lançamentos informada.
  4. Exibe o resultado em percentual.

📌 Saída esperada

O programa mostra o percentual de chance para cada quantidade de lançamentos consecutivos:

Testando o resultado

Neste programa testaremos se o resultado apresentado, condiz com a prática.

A idéia é lançar o dado muitas vezes e acompanhar as estatísticas de seu lançamento.

class LancadorDeDados:
def init(self):
self.resultados = [] # Lista para armazenar os lançamentos

def registrar_lancamento(self, valor):
    """Registra o valor digitado pelo usuário."""
    if 1 <= valor <= 6:
        self.resultados.append(valor)
    else:
        print("⚠️ Valor inválido! Digite apenas números de 1 a 6.")

def calculaPercentual(self, ocorrencias, total):
    """Calcula o percentual de ocorrência."""
    return (ocorrencias / total) * 100 if total > 0 else 0

def mostrar_estatistica(self):
    """Exibe a estatística atualizada após cada lançamento."""
    total = len(self.resultados)
    print(f"\n📊 Estatística após {total} lançamentos:")
    for face in range(1, 7):
        ocorrencias = self.resultados.count(face)
        percentual = self.calculaPercentual(ocorrencias, total)
        print(f"Face {face}: {ocorrencias} ocorrências ({percentual:.2f}%)")

def mostrar_relatorio_final(self):
    """Exibe o relatório final consolidado."""
    print("\n✅ Relatório Final:")
    self.mostrar_estatistica()

==========================

Programa principal no Colab

==========================

dado = LancadorDeDados()

print("🎲 Digite os valores obtidos no lançamento do dado (1 a 6).")
print("Digite 0 para encerrar.\n")

while True:
valor = int(input("Digite o valor do dado (1 a 6) ou 0 para sair: "))
if valor == 0:
break
dado.registrar_lancamento(valor)
dado.mostrar_estatistica()

Relatório final consolidado

dado.mostrar_relatorio_final()

🎲 Programa de Estatística de Lançamentos de Dado

Este programa permite registrar manualmente os resultados de lançamentos de um dado e calcular a estatística de frequência e percentual de cada face (1 a 6) em tempo real.
O programa segue um loop contínuo onde o usuário digita o valor obtido em cada lançamento, e ao digitar 0 o sistema encerra e apresenta o relatório final consolidado.


🧠 Conceito

A estatística apresentada pelo programa é baseada na frequência relativa de cada face, calculada como:


Percentual da Face = (Número de ocorrências da face / Total de lançamentos) × 100

Isso permite observar a distribuição das faces e como ela evolui à medida que mais lançamentos são registrados.


🖥️ Funcionalidades

  • O programa é estruturado com a classe LancadorDeDados.
  • Permite entradas manuais dos resultados dos lançamentos do dado.
  • A cada número digitado, a estatística de todas as faces (1 a 6) é atualizada e exibida.
  • O programa continua recebendo valores até que o usuário digite 0.
  • Ao encerrar, é exibido um relatório final consolidado.

🔑 Métodos da Classe

__init__(self)

  • Inicializa a lista self.resultados para armazenar os lançamentos.

registrar_lancamento(self, valor)

  • Registra o valor digitado pelo usuário (de 1 a 6).
  • Ignora e alerta se o valor for inválido.

calculaPercentual(self, ocorrencias, total)

  • Calcula o percentual de ocorrências de uma face específica em relação ao total de lançamentos.

mostrar_estatistica(self)

  • Mostra a estatística atualizada (ocorrências e percentuais) após cada lançamento digitado.

mostrar_relatorio_final(self)

  • Exibe o relatório final consolidado com os resultados e percentuais finais de todas as faces.

🎯 Tarefa: Aplicando Estatística com Lançamentos de Dado

Objetivo:

Utilizar o programa de estatística de lançamentos de dado para registrar resultados reais e comparar com os valores teóricos de probabilidade, entendendo como a frequência relativa se aproxima da probabilidade real à medida que aumentamos o número de lançamentos.


📝 Instruções:

  1. Acesse e execute o programa no Google Colab que registra os lançamentos de um dado e calcula as estatísticas.
  2. Simule lançamentos reais:
    • Use um dado físico (se disponível) ou um simulador online.
    • Digite no programa o resultado de cada lançamento.
    • Continue lançando até atingir diferentes tamanhos de amostra:
      • 10 lançamentos
      • 30 lançamentos
      • 50 lançamentos
      • 100 lançamentos
  3. Observe como os percentuais calculados pelo programa se aproximam dos valores teóricos (aproximadamente 16,67% para cada face).
  4. Finalize digitando “0” para encerrar e visualizar o relatório final consolidado.

🔎 Reflexão:

  • Compare os resultados obtidos para amostras pequenas (10 ou 30 lançamentos) com os resultados para amostras grandes (50 ou 100 lançamentos).
  • Responda:
    • Quanto maior o número de lançamentos, os percentuais ficaram mais próximos do valor esperado (16,67%)?
    • Por que isso acontece?

📌 Conclusão Esperada:

Os alunos devem perceber que:

  • Com poucos lançamentos, a distribuição é mais irregular e os percentuais variam bastante.
  • Com mais lançamentos (maior amostra), os percentuais tendem a se estabilizar e se aproximar dos valores teóricos de probabilidade.

Isso demonstra, na prática, a Lei dos Grandes Números, um princípio fundamental da estatística e probabilidade.

Google Colab Exemplo

Desenvolvimento de Software
A base da IA

📊 Estatística, Cadeias de Markov e Inteligência Artificial na Predição de Texto


1️⃣ O que é Estatística em Predição de Texto?

  • Predição de texto = prever a próxima palavra com base em um contexto.
  • A estatística é usada para calcular probabilidades de palavras.
  • Modelos simples usam apenas frequência de palavras.

🔎 Exemplo sem conexão (Unigrama):

  • Texto: “O gato dorme. O gato corre.”
  • Palavra mais comum: “O” → Sempre sugerida.

Limite: Não entende contexto. Pode gerar sugestões sem sentido.


2️⃣ Estatística com Conexão: N-gramas

  • Agora usamos palavras anteriores para prever a próxima.
  • Probabilidade condicional: P(palavra∣histoˊrico)P(\text{palavra}|\text{histórico})P(palavra∣histoˊrico)

🔎 Exemplo:

  • Após “O gato”:
    • “dorme” → 50%
    • “corre” → 50%

Agora o modelo entende contexto básico.


3️⃣ Cadeias de Markov

  • Modelo estatístico que usa apenas o estado atual para prever o próximo.
  • Ideal para textos simples e sequenciais.

🔧 Como funciona:

  1. Contar transições entre palavras.
  2. Criar uma matriz de probabilidades.
  3. Escolher a próxima palavra com base nas probabilidades.

🖥 Exemplo prático:

  • “O gato dorme” → 70%
  • “O gato corre” → 30%

Usado em preditores antigos como T9 de celulares.


4️⃣ Limitações das Cadeias de Markov

  • Só consideram poucas palavras anteriores.
  • Não entendem contexto amplo (sentido da frase).
  • Dificuldade em lidar com dependências longas.

https://youtu.be/sANCpLOZPIo?si=UkJ0P7unx1tepvH2

5️⃣ Evolução: Redes Neurais

  • Surgem os modelos de Deep Learning.
  • Aprendem representações matemáticas de palavras (embeddings).
  • Consideram contextos maiores e relações complexas.

🔎 Exemplos: Word2Vec, RNN, LSTM


6️⃣ O Futuro: Inteligência Artificial e Transformers

  • Modelos atuais como GPT, BERT, LLaMA:
    • Usam bilhões de parâmetros.
    • Compreendem contexto amplo e semântico.
    • Preveem palavras com base em atenção (transformers).
  • Não apenas predição de texto, mas entendimento de linguagem natural.

Aplicações:

  • Chatbots (ex: ChatGPT)
  • Autocompletar inteligente
  • Assistentes virtuais
  • Tradução automática

🚀 Conclusão

  • Estatística → N-gramas → Cadeias de Markov → Redes Neurais → IAs modernas.
  • Cada etapa aumentou o contexto e a inteligência das previsões.
  • Hoje, IA transforma simples predição de texto em conversas naturais e criativas.

💡 Frase de impacto final:

“A estatística deu os primeiros passos, mas as IAs atuais nos fizeram correr maratonas na linguagem!”

carreiras e competencias
🎭 Teatro das Competências: Empatia, Comunicação e Colaboração

1️⃣ Objetivo da Atividade

O Teatro das Competências tem como meta:

  • Desenvolver habilidades socioemocionais (empatia, comunicação assertiva, escuta ativa e colaboração).
  • Simular situações reais do mercado de trabalho em ambiente controlado e participativo.
  • Incentivar criatividade, improviso e trabalho em equipe.

2️⃣ Explicação Inicial para a Turma

Professor pode falar:

“Hoje vamos trabalhar situações comuns do ambiente profissional por meio de encenações rápidas. Vocês vão receber roteiros baseados em desafios reais, como conflitos entre colegas, atendimento a clientes insatisfeitos, brainstorming de ideias e entrevistas simuladas.

O objetivo não é apenas ‘atuar’, mas mostrar como resolver problemas usando empatia, comunicação clara e colaboração. No fim, vamos discutir juntos o que funcionou bem e o que poderia ser melhorado.”


3️⃣ Regras do Jogo

  1. Formação dos grupos: 3 a 4 integrantes por grupo.
  2. Distribuição dos roteiros: Cada grupo recebe um caso diferente.
  3. Tempo de preparação: 10 minutos para ler, discutir papéis e ensaiar.
  4. Apresentação: Cada grupo terá 3 a 5 minutos para encenar.
  5. Feedback: Após cada apresentação, a turma e o professor comentam os pontos positivos e sugerem melhorias.

4️⃣ Papéis e Roteiros Prontos

Cada grupo recebe um roteiro impresso com: situação, contexto, papéis e objetivos.


🎭 Roteiro 1: Conflito entre colegas de trabalho

  • Situação: Dois colaboradores discordam sobre a melhor forma de entregar um relatório urgente. O gerente intervém para mediar.
  • Papéis:
    • Colaborador 1: Quer entregar rápido, mesmo que simples.
    • Colaborador 2: Prefere perfeição, mesmo que atrase.
    • Gerente: Deve ouvir os dois lados e propor uma solução equilibrada.
  • Objetivo: Mostrar negociação, escuta ativa e busca de consenso.

🎭 Roteiro 2: Cliente insatisfeito

  • Situação: Um cliente está irritado com um serviço entregue errado. O atendente precisa resolver.
  • Papéis:
    • Cliente: Está nervoso e exige solução imediata.
    • Atendente: Deve ouvir com empatia e propor alternativas.
    • Supervisor: Apoia o atendente e valida a solução final.
  • Objetivo: Demonstrar comunicação calma e resolução eficaz de conflitos.

🎭 Roteiro 3: Brainstorming de inovação

  • Situação: Equipe precisa criar uma campanha publicitária inovadora em curto prazo.
  • Papéis:
    • Líder: Organiza a reunião e dá voz a todos.
    • Criativo: Traz ideias ousadas e diferentes.
    • Cético: Questiona custos e prazos das ideias.
    • Mediador: Tenta conciliar criatividade e viabilidade.
  • Objetivo: Mostrar colaboração e integração de ideias diferentes.

🎭 Roteiro 4: Entrevista de emprego em grupo

  • Situação: Entrevista dinâmica para vaga de trainee.
  • Papéis:
    • Entrevistador: Observa comportamento e interação entre candidatos.
    • Candidato colaborativo 1: Trabalha bem em equipe e ajuda os colegas.
    • Candidato colaborativo 2: Similar ao 1, mas traz ideias próprias.
    • Candidato competitivo: Quer brilhar sozinho e atrapalha o grupo.
  • Objetivo: Mostrar como postura e trabalho em equipe impactam em seleções reais.

5️⃣ Orientações para os Papéis

Cada participante deve receber uma ficha individual, contendo:

  • Nome do papel (ex.: Gerente, Cliente, Criativo).
  • Breve descrição de como atuar.
  • O que dizer ou fazer (pontos-chave):
    • Usar linguagem educada.
    • Demonstrar empatia (olhar nos olhos, ouvir sem interromper).
    • Sugerir soluções objetivas.

6️⃣ Encerramento e Discussão

Após todas as apresentações:

  • Perguntar:
    1. “Quais competências socioemocionais foram mais evidentes?”
    2. “O que ajudou a resolver os conflitos?”
    3. “Como isso se conecta a situações reais de trabalho?”
  • Professor dá feedback geral e reforça a importância de empatia, comunicação e colaboração para o sucesso profissional.
en_USEnglish