CECYTE — Nivel Medio Superior · 2026

Portafolio de
Programación Lógica

Aprendiendo a desarrollar

Módulo: Desarrolla programación lógica para solucionar problemas

Tema 1

Desarrolla Algoritmos para Solucionar Problemas

La base de toda aplicación de software comienza con un algoritmo. Aprendemos a estructurar el pensamiento lógico, declarar variables, y representar soluciones gráficamente antes de escribir una sola línea de código real.

Fundamentos

¿Qué es exactamente un algoritmo?

Un algoritmo es una secuencia de pasos lógicos, ordenados y finitos diseñados para resolver un problema específico. No pertenece a ningún lenguaje de programación: es pura lógica que puede expresarse en español, diagramas o código.

Para que sea considerado un algoritmo válido, debe cumplir tres propiedades:

  • Preciso: Cada paso debe ser inequívoco. La computadora no interpreta ni adivina, ejecuta exactamente lo que le indicas.
  • Finito: Debe tener un inicio y un fin claros. Un bucle sin condición de salida no es un algoritmo, es un error de programación.
  • Definido: Los mismos datos de entrada deben producir exactamente el mismo resultado cada vez que se ejecuta.
Ejemplo cotidiano: Una receta de cocina es un algoritmo. Tiene inicio (ingredientes), pasos ordenados (instrucciones) y fin (el platillo). Si cambias el orden, el resultado cambia o falla.
Pensamiento lógico y programación
El pensamiento lógico es la base de todo desarrollo de software.
Variables y Datos

Variables y Tipos de Datos

Una variable es un espacio reservado en la memoria RAM de la computadora al que le asignamos un nombre para guardar información temporalmente. Piensa en ella como una caja con etiqueta: la etiqueta es el nombre y el contenido es el valor.

Los tipos de datos determinan qué clase de información puede guardar cada variable y qué operaciones se pueden hacer con ella:

  • Entero (Integer): Números sin decimales. Ej: edad = 17, alumnos = 35
  • Real (Float): Números con punto decimal. Ej: promedio = 8.75, precio = 15.50
  • Cadena (String): Texto entre comillas. Ej: nombre = "María", materia = "Lógica"
  • Booleano (Boolean): Solo dos valores posibles: Verdadero o Falso. Base de todas las decisiones lógicas.
Error común: Guardar un número como Cadena impide hacer operaciones matemáticas. "17" + "3" = "173" (concatena), pero 17 + 3 = 20 (suma). ¡El tipo de dato importa!
Variables y tipos de datos
Las variables son los contenedores de información de todo programa.
Herramientas Visuales

Diagramas de Flujo

Es la representación gráfica de un algoritmo usando símbolos estandarizados por la norma ISO 5807. Nos permite ver la ruta completa de los datos antes de escribir código.

  • Óvalo / Terminador: Marca el INICIO y el FIN. Siempre hay exactamente uno de cada uno.
  • Rectángulo / Proceso: Un cálculo, asignación o instrucción de procesamiento.
  • Rombo / Decisión: Condición lógica (Sí/No). Es donde el flujo se bifurca en dos caminos.
  • Paralelogramo / E/S: Entrada de datos del usuario (LEER) o salida de resultados (ESCRIBIR).
  • Flechas / Flujo: Indican la dirección y el orden de los pasos.
INICIO Leer calif1, calif2, calif3 promedio = (c1+c2+c3) / 3 promedio >= 6.0? NO APROBADO ✓ REPROBADO ✗ FIN

Diagrama de flujo: Algoritmo completo para calcular promedio y determinar aprobación.

Algoritmos Secuenciales

Las instrucciones se ejecutan una tras otra en el mismo orden en que fueron escritas. No hay bifurcaciones ni repeticiones. Son la estructura base de todo programa.

Ej: Leer base y altura → calcular área = base × altura → mostrar resultado.

Algoritmos Condicionales

Contienen estructuras SI / SINO que evalúan una condición lógica y ejecutan diferentes instrucciones según el resultado sea verdadero o falso.

Ej: Si temperatura > 30°C → encender ventilador. Sino → apagarlo.

Algoritmos con Bucles

Repiten un bloque de instrucciones bajo una condición. El ciclo PARA se usa cuando sabes cuántas repeticiones habrá. El ciclo MIENTRAS se repite hasta que una condición sea falsa.

Ej: Repetir desde i=1 hasta 10: mostrar tabla del número × i.

Pseudocódigo: Calculadora de Promedio Escolar

El pseudocódigo es el puente entre el lenguaje humano y el código de computadora. Usa palabras en español con estructura lógica, sin reglas de sintaxis estricta. Cada símbolo del pseudocódigo corresponde a un símbolo del diagrama de flujo:

ALGORITMO EvaluarSemestre
INICIO
  // ──────────────────────────────────────────────────
  // 1. Declaración de variables (definimos nombre y tipo)
  // ──────────────────────────────────────────────────
  DECLARAR calif1, calif2, calif3, promedio COMO Real
  DECLARAR nombre_alumno COMO Cadena

  // 2. Entrada de datos → Paralelogramo en el diagrama
  ESCRIBIR "Ingrese el nombre del alumno: "
  LEER nombre_alumno
  ESCRIBIR "Ingrese las 3 calificaciones parciales (0-10): "
  LEER calif1, calif2, calif3

  // 3. Proceso / cálculo → Rectángulo en el diagrama
  promedio = (calif1 + calif2 + calif3) / 3

  // 4. Decisión condicional → Rombo en el diagrama
  SI (promedio >= 6.0) ENTONCES
      ESCRIBIR "Alumno: " + nombre_alumno + " → APROBADO. Promedio: " + promedio
  SINO
      ESCRIBIR "Alumno: " + nombre_alumno + " → REPROBADO. Promedio: " + promedio
  FIN SI
FIN
Estructuras Iterativas

Ciclos: Automatiza la Repetición

Los ciclos o bucles son la herramienta más poderosa para evitar código repetitivo. En vez de escribir la misma instrucción 10 veces, le decimos al algoritmo que la repita automáticamente.

  • PARA (FOR): Se usa cuando conoces exactamente cuántas veces se repite. Tiene un contador que avanza en cada iteración.
  • MIENTRAS (WHILE): Se repite mientras una condición sea verdadera. Si la condición inicia como falsa, el bloque nunca se ejecuta.
  • HACER-MIENTRAS (DO-WHILE): Igual que WHILE, pero garantiza que el bloque se ejecute al menos una vez antes de verificar la condición.
La indentación (sangría) en el pseudocódigo y en el código real señala qué instrucciones pertenecen al bloque del ciclo. Todo lo indentado se ejecuta repetidamente.
Pseudocódigo — Ciclo PARA
ALGORITMO TablaMultiplicar
INICIO
  DECLARAR numero, i, resultado COMO Entero
  ESCRIBIR "¿Tabla del número?"
  LEER numero

  PARA i DESDE 1 HASTA 10 HACER
    resultado = numero * i
    ESCRIBIR numero + " x " + i + " = " + resultado
  FIN PARA
FIN
Pseudocódigo — Ciclo MIENTRAS
ALGORITMO ContarPositivos
INICIO
  DECLARAR numero, contador COMO Entero
  contador = 0
  ESCRIBIR "Ingresa un número (0 para salir):"
  LEER numero

  MIENTRAS (numero != 0) HACER
    SI numero > 0 ENTONCES
      contador = contador + 1
    FIN SI
    LEER numero
  FIN MIENTRAS
  ESCRIBIR "Positivos ingresados: " + contador
FIN

Videos Educativos — Algoritmos y Diagramas de Flujo

¿Qué es un algoritmo? — TED-Ed

Explicación animada sobre algoritmos y su presencia en la vida cotidiana.

Variables, Pseudocódigo y Diagramas

Aprende a representar algoritmos con pseudocódigo y diagramas de flujo paso a paso.

Tema 2

Elabora Proyectos con Programación Lógica

Pasamos de la teoría a la práctica. Implementamos las estructuras de control en lenguajes reales como Python y llevamos la lógica al mundo físico con proyectos de electrónica en Arduino.

Estructura Secuencial

El código se ejecuta línea por línea de arriba hacia abajo, sin saltos. Cualquier error en una línea detiene el programa ahí mismo. Es el flujo natural y la base de todo script.

Python: x = 5y = x * 2print(y) → imprime 10.

Estructura Condicional

Le otorga toma de decisiones al programa. Con bloques if / elif / else el código evalúa una expresión booleana y bifurca su ejecución por uno de dos caminos posibles.

Ej: if nota >= 6: print("Aprobado")

Estructuras Iterativas

Los ciclos evitan repetir código innecesariamente. for itera un número conocido de veces; while se ejecuta mientras una condición sea verdadera. Son idénticos a los ciclos del pseudocódigo.

Aplicación Práctica

Codificando en Python

Python es el lenguaje ideal para aprender lógica: su sintaxis limpia obliga a indentar correctamente, y se parece mucho al pseudocódigo. La transición del algoritmo al código real es casi directa.

  • Sin llaves: Python usa la indentación (4 espacios) para delimitar bloques, no llaves { }.
  • Tipado dinámico: No necesitas declarar el tipo de variable. Python lo detecta automáticamente.
  • input() siempre devuelve texto: Debes convertirlo con int() o float() para operar matemáticamente.
Python — Condicionales (if / elif / else)
# Clasificador de edades con condicionales
edad = int(input("Ingresa tu edad: "))

if edad < 12:
    print("Eres un niño.")
elif edad < 18:
    print("Eres adolescente.")
elif edad < 65:
    print("Eres un adulto.")
else:
    print("Eres adulto mayor.")
Ciclos en Python

Bucles: for y while

Los bucles en Python implementan directamente los ciclos PARA y MIENTRAS del pseudocódigo. El objeto range(inicio, fin, paso) genera secuencias numéricas que el for recorre automáticamente.

range(1, 11) genera los números del 1 al 10 (el límite superior es exclusivo). range(0, 10, 2) genera 0, 2, 4, 6, 8 (saltos de 2).
Ciclo infinito: Si la condición del while nunca se vuelve falsa, el programa corre para siempre. Siempre asegúrate de modificar la variable de condición dentro del bucle.
Python — Ciclo FOR
# Tabla de multiplicar con FOR
numero = int(input("Tabla del número: "))

for i in range(1, 11):
    resultado = numero * i
    print(f"{numero} x {i} = {resultado}")
Python — Ciclo WHILE
# Suma de números positivos con WHILE
total = 0
numero = int(input("Número (0 para salir): "))

while numero != 0:
    if numero > 0:
        total += numero
    numero = int(input("Otro número: "))

print(f"Suma total: {total}")

Videos Educativos — Python desde Cero

Aprende Python desde Cero

Curso completo de Python con estructuras de control, variables y funciones básicas.

Ciclos FOR y WHILE en Python

Aprende las estructuras de repetición en Python con ejemplos prácticos y visuales.

🔌 Proyectos con Arduino

Llevamos la lógica de programación al mundo físico. Arduino es una plataforma de electrónica de código abierto con la que podemos controlar motores, luces, sensores y mucho más usando programación en C++ simplificado.

¿Qué es Arduino?

La Plataforma Arduino UNO

Arduino UNO es una placa de desarrollo basada en el microcontrolador ATmega328P. Tiene 14 pines digitales de entrada/salida, 6 entradas analógicas, un cristal de 16 MHz, conector USB y un regulador de voltaje de 5V.

