-->

Menú principal

lunes, 29 de enero de 2024

TECNOLOGÍA 4º ESO - Proyecto brazo robótico con mecanismo hidráulico

 TEMA 6.-NEUMÁTICA E HIDRÁULICA. PROYECTO BRAZO ROBÓTICO

    Este proyecto permite la construcción de un brazo robótico hidráulico utilizando materiales sencillos como madera, cartón y jeringas. Es necesario explorar varios principios de ingeniería y física de manera práctica y accesible. Al construir este brazo robótico, los estudiantes pueden comprender mejor conceptos como la mecánica de fluidos, la transmisión de fuerzas y el diseño estructural, y los principios de la neumática y la hidráulica, fundamentales en diversas áreas de la ingeniería.

Principios de la hidráulica

    La hidráulica es una rama de la física y la ingeniería que se ocupa del uso de líquidos para transmitir fuerza. En el contexto de un brazo robótico, este principio se aplica usando jeringas llenas de líquido que, al presionar o tirar del émbolo, mueven las partes del brazo. Este sistema imita cómo los cilindros hidráulicos reales operan en maquinaria y robótica, proporcionando una manera eficiente y controlable de generar movimiento y fuerza.

Fuente: https://ecoinventos.com/como-construir-un-brazo-robot-hidraulico-de-carton/

Materiales para hacer un brazo robot hidráulico.

Los materiales que vamos a necesitar son:

  • Madera, chapón de 3 mm de espesor
  • Cartón, de cualquier caja.
  • Palillos de madera, como la de los pinchitos o brochetas.
  • Pegamento.
  • Unos palos de helado.
  • Pila gastada.
  • Jeringas (7).
  • Tubo de plástico.
  • Agua.

Instrucciones para hacer un brazo robot hidráulico de cartón.

Las instrucciones de fabricación las encontrarás en el vídeo:


Aplicaciones y extensión del proyecto

    El brazo robótico hidráulico puede ser usado en contextos educativos para enseñar conceptos de física, matemáticas, y diseño de ingeniería. Además, se pueden explorar extensiones como la incorporación de sensores para control automático, la comparación de diferentes fluidos para evaluar eficiencia y precisión, o el rediseño para tareas específicas como la manipulación de objetos ligeros. Este proyecto también fomenta habilidades importantes como el pensamiento crítico, la resolución de problemas y la creatividad.

SITUACIÓN DE APRENDIZAJE. PASOS A SEGUIR

    Al construir un brazo robótico accionado hidráulicamente con madera, cartón y jeringas, el alumnado seguirá los siguientes pasos para llegar al producto final:

  1. Principios básicos de hidráulica: el alumnado aprenderá cómo la transmisión de fuerza a través de líquidos (agua o aceite) en un sistema cerrado puede usarse para mover o controlar sistemas o máquinas.
  2. Ingeniería mecánica y diseño: comprendería aspectos básicos del diseño y la construcción mecánica, como la articulación y el movimiento de las partes del brazo robótico.
  3. Habilidades de resolución de problemas: el proceso de ensamblaje y puesta en marcha del brazo robótico puede enseñarle a pensar de manera crítica y a resolver problemas que puedan surgir durante la construcción.
  4. Creatividad e innovación: estimula la creatividad del alumnado y la competencia aprender a aprender,  desarrollando nuevas formas de usar materiales de uso técnico para crear un proyecto funcional y novedoso.
  5. Coordinación y destreza manual: al construir el brazo, el alumnado mejora sus habilidades motrices y coordinación.
  6. Trabajo en grupo: permite al alumnado trabajar en grupos, aprendiento a coordinarse y socializarse.
  7. Obtención de un producto final: el alumno se sentirá satisfecho y realizado al comprobar que su esfuerzo, junto con el resto del grupo, permite la obtención de un producto final, en este caso un brazo robótico funcional que tiene utilidad.

    Este tipo de proyectos prácticos son excelentes para introducir al alumnado en conceptos de ciencia, tecnología, ingeniería y matemáticas (STEM) de una manera divertida y atractiva. Importante que los materiales que vamos a usar sean mayormente reciclados.

PLANOS DE CONSTRUCCIÓN DEL PROYECTO

    Los planos de cada una de las piezas se deberán realizar con el programa LibreCAD antes de comenzar la construcción del proyecto. Se utilizará la plantilla con el formato A4 y el cajetín realizados previamente, cuyo diseño se detalla en el siguiente enlace:

