Alumnos: __Pablo Córdoba____________
__________________________
__________________________
__________________________
Fecha de presentación: 17 /04 /2024
Calificación: ________________ Fecha: __ /__ /____
Firma del docente: __________________
Materiales
Para el ejercicio se usará, además de las placas de desarrollo Raspberry Pi Pico y/o Raspberry Pi Pico W,
LED’s, presets o potenciómetros, pulsadores, resistencias necesarias y un protoboard donde conectar
todo.
Informe
Para la entrega del informe (en formato electrónico) se pide:
• Archivo editado con la carátula debidamente completada con los integrantes del grupo.
• Foto o escaneo de esta hoja firmada con el visto del docente cuando corrobora que lo implementado
funciona como se pidió.
• Un diagrama o circuito eléctrico del armado donde se especifiquen valores de componentes y
terminales utilizados en las placas de desarrollo.
• El código implementado para la solución y una breve descripción de lo que hace cada parte.
Enunciado
El siguiente puntos debe estar resuelto aplicando, cuando sea pertinente, interrupciones de GPIO, demora
anti-rebote por software y utilizando el systick para medir los tiempos necesarios. Es conveniente armar el
sistema completo para luego poder desarrollar el punto pedido.
1. Se pide elaborar un sistema que al recibir por UART (115200, 8N1) el valor de la entrada
analógica de la placa 1 cambie la intensidad del brillo del LED de la placa 2 y esta última deberá
enviarle por UART a la placa 1 el porcentaje de brillo que deberá ser visualizado por algún
método (leds, display 7 segmentos, display LCD…).
Visto: __________________
2 de 8
Condiciones
En grupos de 3 o 4 alumnos deberán realizar el sigu íente trabajo, la entrega del informe se realizará
individualmente en formato digital por la plataforma TEAMS o por el Campus Virtual según sea habilitado.
Materiales
Para el ejercicio se usará, además de las placas de desarrollo Raspberry Pi Pico y/o Raspberry Pi Pico W,
LED's, presets o potenciómetros, pulsadores, resistencias necesarias y un protoboard donde conectar todo.
Informe
Para la entrega del informe (en formato electrónico) se pide:
• Archivo editado con la carátula debidamente completada con los integrantes del grupo.
• Foto o escaneo de esta hoja firmada con el visto del docente cuando corrobora que lo implementado
funciona como se pidió.
• Un diagrama o circuito eléctrico del armado donde se especifiquen valores de componentes y
terminales utilizados en las placas de desarrollo.
• El código implementado para la solución y una breve descripción de lo que hace cada parte.
Enunciado
El siguiente puntos debe estar resuelto aplicando, cuando sea pertinente, interrupciones de GPIO, demora
anti-rebote por software y utilizando el systick para medir los tiempos necesarios. Es conveniente armar el
sistema completo para luego poder desarrollar el punto pedido.
l. Se pide elaborar un sistema que al recibir por UART (115200, SN 1) el valor de la entrada
analógica de la placa 1 cambie la intensidad del brillo del LED de la placa 2 y esta última deberá
enviarle por UART a la placa 1 el porcentaje de brillo que deberá ser visualizado p r algún
método (leds, display 7 segmentos, display LCD ... ).
2 de 5
Esquema eléctrico
3 de 8
Código:
Pico 1:
#include <stdio.h>
#include "pico/stdlib.h"
#include "stdlib.h"
#include "systick.h"
#include "hardware/adc.h"
#include "hardware/pwm.h"
#include "hardware/uart.h"
#include "string.h"
#define lcd_rs_pin 16 // Declaracion de constantes
#define lcd_en_pin 17
#define lcd_d4_pin 18
#define lcd_d5_pin 19
#define lcd_d6_pin 20
#define lcd_d7_pin 21
#define pot_pin 26
#define led_pwm 25
#define ADC_CH0 0
#define cant_muestras 5
#define UART_ID uart0
#define BAUD_RATE 115200
#define UART_TX_PIN 0
#define UART_RX_PIN 1
uint32_t frec_adc; // Declaracion de Variables
uint32_t frec_lcd;
uint32_t frec_uart;
uint16_t resu_adc = 0;
uint16_t cont_muestras = 0;
uint16_t cuentas = 0;
uint8_t dato_rx[] = {0,0,0};
uint8_t dato_tx[] = {'I',0,0,'F'};
uint16_t dato_16 = 0;
char cuentas_char[10] ={0};
void lcd_port(int a); // Funciones para el manejo del LCD 20x2 a 4 bit
void lcd_cmd(int com);
void lcd_putchar(char a);
void lcd_putstr(char a[]);
void lcd_move_to(int col, int row);
int escalado(int a);
int main(){
gpio_init(lcd_rs_pin); // Configura los pines para el manejo del LCD
gpio_set_dir(lcd_rs_pin, GPIO_OUT);
gpio_init(lcd_en_pin);
gpio_set_dir(lcd_en_pin, GPIO_OUT);
gpio_init(lcd_d4_pin);
gpio_set_dir(lcd_d4_pin, GPIO_OUT);
gpio_init(lcd_d5_pin);
gpio_set_dir(lcd_d5_pin, GPIO_OUT);
gpio_init(lcd_d6_pin);
gpio_set_dir(lcd_d6_pin, GPIO_OUT);
gpio_init(lcd_d7_pin);
gpio_set_dir(lcd_d7_pin, GPIO_OUT);
stdio_init_all(); // Inicializa librerias
init_systick();
adc_init(); // Inicializa el Puerto ADC
adc_gpio_init(pot_pin);
adc_select_input(ADC_CH0);
uart_init(UART_ID, BAUD_RATE); // Inicializa el puerto UART en 115200 8N1
uart_set_hw_flow(UART_ID, false, false);
uart_set_format(UART_ID, 8, 1, UART_PARITY_NONE);
gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);
frec_adc = get_systick(); // Asigna valores de systick para definir el periodo de ejecicion de cada funcion
frec_lcd = get_systick();
frec_uart = get_systick();
4 de 8
lcd_port(0x00); // Inicializa el LCD
sleep_us(20000);
lcd_cmd(0x03);
sleep_us(5000);
lcd_cmd(0x03);
sleep_us(11000);
lcd_cmd(0x03);
lcd_cmd(0x02);
lcd_cmd(0x02);
lcd_cmd(0x08);
lcd_cmd(0x00);
lcd_cmd(0x0C);
lcd_cmd(0x00);
lcd_cmd(0x06);
lcd_cmd(0x00);
lcd_cmd(0x01);
sleep_us(5000);
lcd_putstr("Intensidad:");
while(1){
if(frec_adc <= get_systick()){ // Lee el valor del ADC cada 5 ms
frec_adc += 5;
resu_adc = resu_adc + adc_read();
cont_muestras++;
if(cont_muestras == cant_muestras){ // Filtro del valor ADC. toma 5 valores y los promedia
resu_adc = resu_adc / cant_muestras;
cuentas = resu_adc;
resu_adc = 0;
cont_muestras = 0;
}
}
if(frec_uart <= get_systick()){ // Genera TX y RX del UART cada 10 ms
frec_uart += 10;
dato_tx[1] = cuentas & 0x00ff; // Pasa el Valor de la variable Cuentas de 16 bit al vector
dato_tx[2] = (cuentas & 0xff00) >> 8; // dato_tx a 2 valores de 8 bit
for(int i = 0; i <=3; i++){
uart_putc(UART_ID,dato_tx[i]); // Envia el vector por la UART
}
//printf("Inicio = %c, Dato tx 1 = %i, Dato tx 2 = %i, Fin = %c \r\n",dato_tx[0], dato_tx[1], dato_tx[2], dato_tx[3]);
if(uart_is_readable(UART_ID)){ // si existen datos en Buffer lee UART
dato_rx[0] = uart_getc(UART_ID);
if(dato_rx[0] == 'I'){ // Si el dato leido es I lee datos restantes
dato_rx[1] = uart_getc(UART_ID);
dato_rx[2] = uart_getc(UART_ID);
dato_rx[3] = uart_getc(UART_ID);
if(dato_rx[3] == 'F'){
dato_16 = (dato_rx[2] << 8) | dato_rx[1];
printf("Inicio = %c, Dato tx 1 = %i, Dato tx 2 = %i, Fin = %c, Dato 16 = %i, \r\n",dato_tx[0], dato_tx[1], dato_tx[2], dato_tx[3],
dato_16);
}
}
}
if(frec_lcd <= get_systick()){ // Actualiza el LCD cada 100 ms Con el Valor recibido de la UART
frec_lcd += 100;
lcd_putstr(" ");
lcd_move_to(11,0);
utoa(escalado(dato_16),cuentas_char,10);
lcd_putstr(cuentas_char);
lcd_putchar('%');
lcd_move_to(11,0);
5 de 8
}
}
}
/* Funciones para el manejo de datos con el LCD*/
void lcd_port(int a){ // Maneja el puerto con el dato a enviar al LCD
if(a & 1){
gpio_put(lcd_d4_pin,true);
}else{
gpio_put(lcd_d4_pin,false);
}
if(a & 2){
gpio_put(lcd_d5_pin,true);
}else{
gpio_put(lcd_d5_pin,false);
}
if(a & 4){
gpio_put(lcd_d6_pin,true);
}else{
gpio_put(lcd_d6_pin,false);
}
if(a & 8){
gpio_put(lcd_d7_pin,true);
}else{
gpio_put(lcd_d7_pin,false);
}
return;
}
void lcd_cmd(int com){ // Maneja el PIN RS del LCD
gpio_put(lcd_rs_pin,false);
lcd_port(com);
gpio_put(lcd_en_pin,true);
sleep_us(4000);
gpio_put(lcd_en_pin,false);
return;
}
void lcd_putchar(char a){ // Funcion para enviar un caracter al LCD
//printf("%i\r\n",a);
int temp = a & 0x0f;
int y = a & 0xf0;
gpio_put(lcd_rs_pin,true);
y = y >> 4;
lcd_port(y);
gpio_put(lcd_en_pin,true);
sleep_us(40);
gpio_put(lcd_en_pin,false);
lcd_port(temp);
gpio_put(lcd_en_pin,true);
sleep_us(40);
gpio_put(lcd_en_pin,false);
sleep_us(40);
return;
}
void lcd_putstr(char a[]){ // Funcion para enviar una cadena al LCD
int i=0;
while(a[i] != '\0'){
lcd_putchar(a[i]);
i++;
}
return;
}
void lcd_move_to(int col, int row){ // Funcion para posicionar el cursor en el LCD
if (row == 0){
6 de 8
int temp = 0x80 + col;
int z = temp >> 4;
int y = temp & 0x0f;
lcd_cmd(z);
lcd_cmd(y);
} else if ( row == 1){
int temp = 0xc0 + col;
int z = temp >> 4;
int y = temp & 0x0f;
lcd_cmd(z);
lcd_cmd(y);
}
return;
}
int escalado(int a){ // Funcion para el escalado del recibido del UART a % para mostrar en el LCD
float result = 0.02456;
int salida;
result = a * result;
salida = result;
return salida;
Pico 2:
#include <stdio.h>
#include "pico/stdlib.h"
#include "stdlib.h"
#include "systick.h"
#include "hardware/uart.h"
#include "hardware/pwm.h"
#include "string.h"
#define led_pwm 25 // Declaracion de constantes
#define UART_ID uart0
#define BAUD_RATE 115200
#define UART_TX_PIN 0
#define UART_RX_PIN 1
uint32_t frec_uart; // Declaracion de Variables
uint8_t dato_rx[4] = {0,0,0,0};
uint16_t dato_16;
int main(){
stdio_init_all(); // Inicializa librerias
init_systick();
uart_init(UART_ID, BAUD_RATE); // Inicializa el UART
uart_set_hw_flow(UART_ID, false, false);
uart_set_format(UART_ID, 8, 1, UART_PARITY_NONE);
gpio_set_function(led_pwm,GPIO_FUNC_PWM);
uint slice = pwm_gpio_to_slice_num(led_pwm);
uint chan = pwm_gpio_to_channel(led_pwm);
pwm_set_clkdiv_int_frac(slice,15,4);
pwm_set_wrap(slice,4095);
pwm_set_enabled(slice,true);
gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART);
gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART);
frec_uart = get_systick();
while(1){
if(frec_uart <= get_systick()){ // Envia cada 10 ms datos por UART
frec_uart += 10;
7 de 8
for(int i = 0; i <=3; i++){
uart_putc(UART_ID,dato_rx[i]); // Envia el vector por la UART
}
if(uart_is_readable(UART_ID)){ // si existen datos en Buffer lee UART
dato_rx[0] = uart_getc(UART_ID);
if(dato_rx[0] == 'I'){ // Si el dato leido es I, lee datos restantes
dato_rx[1] = uart_getc(UART_ID);
dato_rx[2] = uart_getc(UART_ID);
dato_rx[3] = uart_getc(UART_ID);
if(dato_rx[3] == 'F'){ // Si el último dato Leído es F, considera la cadena como valida y realiza conversión
dato_16 = (dato_rx[2] << 8) | dato_rx[1];
pwm_set_chan_level(slice,chan,(uint16_t)dato_16);
//printf("Dato 0 = %c, Dato 1 = %i, Dato 2 = %i, Dato 3 = %c, Dato_16 = %i
\r\n",dato_rx[0],dato_rx[1],dato_rx[2],dato_rx[3],dato_16);
}
}
}
}
8 de 8
