MICROPROCESADORES I

Informe de Practica de Laboratorio Nº 7

COMUNICACIÓN SPI

Grupo “A”

Integrantes del grupo: Rodrigo Coria

Docente:
Ariel Quezada Castro

Cochabamba 16 de Noviembre de 2021

Gestión II– 2021
1. OBJETIVOS

Objetivo General

-Configurar los microcontroladores para funcionar como maestro y como esclavo

Objetivos Específicos

-Leer el valor del potenciómetro del microcontrolador maestro y enviarlo al esclavo

- Visualizar el valor del potenciómetro en el Display LCD del esclavo

-Visualizar el dato obtenido por el puerto serial

2. MARCO TEORICO

La comunicación I2C consiste en un intercambio de información entre dos partes, un

maestro y un ( o muchos) esclavo mediante un bus de datos, La principal diferencia
entre este tipo de comunicación u la serial es el uso de una misma señal de generados
para la sincronización entre los dispositivos, el canal SCL, los cual permite una
comunicación síncrona. Además del canal de reloj se utiliza el canal de transmisión de
datos llamado SDA. EL protocolo de comunicación sigue una serie de pasos:

 Iniciar la comunicación – S
 Enviar 7 bits de dirección – ADDR
 Generar 1 bit de Lectura ó Escritura – R/W
 Enviar 8 bits de dirección de memoria
 Transmitir 8 bits de datos –
 Confirmar la recepción de datos – ACK – ACK nowledged
 Generar confirmación de No-recepción, NACK – No-ACK nowledged
 Finalizar la comunicación

Estos pasos son seguidos por el maestro debido a que este es el único con la capacidad de
generar la señal de reloj para realizar la transmisión de datos.

3. ENUNCIADO

Configurar uno de los microcontroladores como maestro y el otro como esclavo SPI
(usar el modo 3). El maestro realiza la lectura de un voltaje analógico (en un
potenciómetro) y envía éste valor por el puerto SPI. El esclavo recibe el valor enviado
desde el maestro SPI y muestra el valor en un LCD y también lo envía por el puerto
serial para que se visualice en un terminal serial.

4. DISEÑO

Parte 1 - Master

#include <avr/io.h>
#define F_CPU 16000000UL
#include <util/delay.h>
#include <stdlib.h>
#define MOSI 3
#define SCK 5
#define SS 2

void sendchar(unsigned char caracter);

void sendstring(char*cadena);

int main(void)
{
uint8_t valorH,valorL=0;
DDRB= (1<<MOSI)| (1<<SS)|(1<<SCK);
SPCR= (1<<SPE) | (1<<MSTR) | (1<<SPR1) | (1<<SPR0);
ADMUX=0b01000000;
ADCSRA=0b10000111;
DIDR0=0b00000011;

while (1)
{

ADMUX=0b01000000;
ADCSRA|=(1<<ADSC);
while((ADCSRA & (1<<ADIF))==0);
valorL=ADCL;
valorH=ADCH;
SPDR=valorH;
while(!(SPSR & (1<<SPIF)));
valorH=SPDR;
_delay_ms(100);
SPDR=valorL;
while(!(SPSR & (1<<SPIF)));
valorL=SPDR;
_delay_ms(100);
}
}

Parte 2 - Slave

#include <avr/io.h>
#include <stdlib.h>
#include <util/delay.h>
#define F_CPU 16000000UL

#define LCD_DPRT PORTD

#define LCD_DDDR DDRD
#define LCD_DPIN PIND
#define LCD_D4 PD4
#define LCD_D5 PD5
#define LCD_D6 PD6
#define LCD_D7 PD7
#define LCD_CPRT PORTD
#define LCD_CDDR DDRD
#define LCD_CPIN PIND
#define LCD_RS PD2
#define LCD_EN PD3

void lcdWrite4(uint8_t);
void lcdCommand(uint8_t cmd);
void lcdData(uint8_t);
void lcdInit (void);
void lcdGotoxy(uint8_t x, uint8_t);
void lcdPrint(char * str);
void resetear_lcd(void);

void sendchar(unsigned char caracter);

void sendstring(char*cadena);