https://fdiazuceda.blogspot.com/2016/11/dibujo-del-formato-a4-con-cajetin-en-el.html

    A continuación se realizará el diseño de la piezas de la primera etapa del brazo robótico:

Podemos encontrar los planos y el proceso de fabricación en el siguiente documento a descargar en pdf:



Otro Blog donde podéis encontrar información es:


Podemos hacer el terminal del brazo como una pinza para coger objetos o como una pala excavadora:
Para ello podemos descargar el documento completo con los planos y la instrucciones de montaje en:




 

miércoles, 24 de enero de 2024

Computación y Robótica 1º ESO - Tema 4.-Introducción a la programación con Python

 Tema 4.-Introducción a la programación con Python

ÍNDICE
1.-¿Qué es Python
2.-¿Qué es Thonny?
3.-Instalación y ejecución de Thonny
4.-Ejercicios con el entorno Thonny
5.-Introducción a Turtle Graphics
6.-Introducción al módulo gráfico Tkinter


2.-¿Qué es Python?

    Python es un lenguaje de programación de alto nivel que se ha vuelto muy popular en los últimos años debido a su facilidad de aprendizaje y su amplia gama de aplicaciones. Es utilizado en áreas tan diversas como la programación web, el análisis de datos, la inteligencia artificial, la automatización de tareas y la programación de videojuegos, entre otras.

    La sintaxis de Python es simple y legible, lo que lo hace ideal para aquellos que están aprendiendo a programar por primera vez. Además, la comunidad de desarrolladores de Python es muy activa, lo que significa que hay una gran cantidad de recursos y herramientas disponibles para ayudar a los programadores novatos a aprender y a mejorar sus habilidades.

    Si eres nuevo en la programación, Python es un gran lugar para comenzar. Con un poco de dedicación y práctica, puedes aprender los fundamentos de la programación y comenzar a crear tus propios programas en poco tiempo.



2.-¿Qué es Thonny?

Entorno de programación Thonny para Python. Sitio web oficial.

    Thonny es un entorno de desarrollo integrado (IDE) diseñado específicamente para programadores Python. Su objetivo principal es hacer que la programación en Python sea más accesible para principiantes y, al mismo tiempo, proporcionar las herramientas necesarias para programadores más experimentados.

Manual de Python para ESO y Bachillerato

Este es un manual de iniciación a Python con el entorno de programación Thonny.



3.-Instalación y ejecución de Thonny

    En Linux vamos al menú aplicaciones y seleccionamos la opción "Herramientas del sistema", y elegimos la opción del submenú "Centro de sofware de Educandos". En la ventana que nos aparece hacemos clic en la lupa y escribimos la palabra "Thonny" en el cuadro de texto:


Tambien podemos seleccionar dentro de los grupos de programas instalar, el bloque de "Herramientas de desarrollo", donde nos aparecerá entre ellas el entorno Thonny.





4.-Ejercicios con el entorno Thonny

Ejercicio 1: Cálculo del espacio recorrido por un vehículo


print ('Cálculo del espacio recorrido por un vehículo')
v=input('Introduce la velocidad del vehículo en Km/h: ')
v=eval(v)
t=input('Introduce el tiempo que tarda en horas: ')
t=eval(t)
e=v*t
print ('El espacio recorrido es: ',e,'Km')

Ejercicio 2: Saludo


#Ventana de código

Ejercicio 3: Cálculo de la media de varias notas


print('Programa para calcular la media de cuatro notas')
n1 = input('Escribe la primera nota: ')
n1 = float(n1)
n2 = input('Escribe la segunda nota: ')
n2 = float(n2)
n3 = input('Escribe la tercera nota: ')
n3 = float(n3)
n4 = input('Escribe la cuarta nota: ')
n4 = float(n4)
media = (n1 + n2 + n3 + n4)/4
print('La media es: ', media)

Ejercicio 4: Cálculo de los divisores de un número. Si el numero solo es divisible entre 1 y entre si mismo, se trata de un número primo.


print('Este programa te informará de los divisores de un número')
print('Si solo es divisible entre 1 y entre si mismo, es primo')
print('')
n=input('Escribe un número: ')
n=eval(n)
for i in range(1,n):
    if n%i==0:
        div=n/i
        print('El número',n,'es divisible por',i,'y se obtiene',div)

Ejercicio 5: Cálculo de los divisores de un número con recuento del tiempo transcurrido:


import time
print('Este programa te informará de los divisores de un número')
print('Si solo es divisible entre 1 y entre si mismo, es primo')
print('')
n=input('Escribe un número: ')
n=eval(n)
inicio = time.time()
for i in range(1,n):
    if n%i==0:
        div=n/i
        print('El número',n,'es divisible por',i,'y se obtiene',div)
     
fin = time.time()
print('Tiempo transcurrido: ',fin-inicio)

Ejercicio 6: La función "Es_primo" para saber si un número es primo:


print('Para ejecutar la función escribe es_primo(número) en la consola')
def es_primo(num):
    for n in range(2, num):
        if num % n == 0:
            print("No es primo", n, "es divisor")
            return False
    print("Es primo")
    return True

Ejercicio 7: Cálculo de la tabla de multiplicar de un número:


print('Este programa calcula las tablas de multiplicar')
numero=input('Qué tabla de multiplicar quieres calcular: ')
numero=eval(numero)
for n in range(1,11):
    print(n ,'x', numero, '=', n*numero)

Ejercicio 8: Cálculo del índice de masa corporal en función de la edad:

Una medida de la obesidad se determina mediante el índice de masa corporal (IMC), que se calcula dividiendo los kilogramos de peso por el cuadrado de la estatura en metros (IMC = peso (kg)/ [estatura (m)]2.


print('Este programa calcula el índice de masa corporal IMC')
altura=input('Introduce tu estatura en centímetros: ')
altura=eval(altura)
peso=input('Introduce tu peso en kilos: ')
peso=eval(peso)
imc=peso/((altura/100)**2)
imc=float(imc)
print('El IMC es: ',imc)
if imc<18.5:
    print('Tu peso es inferior al normal')
if imc>18.5 and imc<24.9:
    print('Tu peso es normal')
if imc>25 and imc<29.9:
    print('Tu peso es superior al normal')
if imc>30:
    print('Obesidad')    

Ejercicio 9: Cálculo de la raiz cuadrada


import math
print('Este programa calcula la raíz cuadrada,')
print('de los números: 1 al 10')
for x in range(1,11):
    print(x,math.sqrt(x))

Ejercicio 10: Cálculo del máximo común múltiplo y mínimo común divisor:


import math
print('Este programa calculará el mcd y mcm,')
print('de los 2 números que introduzcamos')
n1=input('Escribe el número 1: ')
n1=eval(n1)
n2=input('Escribe el número 2: ')
n2=eval(n2)
mcd=math.gcd(n1,n2)
mcm=(n1*n2)/mcd
print('El Máximo Común Divisor es',mcd)
print('El Mínimo Común Múltiplo es',mcm)

Ejercicio 11: Cálculo de la fecha y hora


import time
import datetime
from time import gmtime,localtime,strftime
print('Obtener la fecha y hora actual en diferentes formatos')
print('Tiempo en segundos:',time.time())
print('Fecha y hora como un texto:',time.ctime())
print('Fecha y hora en formatos habituales')
f_corto=strftime('%d/%m/%y',localtime())
print('Fecha en formato corto:',f_corto)
fh_corto=strftime('%d/%m/%y %H:%M:%S',localtime())
print('Fecha y Hora:',fh_corto)
print('Información con datetime.date')
hoy=datetime.date.today()
print(hoy)
print('Día de la semana:',hoy.weekday())
print('Día del mes:',hoy.day)

Ejercicio 12: Cálculo de la diagonal y el área de un cuadrado


from math import sqrt
def diagonal(lado):
    resultado=sqrt(lado**2+lado**2)
    return resultado
def area(lado):
    resultado=lado*lado
    return resultado
print('Programa que calcula la diagonal de un cuadrado')
l=input('Introduce el lado del cuadrado en metros: ')
l=eval(l)
print('El cuadrado de lado',l,'tiene de diagonal',diagonal(l),'m')
print('El cuadrado de lado',l,'tiene un área',area(l),'m2')


Ejercicio 13: Realiza un programa que genere 6 números aleatorios entre 1 y 49. Como el juego de la primitiva.

print('Este programa genera 6 números de la primitiva')
from random import randint
from time import sleep

print('Este programa genera 6 números de la primitiva')
for n in range(6):
    numero=randint(1,49)
    print('Generación:',n+1,'Número generado:',numero)
    sleep(1)

5.- Introducción a Turtle Graphics

    Si recordais en el tema 3 hemos visto la programación con LOGO utilizanto el programa Xlogo, que nos permite dibujar diferentes figuras. Vamos a dar un paso adelante y vamos a programar en Python de forma similar a Xlogo, pero con un entorno más avanzado utilizando Thonny. Para ello vamos a usar una librería de Python llamada Turtle Graphics.

¿Qué es Python Turtle Graphics?

Python Turtle Graphics es un módulo de programación gráfica para Python utilizado como método para enseñar programación a través de coordenadas relativas. El objeto a programar recibe el nombre de tortuga, elemento clave en el lenguaje de programación Logo, creado por Seymour Papert a finales de la década de los 60.

Ejemplos de Python Turtle Graphics
Ejemplos de Python Turtle Graphics

A la tortuga es un objeto al cual se le puede dar órdenes de movimiento (avance, retroceso, giro, etc). Moviendo adecuadamente la tortuga se puede conseguir dibujar todo tipo de figuras. La tortuga dispone de 3 atributos esenciales:

  • Posición: Respecto al centro de coordenadas.
  • Orientación: Dirección hacia donde mira la tortuga.
  • Pluma: Rastro que puede dejar la tortuga al desplazarse.

Ejercicio 14.- Como ejemplo vamos a realizar un sencillo programa que dibuja un cuadrado en una ventana.


¿Qué medidas tiene la ventana de gráficos?


    El escenario donde se dibujan las figuras tiene un tamaño dinámico, es decir, se puede variar redimensionando la ventana. El centro de coordenadas está en el centro de la imagen. Puedes ver como disponemos de 4 cuadrantes y tendremos que calcular las posiciones de los mismos a la hora de dibujar figuras.

Escenario
Ejercicio 15.- Realizar un programa que dibuje un polígono de n lados de una determinada longitud para cada lado.


import turtle
print('Este programa dibuja un polígono de n lados')

window = turtle.Screen()
flecha = turtle.Turtle()
lados=input('Introduce número de lados del polígono: ')
lados=eval(lados)
lon=input('Introduce longitud del lado del polígono: ')
lon=eval(lon)

for i in range(lados):
    flecha.forward(lon)
    flecha.left(360/lados)
    

Ahora vamos a crear una función que nos permita dibujar varios polígonos en la misma ventana. Para ello realizarmos el siguiente ejercicio.

Ejercicio 16: Dibujar varios polígonos usando una función


import turtle
print('Este programa dibuja varios polígonos')

window = turtle.Screen()
flecha = turtle.Turtle()

def poligono(lados,lon):
    for i in range(lados):
        flecha.forward(lon)
        flecha.left(360/lados)

for k in range(3,15):
    poligono(k,90)


Podemos encontrar la documentación oficial de Turtle Graphics en el siguiente enlace:


Ejercicio 17: Dibujar una estrella de colores amarillo y rojo


from turtle import *
color('red', 'yellow')
setpos(-100,0)
begin_fill()
while True:
    forward(400)
    left(170)
    print(pos())
    if abs(pos()) < 100:
        break
end_fill()
done()

Ejercicio 18: Obtener una figura dibujando circulos desplazados sucesivamente.


#Ventana de código

Ejercicio 19: Explora tu imaginación cambiando los valores de las instrucciones:


#Ventana de código

Ejercicio 20: Dibuja una roseta



from turtle import *
Screen()
color('red', 'blue')
penup()
setpos(0,-150)
pendown()
begin_fill()
for i in range(50):
     circle(25, 360)
     left(25)
     for i in range(5):
         forward(120+i*6)
         left(360/6)
end_fill()
done()

6.-Introducción al módulo gráfico Tkinter

Ejercicio 20: Vamos a usar el módulo Tkinter a través de una simple aplicación «Hola Mundo». Nos permite crear una ventana, mostrar un texto y añadir un botón para salir de la ventana.

from tkinter import *
from tkinter import ttk
root = Tk()
frm = ttk.Frame(root, padding=10)
frm.grid()
ttk.Label(frm, text="Hello World!").grid(column=0, row=0)
ttk.Button(frm, text="Quit", command=root.destroy).grid(column=1, row=0)
root.mainloop()

Después de las declaraciones de import, la línea siguiente será la de crear la instancia de la clase Tk la cual inicia Tk y crea el interprete asociado a Tcl. Esto también crea una ventana de nivel superior, conocida como la ventana raíz la cual sirve como la ventana principal de la aplicación.


6.1.- ¿Qué es Tkinter?

El paquete tkinter («interfaz Tk») es la interfaz por defecto de Python para el kit de herramientas de GUI Tk. Tanto Tk como tkinter están disponibles en la mayoría de las plataformas Unix, así como en sistemas Windows (Tk en sí no es parte de Python, es mantenido por ActiveState).

    Es decir tkinter es una interfaz gráfica de usuario para crear ventanas, botones, cuadros de texto, y otros objetos, para diseñar aplicaciones de usuario.

6.2. Widgets de Tkinter

Fuente: https://www.adictosaltrabajo.com/2020/06/30/interfaces-graficas-en-python-con-tkinter/

A la hora de montar una vista con Tkinter, nos basaremos en widgets jerarquizados, que irán componiendo poco a poco nuestra interfaz. Algunos de los más comunes son:

  • Tk: es la raíz de la interfaz, donde vamos a colocar el resto de widgets.

  • Frame: marco que permite agrupar diferentes widgets.
    • Label: etiqueta estática que permite mostrar texto o imagen.

    • Entry: etiqueta que permite introducir texto corto (típico de formularios).

    • Text: campo que permite introducir texto largo (típico para añadir comentarios).

    • Button: ejecuta una función al ser pulsado.

    • Radiobutton: permite elegir una opción entre varias.

    • Checkbutton: permite elegir varias de las opciones propuestas.

    • Menu: clásico menú superior con opciones (Archivo, Editar…).

    • Dialogs: ventana emergente (o pop-up).

    Ejercicio 21: Vamos a crear una aplicación paso a paso, primero creamos la ventana de la interfaz gráfica:


    import tkinter as tk
    ventana=tk.Tk()
    ventana.title("Mi aplicación")
    ventana.geometry("300x200")
    ventana.mainloop()

    Ejercicio 22:Otro ejemplo de cómo se puede implementar la interacción entre elementos de la interfaz es a través de la implementación de una caja de texto y un botón que al presionarlo realice una búsqueda en Google. La implementación se muestra a continuación:
    import tkinter as tk
    import webbrowser
    
    root = tk.Tk()
    
    def  search_google():
        query = textbox.get()
        url = f"https://www.google.com/search?q={query}"
        webbrowser.open_new_tab(url)
    
    textbox = tk.Entry(root)
    textbox.pack()
    
    button = tk.Button(root, text="Search Google", command=search_google)
    button.pack()
    
    root.mainloop()
    

    En este ejemplo creamos una caja de texto utilizando tk.Entry y un botón utilizado usando tk.Button. Luego, creamos una función llamada search_google que utiliza la biblioteca webbrowser para abrir una búsqueda de Google en una nueva pestaña con la consulta escrita en la caja de texto.

    Finalmente vinculamos el botón con la función search_google implementando la función command en el botón.


    import tkinter as tk

    Ejemplo 23: Operaciones de sumar, restar, multiplicar y dividir con dos números


    from tkinter import *
    # Funciones backend
    def borrar():
        n2.set('')
        n1.set('')
    
    def sumar():
        r.set( float( n1.get() ) + float(n2.get() ) )
    def restar():
        r.set( float( n1.get() ) - float(n2.get() ) )
    def multiplicar():
        r.set( float( n1.get() ) * float(n2.get() ) )
    def dividir():
        r.set( float( n1.get() ) / float(n2.get() ) )
    # Estructura del formulario
    root = Tk()
    root.config(bd=15)  # borde exterior de 15 píxeles, queda mejor
    
    # Tres StringVar para manejar los números y el resultado
    n1 = StringVar()
    n2 = StringVar()
    r = StringVar()
    
    Label(root, text="Numero 1").pack()
    Entry(root, justify=CENTER, textvariable=n1).pack()
    
    Label(root, text="\nNumero 2").pack()
    Entry(root, justify=CENTER, textvariable=n2).pack()
    
    Label(root, text="\nResultado").pack()
    Entry(root, justify=CENTER, state=DISABLED, textvariable=r).pack()
    
    Label(root).pack() # Separador
    
    Button(root, text="Sumar", command=sumar).pack()
    Button(root, text="Restar", command=restar).pack()
    Button(root, text="Multiplicar", command=multiplicar).pack()
    Button(root, text="Dividir", command=dividir).pack()
    Button(root, text="Borrar", command=borrar).pack()
    
    root.mainloop()

    Ejercicio 24: Vamos a dar una mejor vista a nuestra calculadora modificando el código anterior:

    from tkinter import *
    from tkinter import ttk
    from decimal import Decimal
    import sys
    root = Tk()
    root.config(bd=10)  # borde exterior de 15 píxeles, queda mejor
    frm=ttk.Frame(root,padding=10)
    frm.grid()
    
    def borrar():
        n2.set('')
        n1.set('')
        r.set('')
    def salir():
        sys.exit()
    def sumar():
        mensaje()
        r.set( float( n1.get() ) + float(n2.get() ) )
    def restar():
        mensaje()
        r.set( float( n1.get() ) - float(n2.get() ) )
    def multiplicar():
        mensaje()
        r.set( float( n1.get() ) * float(n2.get() ) )
    def dividir():
        mensaje()
        if float(n2.get()) > 0: (r.set( float( n1.get() ) / float(n2.get() ) ))
    def potencia():
        mensaje()
        if float(n2.get()) > -1: (r.set( float( n1.get() ) ** float(n2.get() ) ))
    def porcentaje():
        mensaje()
        if float(n2.get()) > -1: (r.set( float( n1.get() ) * float(n2.get())/100))
    def mensaje():
            res1 = n1.get()
            #aquí compruebas que es un número
            res1 = float(res1) if res1.isdigit() else n1.set(0)
            res2 = n2.get()
            #aquí compruebas que es un número
            res2 = float(res2) if res2.isdigit() else n2.set(0)
    # Estructura del formulario
    
    # Tres StringVar para manejar los números y el resultado
    n1=StringVar()
    n2=StringVar()
    r=StringVar()
    result = Label(root,text="")
    
    ttk.Label(root, text="Numero 1").grid(column=0,row=0)
    ttk.Entry(root, justify=CENTER, textvariable=n1).grid(column=1,row=0)
    #n1 = eval(n1)
    ttk.Label(root, text="Numero 2").grid(column=0,row=1)
    ttk.Entry(root, justify=CENTER, textvariable=n2).grid(column=1,row=1)
    #n2 = eval(n2)
    ttk.Label(root, text="Resultado").grid(column=0,row=2)
    ttk.Entry(root, justify=CENTER, state=DISABLED, textvariable=r).grid(column=1,row=2)
    #r = float(r)
    Label(root).grid() # Separador
    
    Button(root, text="Sumar", command=sumar, bg="green").grid(column=0,row=3)
    Button(root, text="Restar", command=restar,bg="orange").grid(column=1,row=3)
    Button(root, text="Multiplicar", command=multiplicar,bg="cyan").grid(column=2,row=3)
    Button(root, text="Dividir", command=dividir,bg="yellow").grid(column=3,row=3)
    Button(root, text="Potencia", command=potencia,bg="blue").grid(column=4,row=3)
    Button(root, text="Porcentaje", command=porcentaje,bg="magenta").grid(column=5,row=3)
    Button(root, text="Borrar", command=borrar).grid(column=6,row=3)
    Button(root, text="Salir", command=salir,bg="red").grid(column=7,row=3)
    root.title("Mi calculdora")
    #root.geometry('450x200')
    root.mainloop()

    Vamos a crear una sencilla calculadora paso a paso que utiliza varios widget. En primer lugar vamos a crear la ventana con el título y una línea con un cuadro de texto donde aparecerán los resultados del cálculo. Este cuadro de texto se pone en fondo negro y se incializa con un cero en color verde:



    from tkinter import *
    from tkinter import messagebox
    import math
    
    class Mycalc(Frame):
    
        def __init__(self, master, *args, **kwargs):
            Frame.__init__(self, master, *args, **kwargs)
            self.parent = master
            self.grid()
            self.createWidgets()
    
        def deleteLastCharacter(self):
            textLength = len(self.display.get())
    
            if textLength >= 1:
                self.display.delete(textLength - 1, END)
            if textLength == 1:
                self.replaceText("0")
    
        def replaceText(self, text):
            self.display.delete(0, END)
            self.display.insert(0, text)
    
        def append(self, text):
            actualText = self.display.get()
            textLength = len(actualText)
            if actualText == "0":
                self.replaceText(text)
            else:
                self.display.insert(textLength, text)
    
        def evaluate(self):
            try:
                self.replaceText(eval(self.display.get()))
            except (SyntaxError, AttributeError):
                messagebox.showerror("Error", "Syntax Error")
                self.replaceText("0")
            except ZeroDivisionError:
                messagebox.showerror("Error", "Cannot Divide by 0")
                self.replaceText("0")
    
        def containsSigns(self):
            operatorList = ["*", "/", "+", "-"]
            display = self.display.get()
            for c in display:
                if c in operatorList:
                     return True
            return False
    
        def changeSign(self):
            if self.containsSigns():
                self.evaluate()
            firstChar = self.display.get()[0]
            if firstChar == "0":
                pass
            elif firstChar == "-":
                self.display.delete(0)
            else:
                self.display.insert(0, "-")
        
        def raiz(self):
            self.display.insert(0, "math.sqrt(")
            self.append(")")
            self.evaluate()
        
        def raizn(self):
            self.display.insert(0, "pow(")
            self.append(",1/")
        
        def log(self):
            self.display.insert(0, "math.log(")
            self.append(",10)")
            
        def logn(self):
            self.display.insert(0, "math.log(")
            self.append(")")
        
        def ex(self):
            self.display.insert(0, "math.exp(")
            self.append(")")
        
        def pi(self):
            self.append("math.pi")
            self.evaluate()
            
        def potencia(self):
            self.display.insert(0,"(")
            self.append(")**")
        
        def porcentaje(self):
            self.display.insert(0,"(")
            self.append("/100)")
            self.evaluate()
            self.append("*")
            
        def inverse(self):
            self.display.insert(0, "1/(")
            self.append(")")
            self.evaluate()
    
        def createWidgets(self):
            self.display = Entry(self, font=("Arial", 24), relief=RAISED, justify=RIGHT, bg='black', fg='green', borderwidth=0)
            self.display.insert(0, "0")
            self.display.grid(row=0, column=0, columnspan=5, sticky="nsew")
    
            self.ceButton = Button(self, font=("Arial", 12), fg='red', text="CE", highlightbackground='red', command=lambda: self.replaceText("0"))
            self.ceButton.grid(row=1, column=0, sticky="nsew")
            self.inverseButton = Button(self, font=("Arial", 12), fg='red', text="1/x", highlightbackground='lightgrey', command=lambda: self.inverse())
            self.inverseButton.grid(row=1, column=2, sticky="nsew")
            self.delButton = Button(self, font=("Arial", 12), fg='blue', text="Del", highlightbackground='red', command=lambda: self.deleteLastCharacter())
            self.delButton.grid(row=1, column=1, sticky="nsew")
            self.divButton = Button(self, font=("Arial", 12), fg='red', text="/", highlightbackground='lightgrey', command=lambda: self.append("/"))
            self.divButton.grid(row=1, column=3, sticky="nsew")
            self.divButton = Button(self, font=("Arial", 12), fg='red', text="(", highlightbackground='lightgrey', command=lambda: self.append("("))
            self.divButton.grid(row=1, column=4, sticky="nsew")
    
            self.sevenButton = Button(self, font=("Arial", 12), fg='blue', text="7", highlightbackground='black', command=lambda: self.append("7"))
            self.sevenButton.grid(row=2, column=0, sticky="nsew")
            self.eightButton = Button(self, font=("Arial", 12), fg='blue', text="8", highlightbackground='black', command=lambda: self.append("8"))
            self.eightButton.grid(row=2, column=1, sticky="nsew")
            self.nineButton = Button(self, font=("Arial", 12), fg='blue', text="9", highlightbackground='black', command=lambda: self.append("9"))
            self.nineButton.grid(row=2, column=2, sticky="nsew")
            self.multButton = Button(self, font=("Arial", 12), fg='red', text="*", highlightbackground='lightgrey', command=lambda: self.append("*"))
            self.multButton.grid(row=2, column=3, sticky="nsew")
            self.divButton = Button(self, font=("Arial", 12), fg='red', text=")", highlightbackground='lightgrey', command=lambda: self.append(")"))
            self.divButton.grid(row=2, column=4, sticky="nsew")
    
            self.fourButton = Button(self, font=("Arial", 12), fg='blue', text="4", highlightbackground='black', command=lambda: self.append("4"))
            self.fourButton.grid(row=3, column=0, sticky="nsew")
            self.fiveButton = Button(self, font=("Arial", 12), fg='blue', text="5", highlightbackground='black', command=lambda: self.append("5"))
            self.fiveButton.grid(row=3, column=1, sticky="nsew")
            self.sixButton = Button(self, font=("Arial", 12), fg='blue', text="6", highlightbackground='black', command=lambda: self.append("6"))
            self.sixButton.grid(row=3, column=2, sticky="nsew")
            self.minusButton = Button(self, font=("Arial", 12), fg='red', text="-", highlightbackground='lightgrey', command=lambda: self.append("-"))
            self.minusButton.grid(row=3, column=3, sticky="nsew")
            self.minusButton = Button(self, font=("Arial", 12), fg='red', text="log", highlightbackground='lightgrey', command=lambda: self.log())
            self.minusButton.grid(row=3, column=4, sticky="nsew")
    
            self.oneButton = Button(self, font=("Arial", 12), fg='blue', text="1", highlightbackground='black', command=lambda: self.append("1"))
            self.oneButton.grid(row=4, column=0, sticky="nsew")
            self.twoButton = Button(self, font=("Arial", 12), fg='blue', text="2", highlightbackground='black', command=lambda: self.append("2"))
            self.twoButton.grid(row=4, column=1, sticky="nsew")
            self.threeButton = Button(self, font=("Arial", 12), fg='blue', text="3", highlightbackground='black', command=lambda: self.append("3"))
            self.threeButton.grid(row=4, column=2, sticky="nsew")
            self.plusButton = Button(self, font=("Arial", 12), fg='red', text="+", highlightbackground='lightgrey', command=lambda: self.append("+"))
            self.plusButton.grid(row=4, column=3, sticky="nsew")
            self.minusButton = Button(self, font=("Arial", 12), fg='red', text="ln", highlightbackground='lightgrey', command=lambda: self.logn())
            self.minusButton.grid(row=4, column=4, sticky="nsew")
    
            self.negToggleButton = Button(self, font=("Arial", 12), fg='red', text="+/-", highlightbackground='lightgrey', command=lambda: self.changeSign())
            self.negToggleButton.grid(row=5, column=0, sticky="nsew")
            self.zeroButton = Button(self, font=("Arial", 12), fg='blue', text="0", highlightbackground='black', command=lambda: self.append("0"))
            self.zeroButton.grid(row=5, column=1, sticky="nsew")
            self.decimalButton = Button(self, font=("Arial", 12), fg='blue', text=".", highlightbackground='lightgrey', command=lambda: self.append("."))
            self.decimalButton.grid(row=5, column=2, sticky="nsew")
            self.equalsButton = Button(self, font=("Arial", 12), fg='red', text="=", highlightbackground='lightgrey', command=lambda: self.evaluate())
            self.equalsButton.grid(row=5, column=3, sticky="nsew")
            self.equalsButton = Button(self, font=("Arial", 12), fg='red', text="e^x", highlightbackground='lightgrey', command=lambda: self.ex())
            self.equalsButton.grid(row=5, column=4, sticky="nsew")
    
            self.negToggleButton = Button(self, font=("Arial", 12), fg='red', text="Raiz(2)", highlightbackground='lightgrey', command=lambda: self.raiz())
            self.negToggleButton.grid(row=6, column=0, sticky="nsew")
            self.negToggleButton = Button(self, font=("Arial", 12), fg='red', text="Potencia", highlightbackground='lightgrey', command=lambda: self.potencia())
            self.negToggleButton.grid(row=6, column=1, sticky="nsew")
            self.negToggleButton = Button(self, font=("Arial", 12), fg='red', text="Porcentaje", highlightbackground='lightgrey', command=lambda: self.porcentaje())
            self.negToggleButton.grid(row=6, column=2, sticky="nsew")
            self.negToggleButton = Button(self, font=("Arial", 12), fg='red', text="Raiz(n)", highlightbackground='lightgrey', command=lambda: self.raizn())
            self.negToggleButton.grid(row=6, column=3, sticky="nsew")
            self.negToggleButton = Button(self, font=("Arial", 12), fg='red', text="Pi", highlightbackground='lightgrey', command=lambda: self.pi())
            self.negToggleButton.grid(row=6, column=4, sticky="nsew")
    
    Calculator = Tk()
    Calculator.title("Mi calculadora")
    Calculator.resizable(False, False)
    Calculator.config(cursor="pencil")
    root = Mycalc(Calculator).grid()
    Calculator.mainloop()

        Obtenemos la siguiente calculadora: