Raspberry PI y Python

PYTHON

Python es un lenguaje de programación multiplataforma y de código abierto que puede utilizarse tanto para desarrollo web, creación de software y procesamiento de datos, entre muchos otros propósitos. Esta versatilidad y facilidad para aprenderlo (es ampliamente considerado el lenguaje más sencillo de aprender) lo han convertido en el lenguaje de programación más popular del mundo.

Fue lanzado por primera vez en 1991 por Guido van Rossum y sigue siendo desarrollado hoy en día por la Python Software Foundation.

Python se basa en los lenguajes C y C++ y tiene sus raíces en el sistema operativo UNIX. Python existe desde hace años, pero no fue hasta mediados de la década de 2000 cuando se afianzó en el mundo del desarrollo web, con el auge de sitios como Wordpress.

1) Crea el programa Hola Mundo.

print("Hola Mundo") #Manda al puerto seria la parabra hola mundo
nombre = input("Introduce tu nombre:\n")
print("hola", nombre, "¿Cómo estas?")

2) Tipos de datos y operaciones: Crea la variables:

a = 56

b = 45.34

c = "Hola"

d = True

e = [1, 23, "adiós",False]

Utilizando la función type escribe el programa que devuelva el tipo de variable que es.

a = 56
b = 45.34
c = "hola"
d = True
e = [1,23,21,"adio",14,False]
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))

3) Uso de la función print y input, Ejecuta el siguiente programa y comprueba el resultado en el terminal.

number = input("Introduce un número: \n")
print(type(number))
print(5 * int(number))
#Conversión de str a int
number = int(number)
print(type(number))
print(5 * number)
#Conversión de str a float
number = float(number)
print(type(number))
print(5.1 * number)

Introduce un número:

<class 'str'>

<class 'int'>

<class 'float'>

30.599999999999998

4) Uso del tipo de variables. Lista de datos: Crea la siguiente lista nums = [1, 2, 2, 3, 3, 3, 3, 2, 1, 3] y utiliza remove () para eliminar el número 3.

mumero = [1, 2, 3, 3, 3, 3, 2, 1, 3]
#indice  #c  1  2  3  4  5  6  7  8
print("Longitud de la lista; \t", len(mumero))
#muestra los elementos del 2 hasta el final
print("Elementos del indice 2 hasta el final; \t", mumero[2:])
#muestra los elemetos desde o al 2
print("Elementos del indice 0 al 2; \t", mumero[0:3])
#muestra los elementos del indice 2 al 5
print("Elementos del indice 2 al 5; \t", mumero[2:6])
#Uiiliza renove() para eliminar el número 3 de la lista
mumero.remove(3)
print("Lista después de eliminar el número 3; \t", mumero)
print("Longitud de la lista; \t", len(mumero))
for i in range(2,5,1):
    mumero.remove(3)
print("Lista después de eliminar el número 3; \t", mumero)
print("Longitud de la lista; \t", len(mumero))
mumero.remove(3)
print("Lista después de eliminar el número 3; \t", mumero)
print("Longitud de la lista; \t", len(mumero))

5) Uso de la función IF. Crear un programa que solicite por el teclado dos números y escribe por pantalla el mayor de ambos.

#Solicta al usuario un numero y conviertelo en entero
numero1 = input("Ingrese el primer número: \n")
numero2 = input("Ingrese el segundo número: \n")

if (numero1.isdigit() and numero2.isdigit()):
    numero1 = int(numero1)
    numero2 = int(numero2)

if (numero1 > numero2):
    print("El número mayor es: ", numero1)  
elif numero2 > numero1:
    print("El número mayor es: ", numero2)
else:
    print("Los números son iguales: ", numero1, " y ", numero2)

6 ) Uso del bucle FOR

Realiza un ejercicio que inserte 5 nombres en una lista, con la orden for.

7) Uso de la función while().

Escribe un programa que sume 5 número usando la función while.

9) Declaración de Funciones Crea una función que ejecute calcula el área de un polígono regular usando la función math.

import math
n_de_lados = int(input("Ingrese el numero de lados del poligono: "))
longitud_lado = float(input("Ingrese la longitud del lado del poligono: "))
area = (n_de_lados * longitud_lado**2) / (4 * math.tan(math.pi / n_de_lados))
print("El area del poligono es:", area)

10) Crea un juego de naves espacial con al librería minijuegos.py. Para descargar la librería pincha Aquí

Para descargar la instrucciones de uso de la librería pinche Aquí.