La programación se realiza en el IDE de Arduino (gratuito) usando un lenguaje basado en C/C++ simplificado. Todo programa en Arduino tiene exactamente dos funciones obligatorias:

  • setup(): Se ejecuta una sola vez al iniciar. Aquí configuramos los pines (entrada o salida) e iniciamos comunicaciones.
  • loop(): Se ejecuta en bucle infinito mientras Arduino tenga energía. Aquí va la lógica principal del proyecto.
Arduino opera a 5V. Los LEDs necesitan una resistencia de 220Ω en serie para no quemarse. Sin resistencia, la corriente es demasiado alta y destruye el componente.
Arduino UNO R3
Arduino UNO R3 — La placa más usada para aprendizaje. Fuente: Wikimedia Commons CC BY-SA.
Modelo 3D Interactivo — Arduino UNO R3 · Puedes rotar, hacer zoom y explorar la placa

Proyecto 1 — Blink: El "Hola Mundo" de la Electrónica

El proyecto Blink consiste en hacer que un LED parpadee encendiéndose y apagándose con un intervalo de tiempo. Es el primer proyecto de todo programador de hardware y demuestra las dos funciones básicas de Arduino.

Lista de Componentes

# Componente Cantidad Descripción
1 Arduino UNO ×1 Placa principal de control y alimentación
2 LED rojo (o cualquier color) ×1 Diodo emisor de luz, 5mm
3 Resistencia 220Ω ×1 Limita la corriente para proteger el LED (rojo-rojo-café)
4 Protoboard ×1 Tablilla de pruebas sin soldadura
5 Cables Dupont ×2 Cables macho-macho para conexiones
6 Cable USB tipo B ×1 Para conectar Arduino a la computadora y cargar el código

Pasos de Conexión del Circuito

  1. Conecta el LED a la protoboard La pata larga del LED (ánodo +) va en una fila de la protoboard. La pata corta (cátodo −) en otra fila diferente.
  2. Conecta la resistencia en serie con el ánodo Coloca la resistencia de 220Ω entre la pata larga del LED (+) y el pin digital 13 de Arduino usando un cable Dupont.
  3. Conecta el cátodo a GND Del cátodo (pata corta) del LED, conecta un cable al pin GND (tierra/negativo) de Arduino.
  4. Conecta Arduino a la computadora Usa el cable USB. El LED del pin 13 integrado en la placa debería encenderse brevemente al conectar.
  5. Carga el código desde el IDE de Arduino Abre el IDE, selecciona la placa Arduino UNO y el puerto COM correcto, luego haz clic en el botón de carga (→).

Código Fuente — Arduino C++

Arduino C++ — Proyecto Blink (LED parpadeante)
/*
  PROYECTO: BLINK — LED Parpadeante
  Materia:  Lógica de Programación · CECYTE 2026
  Placa:    Arduino UNO
  Pin:      13 (tiene LED integrado en la placa)
  ─────────────────────────────────────────────
  Lógica aplicada:
  → Estructura SECUENCIAL: setup() se ejecuta una vez
  → Estructura ITERATIVA:  loop() se repite infinitamente
*/

// setup() → Equivale al INICIO del pseudocódigo
void setup() {
  // Declaramos el pin 13 como SALIDA (OUTPUT)
  // pinMode es como DECLARAR pin13 COMO Salida Digital
  pinMode(13, OUTPUT);
}

// loop() → Equivale a un ciclo MIENTRAS (Verdadero) HACER
void loop() {

  // ── Encender LED ──
  digitalWrite(13, HIGH);  // HIGH = 5V = LED encendido
  delay(1000);              // Esperar 1000 ms = 1 segundo

  // ── Apagar LED ──
  digitalWrite(13, LOW);   // LOW  = 0V = LED apagado
  delay(1000);              // Esperar 1000 ms = 1 segundo

  // → El loop() vuelve a empezar automáticamente
}
¡Personaliza el proyecto! Cambia los valores de delay(): usa delay(200) para un parpadeo muy rápido o delay(3000) para uno lento. También puedes cambiar 13 por cualquier pin digital del 2 al 13.
Proyecto 2

