https://jorgechac.blogspot.com

viernes, 17 de febrero de 2023

Dibujando en Python utilizando la libreria Matplotlib y Numpy

Bienvenido a mi blog, hoy hablaremos un poco de el conjunto de Mandelbrot, que es el más estudiado de los fractales. Se conoce así en honor al matemático Benoît Mandelbrot (1924-2010), que investigó sobre él en los años setenta. Este conjunto se define en el plano complejo fijando un número complejo C cualquiera, a partir de C, se construye una sucesión por recursión. Fractal (del latín fractus, "irregular", "fragmentado") es una palabra que acuñó el propio Mandelbrot para describir la repetición "infinita" de patrones geométricos a diferentes escalas, que muestran versiones cada vez más pequeñas de sí mismos. Las partes pequeñas de un fractal, explicaba Mandelbrot, son semejantes al todo, al conjunto completo. Lo más interesante es que el matemático demostró que la mayoría de las formas de la naturaleza son fractales. Los fractales se han utilizado para explicar fenómenos atmosféricos, para analizar las redes vasculares y las redes neuronales del cuerpo humano, para calcular la longitud de las costas, para explicar el crecimiento de los cerebros de los mamíferos, para estudiar los seísmos... Incluso en telecomunicaciones se han diseñado antenas fractales como las que utilizan los teléfonos celulares actuales.

En el contexto de los fractales, la iteración se refiere a la aplicación repetida de una regla o un procedimiento para generar la forma o estructura compleja del fractal. En la creación del fractal de Mandelbrot, una fórmula matemática se aplica repetidamente a cada punto en un plano complejo, produciendo un patrón auténtico. La cantidad de veces que se aplica la fórmula es conocida como el nivel de iteración. La Autosimilitud es una característica de los fractales que se refiere a su capacidad para mantener un patrón o forma similar a sí mismos a diferentes escalas. En otras palabras, una porción de un fractal se parece a la forma completa del fractal, sin importar la escala a la que se observe. Esta propiedad se conoce como "simetría fractal". Por ejemplo, un árbol fractal tendrá ramas que se parezcan a las ramas más grandes y a la forma general del árbol. La autosimilitud es una de las características que hacen que los fractales sean tan interesantes y únicos en el mundo de las matemáticas.

Para ello haremos uso de Matplotlib, la cuál es una librería completa para crear visualizaciones estáticas, animadas e interactivas en Python, de igual forma también usaremos la librería NumPy, que nos trae el poder computacional de lenguajes como C y Fortran a Python, un lenguaje mucho más fácil de aprender y usar.

Este será un post corto, vamos primero a tratar de explicar el script linea por linea, después veremos el código final limpio y acabaremos generando la grafica respectiva.

import numpy # importamos la librería NumPy

# NumPy es una biblioteca en Python que proporciona un objeto de matriz N-dimensional

# y funciones matemáticas de alto rendimiento para operar en esas matrices.

import matplotlib.pyplot # importamos la librería Matplotlib que se utiliza para la creación de gráficos y visualizaciones

# comenzamos la definición de una función que calcula el Conjunto de Mandelbrot

def mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon=2.0):

X = numpy.linspace(xmin, xmax, xn, dtype=numpy.float32) # Aquí se está generando un arreglo de números que representan los valores en el eje x. La función linspace de NumPy genera un número especificado de puntos equidistantes entre dos valores dados

Y = numpy.linspace(ymin, ymax, yn, dtype=numpy.float32) # Aquí se está generando un arreglo de números que representan los valores en el eje y

C = X + Y[:, None]*1j # generamos una matriz de números complejos que representan todos los puntos en el plano complejo. La notación 1j es una forma de representar la unidad imaginaria en Python

N = numpy.zeros_like(C, dtype=int) # Se crea un array N con la misma forma que C y se inicializa en cero

Z = numpy.zeros_like(C) # Se crea un array Z con la misma forma que C e inicializa en cero

for n in range(maxiter): # se itera sobre un rango de maxiter elementos

I = numpy.less(abs(Z), horizon) # se crea una matriz booleana I que es verdadera en las posiciones donde la magnitud de Z es menor que horizon

N[I] = n # asignamos el valor actual de la variable "n" a las posiciones en el array "N" donde la condición "I" es verdadera

Z[I] = Z[I]**2 + C[I] # es la fórmula iterativa para calcular el conjunto de Mandelbrot. Esta línea está asignando el resultado de esta fórmula a aquellos elementos en el array "Z" donde la condición "I" es verdadera

N[N == maxiter-1] = 0 # asignamos el valor 0 a aquellos elementos en el array "N" que tienen un valor igual a "maxiter-1"

return Z, N # la función "mandelbrot_set" devuelve los arrays "Z" y "N" como resultados

# Si se está ejecutando este archivo, define los parámetros y ejecuta la función mandelbrot_set

if __name__ == '__main__':