int main(void)
{

uint8_t ADL,ADH=0;
uint16_t AD=0;
char txt[4];
DDRB=(1<<4);
SPCR=(1<<SPE);

UCSR0A=0b00000010;
UCSR0B=0b00001000;
UCSR0C=0b00000110;
UBRR0=207;
lcdInit();
lcdCommand(0x0C);
lcdCommand(0x80);
lcdPrint("ADC: ");
lcdCommand(0xC0);
lcdPrint("LAB 7");

while (1)
{

SPDR=0;
while(!(SPSR & (1<<SPIF)));
ADH=SPDR;
SPDR=0;
while(!(SPSR & (1<<SPIF)));
ADL=SPDR;
AD=(ADH<<8) | (ADL);
while(!(UCSR0A & (1<<5)));
UDR0=13;
sendstring(itoa(AD,txt,10));
while(!(UCSR0A & (1<<5)));
UDR0=13;
lcdCommand(0x86);
lcdPrint(itoa(AD,txt,10));
 if (AD<10)
{
lcdCommand(0x87);
lcdPrint(" ");
}
if (AD<100 && AD>=10)
{
lcdCommand(0x88);
lcdPrint(" ");
}
if (AD<1000 && AD>100)
{
lcdCommand(0x89);
lcdPrint(" ");
}
_delay_ms(500);
}
}
void resetear_lcd()
{
for (int i=0; i<=20; i++)
{
lcdGotoxy(0+i,0);
lcdPrint(" ");
lcdGotoxy(0+i,1);
lcdPrint(" ");
}
}

void lcdWrite4(uint8_t dato)

{
LCD_DPRT = (LCD_DPRT & 0x0F) | (dato & 0xF0);
LCD_CPRT |= (1<<LCD_EN);
_delay_us (1);
LCD_CPRT &= ~(1<<LCD_EN);
}

void lcdCommand (uint8_t cmd ) //OJO solo parte del puerto es del LCD.
{
LCD_CPRT &= ~(1<<LCD_RS);
lcdWrite4(cmd);
_delay_us(100);
lcdWrite4(cmd << 4);
_delay_us(100);
}

void lcdData (uint8_t data)

{
LCD_CPRT |= (1<<LCD_RS);
lcdWrite4(data);
_delay_us (100);
lcdWrite4(data << 4);
_delay_us (100);
}

void lcdGotoxy (uint8_t x, uint8_t y)

{
uint8_t firstCharAdr [] = {0x80, 0xC0, 0x94,0xD4};
lcdCommand (firstCharAdr[y] + x);
_delay_us(100);
}
void lcdPrint(char * str)
{
uint8_t i = 0;
while(str[i] !=0)
{
lcdData(str[i]);
i++;
}
}

void lcdInit(void)
{
LCD_DDDR |= (1<<LCD_D4) | (1<<LCD_D5) | (1<<LCD_D6) | (1<<LCD_D7);
LCD_CDDR |= (1<<LCD_RS) | (1<<LCD_EN);
_delay_ms(50);
LCD_CPRT &= ~(1<<LCD_EN);
LCD_CPRT &= ~(1<<LCD_RS);
lcdWrite4(0x30);
_delay_ms(5);
lcdWrite4(0x30);
_delay_us(100);
lcdWrite4(0x30);
_delay_us(100);
lcdWrite4(0x20);
_delay_ms(100);
lcdCommand(0x28);
lcdCommand(0x0E);
lcdCommand(0x01);
_delay_ms(2);
lcdCommand(0x06);
}

void sendchar(unsigned char caracter)

{
while(!(UCSR0A & (1<<5)));
UDR0 = caracter;

}
void sendstring(char*cadena)
{
while(*cadena!=0x00)
{
sendchar(*cadena);
cadena++;

}
}

5. SIMULACIÓN
6. CUESTIONARIO

 Explique el funcionamiento de la comunicación SPI

La comunicación funciona conectando dos dispositivos y asignándoles los roles

de maestro y esclavo. El maestro es el encargado de iniciar la comunicación y
transmisión de datos siguiendo los debidos protocolos mientras que el esclavo
se encarga de recibir la información ara seguir su programa cargado siendo
 incapaz de iniciar la comunicación. Para la transmisión de datos se sigue un
protocolo en donde se transmite un bus de datos en donde se encuentra el
protocolo de comunicación seguido de la transmisión de datos.

 Explique la configuración del puerto SPI en el microcontrolador como maestro y

como esclavo

Para la configuración de los microcontroladores se conectan los canales

MOSI( Master output-Slave input, el canal que envia la información del maestro
al esclavo), MISO (Master input-Slave output, el canal que envia la información
del esclavo hacia el maestro), SCK( el canal que genera la señal de reloj para la
sincronización de microcontroladores) y el canal SS(Slave Select, en donde se
habilita el esclavo con el que se quiere comunicar en ese momento)

7. CONCLUSIONES
Se pudo realizar la comunicación entre el maestro y el esclavo permitiendo apreciar
algunas de las ventajas de esta comunicación como es la separación de funciones en
donde a cada microcontrolador se le asigno funciones especificas al igual que se
pudo entender la conexión entre los dispositivos para un mejor entendimiento de
los pines de comunicación.