Control de LED con Botón

En este proyecto el LED solo se enciende mientras el botón está presionado. Aquí aplicamos una estructura condicional en hardware real: SI el botón está presionado, ENTONCES encender LED, SINO apagarlo.

Necesitas agregar a los componentes del Proyecto 1: un botón pulsador (push button) y una resistencia de 10kΩ (pull-down) conectada entre el pin del botón y GND para evitar lecturas erróneas de ruido eléctrico.

Este proyecto introduce digitalRead(), que devuelve HIGH (1) si hay voltaje en el pin, o LOW (0) si no. Es la lectura de una variable booleana del mundo físico.
Arduino C++ — LED con Botón (if/else)
/*
  PROYECTO: Control de LED con Botón
  Lógica aplicada: Estructura CONDICIONAL
  Botón → Pin 2 | LED → Pin 13
*/

const int PIN_BOTON = 2;
const int PIN_LED   = 13;
int estadoBoton = 0;

void setup() {
  pinMode(PIN_LED,   OUTPUT);
  pinMode(PIN_BOTON, INPUT);
  Serial.begin(9600); // Activa monitor serial
}

void loop() {
  // Leer el estado del botón (HIGH o LOW)
  estadoBoton = digitalRead(PIN_BOTON);

  // Condicional: SI presionado → encender
  if (estadoBoton == HIGH) {
    digitalWrite(PIN_LED, HIGH);
    Serial.println("Botón presionado → LED ON");
  } else {
    digitalWrite(PIN_LED, LOW);
    Serial.println("Sin presión  → LED OFF");
  }
  delay(50); // Pequeña pausa anti-rebote
}

Proyecto 3 — Semáforo con 3 LEDs

Usamos tres LEDs (rojo, amarillo y verde) para simular un semáforo. Este proyecto refuerza la estructura secuencial y el manejo de múltiples pines de salida.

Arduino C++ — Semáforo
/*
  PROYECTO: Semáforo con 3 LEDs
  Pines: Rojo=11 | Amarillo=12 | Verde=13
  Lógica: Estructura SECUENCIAL en loop()
*/

const int ROJO    = 11;
const int AMARILLO = 12;
const int VERDE   = 13;

void setup() {
  pinMode(ROJO,    OUTPUT);
  pinMode(AMARILLO, OUTPUT);
  pinMode(VERDE,   OUTPUT);
}

void loop() {
  // ── FASE ROJA: Alto (3 segundos) ──
  digitalWrite(ROJO, HIGH);
  delay(3000);
  digitalWrite(ROJO, LOW);

  // ── FASE AMARILLA: Precaución (1 segundo) ──
  digitalWrite(AMARILLO, HIGH);
  delay(1000);
  digitalWrite(AMARILLO, LOW);

  // ── FASE VERDE: Avanzar (3 segundos) ──
  digitalWrite(VERDE, HIGH);
  delay(3000);
  digitalWrite(VERDE, LOW);
}

Videos Educativos — Proyectos Arduino

Primer proyecto Arduino: LED Blink paso a paso

Tutorial completo en español para conectar y programar tu primer LED parpadeante.

Primera práctica en Arduino — BLINK | CODIZI

Explicación detallada del código setup() y loop() con animaciones didácticas.

Créditos

Alumnos Colaboradores

Estudiantes responsables de este portafolio de evidencias académicas · CECYTE 2026

Jesus Emanuel Solis Trapala

Jesus Emanuel Solis Trapala

1er Año Preparatoria CECYTE 2026

Estudiante enfocado en el desarrollo de pensamiento lógico, construcción de algoritmos eficientes y proyectos de electrónica con Arduino.

Keira Michael Santiago Guzmán

Keira Michael Santiago Guzmán

1er Año Preparatoria CECYTE 2026

Estudiante dedicada a la estructuración de proyectos, diagramado de flujo y diseño de la evidencia digital del portafolio.