Ejemplo:

import minijuegos as mj

mj.crearVentana(600, 400,)
#mj.colorFondo(10, 10, 40)
mj.fondoImagen("espacio.png")
# Jugador
mj.objeto("jugador", 50, 50, 250, 300, "nave.png")
mj.marcarJugador("jugador")

# Enemigo
mj.objeto("enemigo1", 50, 50, 100, -50, "ovni.png")
mj.marcarEnemigo("enemigo1")

mj.objeto("enemigo2", 50, 50, 300, -150, "ovni.png")
mj.marcarEnemigo("enemigo2")

# Movimiento jugador
mj.mueveTecla("jugador", "izquierda", 5)
mj.mueveTecla("jugador", "derecha", 5)
mj.mueveTecla("jugador", "arriba", 5)
mj.mueveTecla("jugador", "abajo", 5)

# marcador de puntuación en la esquina superior izquierda
mj.iniciarPuntuacion(10, 10, color="yellow")

# Enemigos bajan
mj.configurarEnemigos(velocidad=2)

# Disparos con espacio
def disparo():
    mj.disparar("jugador", "bala.png", ancho=10, alto=20)

mj.teclaAccion("espacio", disparo)



# Qué pasa cuando muere un enemigo
def enemigo_muerto(nombre):
    print("Enemigo destruido:", nombre)
    # cada enemigo vale 10 puntos
    mj.sumarPuntos(10)

mj.configurarMuerteEnemigo(enemigo_muerto)

# Colisión directa jugador–enemigo
def choque():
    print("¡Colisión con el jugador!")
    # guardar la puntuación en el registro y mostrar la mejor obtenida
    mj.guardarRegistro()
    registros = mj.leerRegistro()
    
    # Mostrar en pantalla
    mj.texto("¡GAME OVER!", 300, 150, color="red")
    mj.texto(f"Tu puntuación: {mj.obtenerPuntuacion()}", 300, 200, color="yellow")
    
    if registros:
        mejor = max(registros)
        mj.texto(f"Mejor puntuación: {mejor}", 300, 250, color="white")
        print("Mejor puntuación hasta ahora:", mejor)
    else:
        mj.texto("No hay puntuaciones registradas.", 300, 250, color="white")
        print("No hay puntuaciones registradas aún.")

mj.colision("jugador", "enemigo1", choque)
mj.colision("jugador", "enemigo2", choque)

mj.iniciar()

11) Crea una ventana, donde definamos un tamaño de ventana se 500 * 500, color de fondo azul, tenga un frame que ponga un texto, donde introduciremos una imagen.

#Impottamos la libraria TK para crear ventanas
from tkinter import *

#Creamos una ventana, para ello creamos una variable donde meterla
ventana = Tk()
ventana.title ("Prueba")
ventana.config (bg="green")
#Para poder meter algo en al ventana hay que hacerlo en un frame
miframe = Frame(ventana)

miframe.pack ()   #Empaqueto el frame para que esté en la ventana.
miframe.config (width = "600", height ="600")
miframe.config (bg ="red")
#Meter un texto o una imagen se hace con label
Label (miframe, text ="Hola mundo").place (x=100, y=40)
#Para crear una imagen hay que crear una variable y después meter una imagen dentro de tipo png o gif
#que debe estar en la carpeta donde tengamos el programa.
miframe.pimagen = PhotoImage(file="lapiz.png")

a = 50

for i in range(10):

    Label(miframe, image=miframe.pimagen).place(x=a, y=100)
    a = a +10
#print('a')
   
ventana.mainloop()   #Es un bloque infinito para que la ventana.

12) Realiza un programa que reste y sume dos número distintos, y el resultado lo imprima en la consola.

#Defino la función y dos argumentos que son los que vamos a usar
def suma(num1,num2):
    resultado=num1+num2
    return(resultado)

print(suma(5,6))
print("ESTE ES EL ARCHIVO CORRECTO")

13) Las listas son formas de almacenas una serías de variables, en forma de matriz.

#La lista hay que definer entre corchetes 
milista=["casa","piso","parcela","chalet"]
#insertar 1 elemento
milista.insert(4,"rascacielos")
#exterder más de un elemento
milista.extend([5,25.8,True])
print (milista[:])
print (milista[2])
#Para saber en posición esta un elemento por ejemplo piso funciona para lista de texto no mixtas
#Al extender con números y True la función index no funciona.
#print (milista.index("piso")
print ("piso" in milista)
# Las Tuplas son paracidas a las lista pero en ella no se cambia los valores solo se almacenan los datos
# No sirve para recorrerla, expandiarla, añadir y eliminar elemento.
mitupla=("casa",2,2.5,True)
#Te la el elemento que esta en la posición 2 contando el cero.
print(mitupla[2])

14) Dibuja dos líneas que se crucen dentro de una ventana.

#Importamos la libreria que gestiona las pantalla
from tkinter import *
# vamos en crear un widget donde podemos gestionar figuras geométricas, imagenes, dibujos.
Canvas = Canvas (width=800,height=600,bg='green')
#Empaquetamos el widget con para indicar que el canvas se expande con la ventana, y fill=BOTH 
# establece que este widget debe rellenar todo el espacio vertical u horizontal, con esto tenemos 
# un canvas que ocupa toda la ventana.
Canvas.pack(expand=YES, fill=BOTH)
#creamos la linea indicando los puntos iniciales y finales.
Canvas.create_line(10,20,220,20)
#AL función mainloop se pone porque la ventana tiene que estar siempre en ejecución  
mainloop()

15) Dibuja arcos concéntricos que vayan aumentando el radio en 20 dentro de una ventana.

import minijuegos as mj
#crear la ventana para dibujar
mj.crearVentana(600, 400,)
mj.colorFondo(20, 10, 40)

#Crear circulos concéntricos

for i in range(10, 200, 10):
    mj.circulo( 300, 200, i, "white", 2)   
mj.iniciar()

16) Dibujar tres rectángulos dentro de una ventana que tengan distintos colores y tamaño.

#Importamos la libreria que gestiona las pantalla
from tkinter import *
# vamos en crear un widget donde podemos gestionar figuras geométricas, imagenes, dibujos.
Canvas = Canvas (width=800,height=600,bg='green')
#Empaquetamos el widget con para indicar que el canvas se expande con la ventana, y fill=BOTH 
# establece que este widget debe rellenar todo el espacio vertical u horizontal, con esto tenemos 
# un canvas que ocupa toda la ventana.
Canvas.pack(expand=YES, fill=BOTH)
#creamos un cuadrado indicando los puntos de la esquina superior izquierda y la inferior derecha.
Canvas.create_rectangle(10,20,220,200,fill='red',width=5)
#AL función mainloop se pone porque la ventana tiene que estar siempre en ejecución  
mainloop()

17) Dibuja los arcos olímpicos dentro de una ventana. Par que te sirve a ayuda te dejo el ejercicio siguiente:

#Importamos la libreria que gestiona las pantalla
from tkinter import *
# vamos en crear un widget donde podemos gestionar figuras geométricas, imagenes, dibujos.
Canvas = Canvas (width=800,height=600,bg='green')
#Empaquetamos el widget con para indicar que el canvas se expande con la ventana, y fill=BOTH 
# establece que este widget debe rellenar todo el espacio vertical u horizontal, con esto tenemos 
# un canvas que ocupa toda la ventana.
Canvas.pack(expand=YES, fill=BOTH)
#creamos un circulo indicando  referencia a los extremos superior izquierda e inferior derecha 
Canvas.create_oval(200,200,50,100,fill='#2C6377',width=3)
#AL función mainloop se pone porque la ventana tiene que estar siempre en ejecución  
mainloop()

18) Trabajamos con imágenes.

#Importamos la libreria para gestionar las ventanas
from tkinter import *
ventana=Tk()
#Creamos un widget donde hacer las representaciones gráficas.
Canvas=Canvas(width=800,height=600,bg='green',)
Canvas.pack(expand=YES,fill=BOTH)
#creamos una variales y almacenamos la imagen
lapiz=PhotoImage(file='lapiz.png')
#cargamos la imagen el la ventana en el  punto 50, 50 y con 
# anchor le decirmos que el origen es la esquina superior izquierda.
Canvas.create_image(50,50,image=lapiz,anchor=NW)

ventana.mainloop()

19) Bucle condicional IF.

from tkinter import *
from xml.etree.ElementPath import get_parent_map
ventana = Tk()
ventana.geometry("700x600")
ventana.title ("Lienzo para dibujar")

Lienzo = Canvas (width=600, height=500, bg='yellow')
Lienzo.pack()
a = 0

if a == 0:
    circulo=Lienzo.create_oval(20, 20, 60, 60, fill= 'green')
else:
    cuadrado=Lienzo.create_rectangle(60, 60, 120, 120, fill='black')


ventana.mainloop()

20) Bucle FOR.

a = 0
for i in range(10):
    a = a +1
    print (a)

Crear circulo concéntricos con la función for.

from tkinter import *

ventana = Tk()
Lienzo=Canvas(width=800,height=600,background='red')
Lienzo.pack(expand=YES, fill=BOTH)
#crear las variables para las coordenadas.
x1=200.0;y1=200;x2=300;y2=300;c=0

for i in range(15):
    #Tenemos que relacionar la esquina superiro izquierda y inferior derecha con
    #con el centro de la circunferencia al alto y ancho.
    Lienzo.create_oval(x1,y1,x2,y2,fill='green')
    #Variación de la coordenadas.
    c=-1*(c+10)
    x1=x1-(c/2)
    y1 =y1-(c/2)
    x2=x2+(c/2)
    y2=y2+(c/2)
    
ventana.mainloop()

21) Bucle while.

ffrom tkinter import *

ventana = Tk()
ventana.geometry("800x600")
ventana.title("Ejemplo finción while")

Lienzo=Canvas(width=700, height=500,bg='pink')
Lienzo.pack()

a = 20
while a <= 400:
    Linea=Lienzo.create_line(100, 30+a, 400, 30+a, fill='black')
    a = a + 4

ventana.mainloop()

22) Clases.

#Las clases son pequeños programas que sirven para llamarlos desde otro programa.
#Están empaquetos, significa que se acceden a ellos con argumentos o parámetros
#Se pueden definir propiedades (que son como es o características del objeto) o
#comportamiento (que son funciones, que aquí se llaman métodos, que se ejecutan en la clase)

class Coche ():

#Para tener que parámetros se van a establecer de partida se una un constructor esto de hace
#con el metodo def  y el nombre__init__ seguido de (self)
    def __init__(self):

        self.largoCoche=250
        self.anchoCoche=150
        self.__ruedas=4  #Para encapsular una variable y que no se puede modificar de fuera se pone __nombre.
        self.enmarcha=True
#Vamos a crear un metodo para ello se hace con la def.
# se le pone un nombre y te crear un argumento llamado self

    def arranca (self,arrancamos):  #self signicica uno mismo loa que sustituye el al nombre que le pongas 
        #a la instancia  en este caso sería (micoche.)
        self.enmarcha=arrancamos
        if (self.enmarcha):
            self.__estado()  #ejecutando el encasulado del método
            return "El coche está en marcha"

        else:
            return "El coche está parado"

#Si queremos encapsular un método se hace con 2 guiones bajos igual que con los parámetros

    def __estado (self):   #encasulado del método
        print ("El ancho es: ",self.anchoCoche,"Largo: ",self.largoCoche,
        "Número de ruedas: ",self.__ruedas)

#Para llamar a la clase primero hay que INSTANCIAS la clase que se hace de la
#siguiente manera.
micoche=Coche()

#Para usar una caracterísca (micoche.largoCoche)o comportamiento (micoche.arranca())
# se hace con el punto.

print (micoche.arranca(False))



print ("--------Vamos a crear otro objeto usando la misma clase.------")

micoche2=Coche()
micoche2.largoCoche=300
print (micoche2.arranca(True))

23) Movimiento simple de un rectángulo

from tkinter import *
from tkinter.ttk import * 
#Definimos la ventana, titulo y tamaño
ventana = Tk()
ventana.title("Movimiento básico de figura")    #Asignamos un título a la ventana
ventana.geometry("800x600")  #Ponemos el fondo de la ventana en verde
#definimos el ancho y alto que nos vamos a desplazar y el tamaño que le daremos al widgetCanvas
w=600
h=400
x = w//2  #División coge el número entero de la división
y = h//2

#creamos la widget que usaremos para representas las figuras geométricas
canvas = Canvas(ventana, width=w, height=h, bg='green')
canvas.pack()
#Creamos el rectángulo
rectangulo =canvas.create_rectangle(x, y, x+20, y+20, fill = "black")
#Para mover el objeto de crea una función en la que se mueve el objeto 
#para usar el retardo con after hay que asociar el método a la función para que funcione
def movimiento():
    x=5
    y=5

    canvas.move(rectangulo, x, y) 
    canvas.after(50,movimiento)


movimiento()

mainloop()

24) Movimiento de círculo con el teclado

from tkinter import *
from turtle import down, left, right, up
#Definir las ventanas
Ventana = Tk()
Ventana.geometry("800x600")
Ventana.title("Área de dibujo")
#Definimos las variables
w= 700
h = 500
X= w//2
Y= h//2
#definimos el lienx¡zo de trabajo
Lienzo=Canvas(Ventana, width=w, height=h,bg='blue')
Lienzo.pack()
#Creamos el ciculo
circulo=Lienzo.create_oval(X, Y, X+20, Y+20, fill='yellow')

#Definamos las funciones que harán los movimientos
def left(event):
    Lienzo.move(circulo, -10, 0)
def right(event):
    Lienzo.move(circulo, 10, 0)
def up(event):
    Lienzo.move(circulo, 0, -10)
def down(event):
    Lienzo.move(circulo, 0, 10)

#Meter los datos desde el teclado
Ventana.bind("<Left>", left)
Ventana.bind("<Right>", right)
Ventana.bind("<Up>", up)
Ventana.bind("<Down>", down)

Ventana.mainloop()

25) Movimiento con ratón

import tkinter as tk
#Luego de crear el objeto de la clase Canvas procedemos a llamar al método bind e indicar 
# el nombre de evento a capturar y el método que lo capturará:
class Aplicacion:
    def __init__(self):
        self.ventana1=tk.Tk()
        self.canvas1=tk.Canvas(self.ventana1, width=600, height=400, background="black")
        self.canvas1.bind("<Motion>", self.mover_mouse)
        self.canvas1.bind("<Button-1>", self.presion_mouse)
        self.canvas1.grid(column=0, row=1)
        self.ventana1.mainloop()
#Para capturar el desplazamiento de la flecha del mouse debemos especificar 'Motion' y la 
# presión del botón izquierdo del mouse debemos especificar ''Button-1'.
    def presion_mouse(self, evento):
        self.canvas1.create_oval(evento.x-5,evento.y-5,evento.x+5,evento.y+5, fill="red")
#Todos los métodos que capturan eventos reciben un parámetro con información del evento propiamente 
# dicho. Los atributos x e y almacenan la coordenada actual de la flecha del mouse.

#El método 'presion_mouse' se dispara cuando presionamos el botón izquierdo del mouse dentro 
# del objeto canvas1. Dibujamos un círculo teniendo en cuenta donde se encuentra la flecha del
#  mouse en este momento:
    def mover_mouse(self, evento):        
        self.ventana1.title(str(evento.x)+"-"+str(evento.y))

aplicacion1=Aplicacion()

26) Movimiento con rebote

from tkinter import *
#from time import sleep
#time = time()
Ventana = Tk()

canvas = Canvas(Ventana, width = 500, height = 500)
canvas.pack()
radio = 10
Xc = 2 
Yc = 2

#Se crea una tupla con las dimensiones de la caja que contiene la circunferencia.
Caja_circunferencia = (-radio, -radio, radio, radio)
circulo = canvas.create_oval(*Caja_circunferencia)
Direccion = 0
 
def move_oval():
    global Direccion
    x1, y1, x2, y2 = canvas.coords(circulo)
    
    if x2 >= 500 or y2 >= 500:
        Xc = -2
        Yc = -2
        Direccion = 1
    if x1 <= 0 or y1 <= 0:
        Xc = 2 
        Yc = 2 
        Direccion = 0
    if  ((x1 > 0  or x2 < 500 or y1 > 0 or y2 < 500)  and  Direccion == 0):
        Xc = 2 
        Yc = 2 
    if  ((x1 > 0  or x2 < 500 or y1 > 0 or y2 < 500)  and  Direccion == 1):
        Xc = -2 
        Yc = -2 

    canvas.move(circulo, Xc, Yc)
    canvas.after(40, move_oval)


# Ponemos el funcionamiento el circulo


move_oval()
#time.sleep(40)

Ventana.mainloop()

Raspberry PI

Los pines más cercanos al borde de la placa son pares y los más internos impares:

ALIMENTACIÓN PARA SENSORES A 3.3V: PINES 1 Y 17 ALIMENTACIÓN PARA ACTUADORES A 5V: PINES 2 Y 4 MASA: PINES 6, 9, 14, 20, 25, 30, 34 Y 39

RESTO DE PINES: ENTRADAS/ SALIDAS DIGITALES.

PRÁCTICA 1. LED INTERMITENTE

Esta práctica consiste en conectar un led a la Raspberry que se encenderá y se apagará cada segundo. Esta práctica puede realizarse con el led rojo o blanco.