# Se definen los límites para que el gráfico incluya la región rectangular con esquinas opuestas (-2, -1.5) y (1, 1.5)

xmin, xmax, ymin, ymax = numpy.array([-2, 1, -1.5, 1.5], dtype=numpy.float32)

# Se definen las dimensiones de la matriz que se va a utilizar para almacenar los valores de iteración para cada punto del conjunto de Mandelbrot

# Se usarán matrices de 3000x2500 para almacenar los valores de iteración

xn, yn = numpy.array([3000, 2500], dtype=int)

# La variable "maxiter" define el número máximo de iteraciones que se realizarán en el cálculo del conjunto de Mandelbrot.

# En este caso, se han establecido en 200

maxiter = 200

# La variable "horizon" se usa para definir el umbral que determina si un punto está dentro del conjunto de Mandelbrot. En este caso, se ha definido

# como 2 elevado a la 40, lo que significa que se realizarán un máximo de 2 elevado a la 40 iteraciones para determinar si un punto está dentro del conjunto

horizon = 2.0 ** 40

log_horizon = numpy.log2(numpy.log(horizon))/2

# Llamamos a la función "mandelbrot_set" definida previamente para calcular los valores de iteración y la matriz compleja para el conjunto de Mandelbrot

Z, N = mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon)

# Se ignora la advertencia de que algunos valores resultantes de las operaciones sean inválidos

with numpy.errstate(invalid='ignore'):

# Calculamos los valores de M utilizando los valores de N y Z

M = numpy.nan_to_num(N + 1 - numpy.log(numpy.log(abs(Z)))/numpy.log(2) + log_horizon)

# Graficamos los valores de M con los parámetros especificados

matplotlib.pyplot.imshow(M, extent=[xmin, xmax, ymin, ymax], cmap='hot', aspect='equal') # se muestra el conjunto de Mandelbrot como una imagen en una ventana emergente

matplotlib.pyplot.xlabel("Re(c)") # Se agrega un label o etiqueta para las coordenadas x e y y se establece un título

matplotlib.pyplot.ylabel("Im(c)")

matplotlib.pyplot.title("Mandelbrot Set by JorgeChac")

matplotlib.pyplot.show() # Abrimos una ventana de visualización y mostramos el gráfico generado por el código.

Acá tenemos el código final limpio en Python:

# -----------------------------------------------------------------------
# (| " mandelbrot.py                                                  "|)
# (| "                                                                "|)
# (| " Script que genera el conjunto de Mandelbrot y lo visualiza     "|)
# (| " como una imagen utilizando las librerías NumPy y Matplotlib    "|)
# (| " de Python.                                                     "|)
# (| "                                                                "|)
# (| " El conjunto de Mandelbrot es un conjunto de puntos en el plano "|)
# (| " complejo que se define mediante una regla matemática iterativa."|)
# (| " El programa calcula los valores de los puntos en una cuadrícula"|)
# (| " de coordenadas en el plano complejo utilizando la función      "|)
# (| " mandelbrot_set() que implementa la regla iterativa. Luego, el  "|)
# (| " programa utiliza la librería Matplotlib para representar los   "|)
# (| " resultados como una imagen en una ventana de visualización.    "|)
# (| "                                                                "|)
# (| " Este código de ejemplo es de dominio público.                  "|)
# (| "                                                                "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB   "|)
# (| " Visita  https://jorgechac.blogspot.com                         "|)
# (| "                                                                "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   	      "|)
# (| " Whatsapp y Ventas NEQUI +573177295861                          "|)
# (| " Bucaramanga - Colombia                                         "|)
# -----------------------------------------------------------------------
import numpy
import matplotlib.pyplot

def mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon=2.0):
    
    X = numpy.linspace(xmin, xmax, xn, dtype=numpy.float32)
    Y = numpy.linspace(ymin, ymax, yn, dtype=numpy.float32)

    C = X + Y[:, None]*1j

    N = numpy.zeros_like(C, dtype=int)
    Z = numpy.zeros_like(C)

    for n in range(maxiter):

        I = numpy.less(abs(Z), horizon)
        N[I] = n

        Z[I] = Z[I]**2 + C[I]

    N[N == maxiter-1] = 0
    return Z, N

if __name__ == '__main__':

    xmin, xmax, ymin, ymax = numpy.array([-2, 1, -1.5, 1.5], dtype=numpy.float32)

    xn, yn = numpy.array([3000, 2500], dtype=int)

    maxiter = 200

    horizon = 2.0 ** 40

    log_horizon = numpy.log2(numpy.log(horizon))/2

    Z, N = mandelbrot_set(xmin, xmax, ymin, ymax, xn, yn, maxiter, horizon)

    with numpy.errstate(invalid='ignore'):
        
        M = numpy.nan_to_num(N + 1 - numpy.log(numpy.log(abs(Z)))/numpy.log(2) + log_horizon)

    matplotlib.pyplot.imshow(M, extent=[xmin, xmax, ymin, ymax], cmap='hot', aspect='equal')
    matplotlib.pyplot.xlabel("Re(c)")
    matplotlib.pyplot.ylabel("Im(c)")
    matplotlib.pyplot.title("Mandelbrot Set by JorgeChac")
    matplotlib.pyplot.show()

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar la grafica en Python con matplotlib, así:

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

Si te sirvió deja un comentario de agradecimiento, comparte el post en tus redes sociales o recomiéndale el blog a un amigo, eso me motiva a seguir realizando estos pequeños posts y espero que vuelvas a mi blog, publico nuevo material con base en los softwares y apps que utilizo y la experiencia que he adquirido. Por último si deseas colaborar voluntariamente y crees que mi trabajo y mi tiempo lo ameritan, considere hacer una pequeña donación a mi NEQUI +573177295861.

También te puede interesar:

Dibujando en Python utilizando el módulo Python Turtle

Dibujo del logotipo de Python utilizando el módulo Python Turtle

Simulador Wokwi - Generalidades

UEFI y BIOS - Generalidades

DISCOS SSD - GENERALIDADES

Creación de Particiones desde símbolo del sistema

Nuevos Microcontroladores Raspberry Pi Pico W, H y WH

Cómo Detectar un Arduino Falsificado

HDD Low Level Format Tool v4.40

Activa tu Windows 10/11 fácil

martes, 7 de febrero de 2023

Dibujando en Python utilizando el módulo Python Turtle

Bienvenido a mi blog, hoy continuaremos practicando el uso del módulo python turtle que vimos en el post pasado "Dibujo del logotipo de Python utilizando el módulo Python Turtle" en el cual esbozamos los principios de dicho módulo y los aplicamos para dibujar el logotipo de Python.

Este será un post corto, ya que iremos directamente a programar en Python 3 un dibujo en constante cambio de colores que se mueva hacia adelante y hacia arriba en una espiral, con una curva suave. Vamos a escribir el script completo colocando los respectivos comentarios para poder entenderlo y finalmente visualizaremos el resultado:

# -----------------------------------------------------------------------
# (| " Graphics_turtle.py                                             "|)
# (| "                                                                "|)
# (| " El resultado final es un dibujo en constante cambio de colores "|)
# (| " que se mueve hacia adelante y hacia arriba en una espiral, con "|)
# (| " una curva suave.                                               "|)
# (| "                                                                "|)
# (| " Python turtle es un módulo de Python que permite crear gráficos"|)
# (| " vectoriales mediante el uso de comandos simples. Estos comandos"|)
# (| " controlan un cursor, conocido como tortuga (turtle), que se    "|)
# (| " mueve por la pantalla y dibuja líneas y figuras geométricas y  "|)
# (| " nos permite crear diseños personalizados.                      "|)
# (| "                                                                "|)
# (| " Este código de ejemplo es de dominio público.                  "|)
# (| "                                                                "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB   "|)
# (| " Visita  https://jorgechac.blogspot.com                         "|)
# (| "                                                                "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   	      "|)
# (| " Whatsapp y Ventas NEQUI +573177295861                          "|)
# (| " Bucaramanga - Colombia                                         "|)
# -----------------------------------------------------------------------

# Importa todas las funciones y métodos del módulo "turtle"
from turtle import *

# Importa el módulo "colorsys"
import colorsys

# Establece el color de fondo de la ventana de gráficos en negro
bgcolor('black')

# Establece la velocidad máxima de animación
speed(0)

# Establece el grosor de la pluma en 3
pensize(3)

# Establece un valor inicial para la variable "hue" en 0.0 la variable
# "hue" se utiliza para determinar el color de la pluma en cada iteración
# del bucle
hue = 0.0

# Repite las siguientes acciones 300 veces
for i in range(300):

    # Convierte el valor de hue a un color RGB y lo establece como el
    # color de la pluma
    color = colorsys.hsv_to_rgb(hue, 1, 1)
    pencolor(color)
    # Aumenta el valor de hue en 0.005
    hue += 0.005
    # Gira el lápiz hacia la derecha en la cantidad de "i"
    right(i)
    # Dibuja un círculo con un radio de 50 y un ángulo de "i"
    circle(50, i)
    # Avanza hacia adelante la cantidad de "i"
    forward(i)
    # Gira el lápiz hacia la izquierda en 91° grados
    left(91)

# Finaliza la gráfica y mantiene la ventana abierta hasta que el usuario
# la cierre manualmente
done()

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar la grafica en Python, así:

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

jueves, 2 de febrero de 2023

Dibujo del logotipo de Python utilizando el módulo Python Turtle

Bienvenido a mi blog, hoy hablaremos un poco de Python turtle, el cual es un módulo de Python que permite crear gráficos vectoriales mediante el uso de comandos simples. Estos comandos controlan un cursor, conocido como tortuga (turtle), que se mueve por la pantalla y dibuja líneas y figuras geométricas y nos permite crear diseños personalizados. Es comúnmente utilizado en la enseñanza de la programación, ya que es fácil de entender y usar. Con Python turtle, los estudiantes pueden aprender conceptos básicos de programación como bucles, condicionales y funciones mientras crean sus propios gráficos. Algunos ejemplos de cómo utilizar la función turtle incluyen:

Mover el cursor hacia adelante utilizando el comando "forward()"
Girar el cursor utilizando el comando "left()" o "right()"
Cambiar el color de la línea utilizando el comando "pencolor()"
Escribir texto en la pantalla utilizando el comando "write()"
Mostrar o ocultar el cursor utilizando el comando "showturtle()" o "hideturtle()"

Para utilizar la función turtle, primero debemos importar el módulo en nuestro script. Luego, podemos crear una instancia de turtle y utilizar los comandos mencionados anteriormente para dibujar en la pantalla. Hoy aprenderemos a dibujar el logotipo de Python con el modulo Python Turtle.

Paso 1: Importación de bibliotecas

# Importación de la biblioteca turtle para dibujar el logotipo de Python

import turtle

Paso 2: crear un cursor y un lienzo separado para dibujar el logotipo de Python

# Creando nuestro cursor tortuga para dibujar

my_turtle_cursor = turtle.Turtle()

# Creación de un lienzo separado para dibujar el logotipo de Python

my_turtle_screen = turtle.Screen()

Paso 3: Creación de una función para pausar el cursor al final

# Creación de una función de pausa, para pausar el cursor

def pause():

my_turtle_cursor.speed(2)

for i in range(100):

my_turtle_cursor.left(90)

Paso 4A: crear una función para dibujar el punto superior del logotipo de Python

# Función para dibujar el punto superior del logotipo de Python

def draw_upper_dot_of_python_logo():

my_turtle_cursor.penup()

my_turtle_cursor.right(90)

my_turtle_cursor.forward(160)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(70)

my_turtle_cursor.pencolor("white")

my_turtle_cursor.dot(35)

Paso 4B: Creando una función para ir a la Segunda Posición en nuestro Lienzo

# Función para hacer la segunda posición

def goto_second_position():

my_turtle_cursor.penup()

my_turtle_cursor.forward(20)

my_turtle_cursor.right(90)

my_turtle_cursor.forward(10)

my_turtle_cursor.right(90)

my_turtle_cursor.pendown()

Paso 5: Crear una función media

def half():

my_turtle_cursor.forward(50)

draw_side_curve_of_python_logo()

my_turtle_cursor.forward(90)

draw_first_left_curve_of_python_logo()

my_turtle_cursor.forward(40)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(80)

my_turtle_cursor.right(90)

my_turtle_cursor.forward(10)

my_turtle_cursor.right(90)

my_turtle_cursor.forward(120) # on test

draw_second_left_curve_of_python_logo()

my_turtle_cursor.forward(30)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(50)

draw_right_curve_of_python_logo()

my_turtle_cursor.forward(40)

my_turtle_cursor.end_fill()

Paso 6: crear una función para dibujar el segundo punto del logotipo de Python

# Función para dibujar el segundo punto

def draw_lower_dot_of_python_logo():

my_turtle_cursor.left(90)

my_turtle_cursor.penup()

my_turtle_cursor.forward(310)

my_turtle_cursor.left(90)

my_turtle_cursor.forward(120)

my_turtle_cursor.pendown()

my_turtle_cursor.dot(35)

Paso 7: Creación de una función para dibujar la primera curva izquierda del logotipo de Python

# Función para dibujar la primera curva izquierda

def draw_first_left_curve_of_python_logo():

draw_side_curve_of_python_logo()

my_turtle_cursor.forward(80)

draw_side_curve_of_python_logo()

Paso 8: Creación de una función para dibujar la segunda curva izquierda del logotipo de Python

# Función para dibujar la segunda curva izquierda

def draw_second_left_curve_of_python_logo():

draw_side_curve_of_python_logo()

my_turtle_cursor.forward(90)

draw_side_curve_of_python_logo()

Paso 9: Crear una función para dibujar una curva lateral

# Función para Dibujar Curva Lateral

def draw_side_curve_of_python_logo():

for i in range(90):

my_turtle_cursor.left(1)

my_turtle_cursor.forward(1)

Paso 10: Creación de una función para dibujar la curva derecha

# Función para dibujar la curva derecha

def draw_right_curve_of_python_logo():

for i in range(90):

my_turtle_cursor.right(1)

my_turtle_cursor.forward(1)

Paso 11: Configuración del tamaño del lápiz y la velocidad de nuestro cursor

# Configuración del cursor según nuestras necesidades

my_turtle_cursor.pensize(2)

my_turtle_cursor.speed(10)

my_turtle_cursor.pensize(2)

my_turtle_cursor.pencolor("black")

Paso 12: Establecer los colores de relleno para diferentes partes y llamar a todas las funciones

# cambiamos el color de fondo del lienzo

my_turtle_screen.bgcolor("white")

# Configuración del color de relleno de la parte superior del logotipo de python

my_turtle_cursor.fillcolor("#306998")

# Comenzando a llenar el color de la parte superior del logo de python

my_turtle_cursor.begin_fill()

half()

# Inclinando el cursor para llenar el color en la parte superior del logo de python

my_turtle_cursor.end_fill()

goto_second_position()

# Configuración del color de relleno de la parte inferior del logotipo de python

my_turtle_cursor.fillcolor("#FFD43B")

my_turtle_cursor.begin_fill()

half()

# Inclinando el cursor para llenar el color en la parte inferior del logotipo de python

my_turtle_cursor.end_fill()

# Dibujo de puntos (ojos) superior e inferior del logotipo de python

draw_upper_dot_of_python_logo()

draw_lower_dot_of_python_logo()

pause()

Para sintetizar acá tenemos el código completo para dibujar el logotipo de Python usando el modulo Phyton Turtle, nuestro código está completo y finalmente lo ejecutamos para ver el logotipo de Python.

# -------------------------------------------------------------------------
# (| " logo_python.py                                                   "|)
# (| "                                                                  "|)
# (| " Dibujo del logotipo de Python utilizando el módulo Python Turtle."|)
# (| "                                                                  "|)
# (| " Python turtle es un módulo de Python que permite crear gráficos  "|)
# (| " vectoriales mediante el uso de comandos simples. Estos comandos  "|)
# (| " controlan un cursor, conocido como tortuga (turtle), que se mueve"|)
# (| " por la pantalla y dibuja líneas y figuras geométricas y nos      "|)
# (| " permite crear diseños personalizados.                            "|)
# (| "                                                                  "|)
# (| " Este código de ejemplo es de dominio público.                    "|)
# (| "                                                                  "|)
# (| " Developer: jorgechac© - Técnico Laboral en Programación UNAB     "|)
# (| " Visita  https://jorgechac.blogspot.com                           "|)
# (| "                                                                  "|)
# (| " Venta de accesorios Arduino/Raspberry Pi Pico/ESP32   		"|)
# (| " Whatsapp y Ventas NEQUI +573177295861                            "|)
# (| " Bucaramanga - Colombia                                           "|)
# -------------------------------------------------------------------------

# Importación de la biblioteca turtle para dibujar el logotipo de Python
import turtle

# Creando nuestro cursor tortuga para dibujar
my_turtle_cursor = turtle.Turtle()

# Creación de un lienzo separado para dibujar el logotipo de Python
my_turtle_screen = turtle.Screen()

# Creación de una función de pausa, para pausar el cursor
def pause():
    my_turtle_cursor.speed(2)
    for i in range(100):
        my_turtle_cursor.left(90)

# Función para dibujar el punto superior del logotipo de Python
def draw_upper_dot_of_python_logo():
    my_turtle_cursor.penup()
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(160)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(70)
    my_turtle_cursor.pencolor("white")
    my_turtle_cursor.dot(35)

# Función para hacer la segunda posición
def goto_second_position():
    my_turtle_cursor.penup()
    my_turtle_cursor.forward(20)
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(10)
    my_turtle_cursor.right(90)
    my_turtle_cursor.pendown()

# Crear una función media
def half():
    my_turtle_cursor.forward(50)
    draw_side_curve_of_python_logo()
    my_turtle_cursor.forward(90)
    draw_first_left_curve_of_python_logo()
    my_turtle_cursor.forward(40)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(80)
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(10)
    my_turtle_cursor.right(90)
    my_turtle_cursor.forward(120)  # on test
    draw_second_left_curve_of_python_logo()
    my_turtle_cursor.forward(30)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(50)
    draw_right_curve_of_python_logo()
    my_turtle_cursor.forward(40)
    my_turtle_cursor.end_fill()

# Función para dibujar el segundo punto
def draw_lower_dot_of_python_logo():
    my_turtle_cursor.left(90)
    my_turtle_cursor.penup()
    my_turtle_cursor.forward(310)
    my_turtle_cursor.left(90)
    my_turtle_cursor.forward(120)
    my_turtle_cursor.pendown()
    my_turtle_cursor.dot(35)

# Función para dibujar la primera curva izquierda
def draw_first_left_curve_of_python_logo():
    draw_side_curve_of_python_logo()
    my_turtle_cursor.forward(80)
    draw_side_curve_of_python_logo()

# Función para dibujar la segunda curva izquierda
def draw_second_left_curve_of_python_logo():
    draw_side_curve_of_python_logo()
    my_turtle_cursor.forward(90)
    draw_side_curve_of_python_logo()

# Función para Dibujar Curva Lateral
def draw_side_curve_of_python_logo():
    for i in range(90):
        my_turtle_cursor.left(1)
        my_turtle_cursor.forward(1)

# Función para dibujar la curva derecha
def draw_right_curve_of_python_logo():
    for i in range(90):
        my_turtle_cursor.right(1)
        my_turtle_cursor.forward(1)

# Configuración del cursor según nuestras necesidades
my_turtle_cursor.pensize(2)
my_turtle_cursor.speed(10)
my_turtle_cursor.pensize(2)
my_turtle_cursor.pencolor("black")

# cambiamos el color de fondo del lienzo
my_turtle_screen.bgcolor("white")

# Configuración del color de relleno de la parte superior del logotipo
# de python
my_turtle_cursor.fillcolor("#306998")

# Comenzando a llenar el color de la parte superior del logo de python
my_turtle_cursor.begin_fill()
half()

# Inclinando el cursor para llenar el color en la parte superior del logo
# de python
my_turtle_cursor.end_fill()
goto_second_position()

# Configuración del color de relleno de la parte inferior del logotipo
# de python
my_turtle_cursor.fillcolor("#FFD43B")
my_turtle_cursor.begin_fill()
half()

# Inclinando el cursor para llenar el color en la parte inferior del
# logotipo de python
my_turtle_cursor.end_fill()

# Dibujo de puntos (ojos) superior e inferior del logotipo de python
draw_upper_dot_of_python_logo()
draw_lower_dot_of_python_logo()
pause()

Finalmente después de ejecutar el código, se abrirá una nueva ventana y se comenzará a generar el logotipo de Python, así:

Bibliografía: AVIRAL KAUSHIK de copyassignment.com

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

También te puede interesar:

Simulador Wokwi - Generalidades

UEFI y BIOS - Generalidades

DISCOS SSD - GENERALIDADES

Creación de Particiones desde símbolo del sistema

Raspberry Pi Pico Pin Mapping

HDD Low Level Format Tool v4.40

Activa tu Windows 10/11 fácil

martes, 20 de septiembre de 2022

SparkFun Pro Micro

Bienvenido a mi blog, hoy hablaremos un poco de la placa Pro Micro, a diferencia de otras placas que hemos descrito en estos post's, Pro Micro NO es una placa Arduino como tal, ya que fue diseñada y construida por SparkFun Electronics, la cuál es una empresa dedicada a la comercialización de productos electrónicos en Niwot, Colorado, Estados Unidos. SparkFun Electronics fabrica y vende placas de desarrollo de microcontroladores y diversos dispositivos, a destacar que todos los productos diseñados y producidos por SparkFun, se lanzan como hardware de código abierto.

La SparkFun Pro Micro la encontramos en versiones de 3,3V a 8 MHz y 5V a 16 MHz y es una placa de desarrollo pequeña y genial. Posee un microcontrolador compatible con Arduino, la Pro Micro es una placa basada en la MCU Atmel, el ATmega32U4 y logra con un solo chip lo que los viejos Arduino UNO Rev3, MEGA2560, NANO y Pro Mini nunca pudieron poseer: la verdadera funcionalidad USB. La razón más grande por la que algunos técnicos la llaman erróneamente "Arduino Pro Micro", es porque en su corazón los chips Atmel son ampliamente conocidos y utilizados en la plataforma Arduino, por ejemplo, en el Arduino Leonardo ya habíamos visto dicho chip.

Como todas las placas compatibles, tiene semejanzas con otras de sus hermanastras mayores: es muy similar a Arduino Micro pero en un factor de forma más pequeño. En este post, podrás comprender todo lo que necesitas saber sobre esta placa y comenzar a desarrollar tus propios proyectos DIY con SparkFun Pro Micro, la cuál en su mayoría es usada para HID Human Interface Device, es decir, emular teclados, mouse's o joystick.

Sparkfun Pro Micro tiene 18 pines de entrada/salida digital (de los cuales 5 se pueden usar como salidas PWM), 9 entradas analógicas, un resonador incorporado y orificios para montar cabezales de pines.

Características Físicas:

Las dimensiones de la Sparkfun Pro Micro PCB son: 700 milésimas de pulgada x 1300 milésimas de pulgada, que expresadas en milímetros serian: 17.78mm x 33.02mm

Especificaciones técnicas:

Power

La Sparkfun Pro Micro se puede alimentar con un suministro regulado de 3,3V o 5V (según el modelo) en el pin Vcc. Hay un regulador de voltaje LDO a bordo MIC5219 para que pueda aceptar voltajes de hasta 12VCC. Si está suministrando energía no regulada a la placa, asegúrese de conectarse al pin "RAW" no en VCC.

Los pines de alimentación son los siguientes:

RAW: Se utiliza para suministrar voltaje no regulado a la placa. Si la placa se alimenta a través de USB, el voltaje en este pin será de aproximadamente 4,8 V (los 5 V de USB menos una caída del diodo Schottky).
VCC: El suministro regulado de 3,3 o 5 voltios según el modelo.
GND: Clavijas de tierra.

Memoria

El ATmega32U4 tiene 32 kB de memoria flash para almacenar código (de los cuales 0,5 kB se utilizan para el gestor de arranque o bootloader). Tiene 2.5 kB de SRAM y 1 kBs de EEPROM (que se pueden leer y escribir utilizando la biblioteca EEPROM).

Entradas y salidas

Cada uno de los 18 pines digitales de la Sparkfun Pro Micro se puede usar como entrada o salida, utilizando las funciones pinMode, digitalWrite y digitalRead. Funcionan a 3,3 o 5 voltios (según el modelo). Cada pin puede proporcionar o recibir un máximo de 40 mA y tiene una resistencia pull-up interna (desconectada por defecto) de 20-50 kΩ. Además, algunos pines tienen funciones especializadas:

Serial: Pin 0 (RX) y Pin 1 (TX). En estos pines tenemos el puerto serial full dúplex UART, que se utiliza para recibir y transmitir datos en serie TTL. El software Arduino incluye un monitor en serie que permite enviar datos de texto simples hacia y desde la placa a través de una conexión USB. La biblioteca <SoftwareSerial> permite la comunicación en serie de los pines digitales de la Sparkfun Pro Micro.

Interrupciones Externas: Pines 0, 1, 2, 3 y 7, estos pines se pueden configurar para activar una interrupción en un valor bajo, un flanco ascendente o descendente, o un cambio de valor. Consulte la función <attachInterrupt> para obtener más información.

PWM: Pines 3, 5, 6, 9, y 10 Proporcionan una salida PWM de 8 bits con la función analogWrite. Los pines PWM simulan la salida de hardware analógico mientras que otros pines simulan la salida analógica de software. Estos 5 pines PWM encuentran aplicaciones en las que necesitamos regular algo, por ejemplo la velocidad de un motor DC, el control de giro de un servomotor, el brillo de un led, etc.

SPI: 16 (MOSI Master-Out Slave-In), 14 (MISO Master-In Slave-Out), 15 (SCK Serial Clock). Estos pines admiten la comunicación SPI (interfaz periférica en serie) desarrollada por Motorola. Recordemos que a diferencia de I2C, en SPI solo puede existir un dispositivo maestro y no existe límite para el número de esclavos.

La Sparkfun Pro Micro tiene 9 entradas analógicas, cada una de las cuales proporciona 10 bits de resolución (es decir, 1024 valores diferentes). Las entradas analógicas miden de tierra a VCC y toman la señal de los sensores analógicos y la convierten en un valor digital. Los pines miden el voltaje, no la corriente, porque tienen un valor muy alto de resistencia interna. Entonces, el valor de la corriente es mucho menor en comparación con el voltaje, además los 9 pines indicados como entradas analógicas (A0, A1, A2, A3, A6, A7, A8, A9 y A10) también pueden ser configurados como entradas o salidas digitales.

I2C: Pin 2 (SDA) y Pin 3 (SCL). Admite comunicación I2C (TWI) utilizando la biblioteca <Wire> para simplificar el uso del bus I2C.

Reset: Una resistencia de 10 kΩ en la placa eleva este pin manteniéndolo en alto y está activo en nivel bajo, por lo que debe conectarse a tierra para iniciar un reinicio. La Sparkfun Pro Micro permanecerá apagada hasta que la línea de reinicio vuelva a estar alta.

Al realizar reset, se envía el pulso lógico al pin de reset del microcontrolador ATmega32U4. Es una línea muy importante, ya que algunas veces los ordenadores se bloquean al no saber si deben tratar la pro micro como un mouse o un teclado o un joystick o un microcontrolador que deben comandar?, así que es muy normal y será necesario en algún momento hacer un reset o reinicio.

Programación:

1. Tu Sparkfun Pro Micro se puede programar con la descarga del software Arduino IDE, realizándole algunos sencillos y cortos ajustes.

2. Otra forma de programar tu Sparkfun Pro Micro es compilar el código por separado usando el compilador AVR-GCC para generar el archivo ejecutable y luego usar Avr-ObjCopy para convertirlo en un archivo .HEX finalmente, Avrdude se usa para cargar el archivo hexadecimal en el tablero.

AVRDUDE es un acrónimo de AVR Downloader/UploaDEr. Es un software de código abierto que se utiliza para programar microcontroladores AVR de atmel (ahora microchip). También puede usarlo para programar EEPROM's, memorias Flash e incluso fusibles y bits de bloqueo. ademas al instalar AVRDUDESS éste no toca la variable %PATH%, por lo que no causará ningún problema con el IDE de Arduino.

Cómo conectar Sparkfun Pro Micro a la computadora?

El procedimiento lo resumo en solo 3 pasos:

1. Descargar e instalar el driver para Windows.

2. Configuramos la dirección en el gestor URL adicional de tarjetas.

https://raw.githubusercontent.com/sparkfun/Arduino_Boards/master/IDE_Board_Manager/package_sparkfun_index.json

3. Seleccionamos Sparkfun AVR Boards - Sparkfun Pro Micro.

Ahora vamos a desglosar los pasos uno a uno más detallados, antes de enchufar su placa, comience descargando los controladores. Los drivers para la Sparkfun Pro Micro están firmados para usuarios de Windows y pueden descargarlos directamente usando el siguiente enlace:

DRIVERS PRO MICRO

Descomprime ese archivo .zip y no olvides dónde dejaste su contenido. En ese archivo zip, debe encontrar los archivos .inf y .cat , que contienen toda la información que Windows necesita para instalar el controlador de Pro Micro. El controlador sparkfun.inf y el archivo de catálogo firmado digitalmente sparkfun.cat se encontrarán en ..."Arduino_Boards-master/sparkfun/avr/signed_driver".

Ahora conectaremos la placa Sparkfun Pro Micro a la PC con un cable microusb y obtendremos un resultado como el siguiente (recomendable trabajar con un puerto USB 2.0):

Abriremos ahora el administrador de dispositivos de Windows y actualizaremos el driver manualmente, indicándole la ruta donde esta el driver firmado que bajamos en los pasos anteriores: "Arduino_Boards-master/sparkfun/avr/signed_driver"

Antes de poder usar la Sparkfun Pro Micro en el IDE de Arduino, deberemos instalar los archivos de la placa (.brd) para que Arduino sepa cómo comunicarse con esta board. Abrimos el IDE de Arduino, luego vamos a Preferencias (Archivo>Preferencias). Luego, hacia la parte inferior de la ventana, pegue esta URL en el cuadro de texto "Gestor de URLs adicionales de Tarjetas" y damos click en OK:

A continuación, hacemos click en Herramientas - Placa, y vamos a gestor de tarjetas:

En el gestor de tarjetas buscamos el paquete sparkfun y ubicándonos sobre Sparkfun AVR Boards damos click en Instalar:

Una vez instalado el paquete podremos ver todas las placas soportadas:

Tenga en cuenta, como ya hemos expuesto anteriormente, que hay dos opciones para la Sparkfun Pro Micro: 3V3 8 MHz y 5V 16 MHz. Es muy importante que seleccione la opción Pro Micro que coincida con el voltaje y la velocidad de su placa. Esto aparece en Herramientas > Procesador.

Cabe destacar que hay una nueva versión de la Sparkfun Pro Micro, llamada "Qwiic Pro Micro" donde básicamente se actualizo a conector USB tipo C, se le añadió el botón de reset incluido en la board y las almohadillas para agujeros pasantes Through-Hole, tienen bordes almenados un diseño similar a la Raspberry Pi Pico para soldarla directamente en el proyecto como un componente SMD.

SparkFun Qwiic Pro Micro

Algunos Clones de la Sparkfun Pro Micro

Tanto el Arduino Leonardo como la Sparkfun Pro Micro, son placas de desarrollo basadas en el microcontrolador ATmega32U4 de Atmel. La principal diferencia entre los bootloaders de estas dos placas es que el bootloader del Leonardo utiliza el protocolo de arranque en serie (Serial Bootloader) de Atmel, mientras que el bootloader de la Sparkfun Pro Micro utiliza el protocolo de arranque en HID (Human Interface Device). En pocas palabras, aunque ambos bootloaders permiten programar el microcontrolador a través del puerto USB, el protocolo utilizado para hacerlo es diferente.

El bootloader del Leonardo utiliza el protocolo de arranque en serie, mientras que el bootloader del Sparkfun Pro Micro utiliza el protocolo de arranque en HID.

Descarga aqui el bootloader de Arduino Leonardo

Descarga aqui el bootloader de Sparkfun Pro Micro

Finalmente también tenemos la parte Sparkfun Pro Micro en Fritzing y también encontramos variaciones de la misma para las clones:

Post Data: Toda la información técnica para realizar este post fue sacada y corregida directamente de la página del fabricante de la Pro Micro Original, Sparkfun Electronics. Es posible que los clones chinos cambien algunos parámetros al utilizar otros componentes.

"La palabra 'Arduino' y los logotipos oficiales son marcas comerciales con copyright © de Arduino AG. El software Arduino IDE es propiedad de sus respectivos autores. La licencia principal que rige los productos de Arduino es la Licencia Pública General de GNU (GPL) y la Licencia Pública General Menor de GNU (LGPL). Todos los derechos están reservados por sus respectivos propietarios y licencias correspondientes."

Quieres aportar algo que complemente este articulo? crees que hay algo que se deba corregir? Escríbenos este blog es para todos.

Recuerda que en https://jorgechac.blogspot.com nos dedicamos a construir una electrónica mejor! y apoyamos el proyecto CTC GO! (Creative Technologies in the Classroom) que es un programa de educación steam personalizable.