• STM SPI UART
• Arduino SPI

• Antes de conectar las tarjetas de desarrollo y sus pines a un circuito externo (especialmente señales que entran a la tarjeta de desarrollo) las tarjetas de desarrollo deben haber sido programadas al menos una vez inicialmente antes de ser conectado a dicho circuito.

1. Lea completamente todos los pasos de la guía de esta actividad
2. Anote, responda y agregue al reporte todas las preguntas e instrucciones que se realicen en la guía. Dichas preguntas e instrucciones se pueden denotar al estar enumeradas con el siguiente formato: “1) Anote el puerto asignado a su dispositivo Arduino”
3. Debe realizar una descripción de lo logrado a lo largo de la actividad, incluyendo las dificultades que se presentaron. Una bitácora de lo sucedido es lo mejor. (Anote no solo lo que usted ejecutó sino también el resultado de lo que ejecuta)
4. El reporte debe ser entregado mediante correo electrónico al asistente con copia al profesor del curso mediante correo electrónico. Debe utilizar formato PDF.
5. El correo electrónico del reporte debe llevar el siguiente formato en el “subject”: “IE0624 - Reporte N”, donde N es el número de la actividad realizada.

El reporte debe incluir las siguientes secciones (se incluye el porcentaje de nota de cada sección)

1. Portada (curso, semestre, año, fecha, número y nombre de práctica, integrantes). 2%
2. Bitácora de trabajo describiendo el resultado de todos los pasos seguidos de la guía incluyendo dificultades y/o situaciones inesperadas. 30%
3. Capturas o fotografías de puntos importantes realizadas durante la actividad (el circuito ensamblado, resultados observables en el osciloscopio, etc) 20%
4. Respuestas al cuestionario de la guía. 20% (deben estar claramente identificadas con el número de pregunta, sin confundirse con otra numeración en el reporte)
5. Todo el código fuente de todos los programas utilizados a lo largo de la actividad. Debe agregar al inicio del código una descripción sobre dicho código (a qué parte de la práctica corresponde, la función que cumple dicho código). 20%
6. Referencias utilizadas en caso de acceder a alguna fuente de información de Internet o bibliográfica durante la realización de la actividad. 8%

La libraría integrada de funciones de arduino contiene funciones de conveniencia para la comunicación utilizando el puerto SPI.

Los pasos de las primeras actividades del curso hicieron uso del programa arduino que es parte de los repositorios oficiales de la distribución de Linux: Debian GNU/Linux. El problema es que la versión que se encuentra en el repositorio de Debian es muy antigua (versión 1.0.5) la cual contiene funciones para utilizar el puerto SPI obsoletas.

Necesitamos instalar una versión más actualizada de Arduino. Por ejemplo, la versión 1.8.3. Pero primero es recomendable actualizar el sistema operativo Debian a su última versión Debian Unstable para evitar posibles problemas de incompatibilidad de librerías con Arduino.

• Siga la guía para la “Actualización al sistema debian unstable (sid)” disponible aquí. Solo debe seguir la sección para actualizar a debian unstable.

• Descargue la última versión de Arduino (para Linux de 64bits) desde aquí: https://www.arduino.cc/en/Main/Software
• Descargue el archivo en el directorio “~/local/src”
• Descomprima dicho archivo:

cd ~/local/src
tar -xzf arduino-1.8.3-linux64.tar.xz

• Para ejecutar arduino, siempre desde una nueva consola, debe realizar los siguientes pasos:

cd ~/local/src/arduino-1.8.3/
./arduino

• Si no lo realiza de esta forma estará ejecutando el arduino antiguo. Siempre corrobore la versión que se encuentra ejecutando observando la barra superior de la aplicación gráfica de arduino.

• Programe y cargue el siguiente programa en el Arduino:

#include <SPI.h>
#include <avr/pgmspace.h>

const int CSpin = 10;
const int DCpin = 2;

void setup() {
  Serial.begin(9600);

  // start the SPI library:
  SPI.begin();
  SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  // initalize the  data ready and chip select pins:
  pinMode(CSpin, OUTPUT);
  pinMode(DCpin, OUTPUT);
  digitalWrite(CSpin, HIGH);
  digitalWrite(DCpin, HIGH);
  delay(10);
  sendCmd(0xAF); //Display ON
  delay(10);
  sendCmd(0xA5); //All display ON
  delay(10);
  sendCmd(0x81); //Set contrast
  delay(10);
  sendCmd(0xFF); // Contrast
  delay(10);
  sendCmd(0xA4); //All display from mem
  delay(10);
  sendCmd(0x20); //Horizontal Addressing mode
  delay(100);
  sendCmd(0x00); //Horizontal Addressing mode
  delay(100);
  sendCmd(0x21); //Set col address
  delay(100);
  sendCmd(0x00); //Start col
  delay(100);
  sendCmd(0x7F); //End col
  delay(100);
  sendCmd(0x22); //Set page address
  delay(100);
  sendCmd(0x00); // Page start address
  delay(100);
  sendCmd(0x07); // Page end address
  delay(100);
  sendCmd(0x40); // Set display start line
  delay(100);
  sendCmd(0xA1); // Set segment remap
  delay(100);
  blankScreen();
}

const PROGMEM uint8_t I[] = { 0b00000000,
                             0b00000000,
                             0b01000010,
                             0b01111110,
                             0b01000010,
                             0b00000000,
                             };

const PROGMEM uint8_t E[] = { 0b00000000,
                             0b01000010,
                             0b01000010,
                             0b01011010,
                             0b01011010,
                             0b01111110,
                             };

const PROGMEM uint8_t space[] = { 0b00000000,
                                 0b00000000,
                                 0b00000000,
                                 0b00000000,
                                 0b00000000,
                                 0b00000000,
                                 };

const PROGMEM uint8_t love[] = { 0b00000000,
                                0b00111000,
                                0b01000100,
                                0b00100010,
                                0b01000100,
                                0b00111000,
                                };

uint8_t temp;
int col=0;

void printLetter(const uint8_t* letter) {
  for (int i=6; i>=0; i--){
    temp=pgm_read_word_near(letter+i);
    sendData(temp);
    col++;
  }
}

const uint8_t* letters[]={love, space, E, I, E, space, love, space};

void loop() {
    Serial.print("test\n");
      delay(10);
      //sendData(0b00010001);
      int i=0;
      while (col<(128-6)) {
            printLetter(letters[i]);
            i++;
            if (i>7) {
               i=0;
            }
      }
      for (int j=0;j<(128-col); j++) {
          sendData(0x00);
      }
      col=0;
}

void sendData(byte data) {
    digitalWrite(CSpin, LOW);
    digitalWrite(DCpin, HIGH);
    SPI.transfer(data);
    digitalWrite(DCpin, HIGH);
    digitalWrite(CSpin, HIGH);
}

void sendCmd(byte cmd) {
    digitalWrite(CSpin, LOW);
    digitalWrite(DCpin, LOW);
    SPI.transfer(cmd);
    digitalWrite(DCpin, HIGH);
    digitalWrite(CSpin, HIGH);
}

void blankScreen() {
   for (int i=0; i<1024; i++){
      //delay(10);
      sendData(0x00);
   }
}

• Apague el arduino
• Utilizando una la protoboard conecte el arduino y el módulo OLED de la siguiente manera:

• Encienda el Arduino y compruebe que la pantalla OLED despliega “<3 EIE <3 <3 EIE <3 <3 ”
• Modifique el programa para desplegar el siguiente texto: “Lu RZ ” (Labo micros Rulez). 1) Mencione las modificaciones realizadas al programa para lograr esto.
• Modifique la línea:

  sendCmd(0xFF); // Contrast

Así:

  sendCmd(0x7F); // Contrast

• 2) Describa lo que sucede
• 3) Qué indica el número “7” de la línea: ?

            if (i>7) {

• 4) Para qué sirve la función pgm_read_word_near() ?
• 5) En qué tipo de memoria del microprocesador Arduino se están almacenando los “pixeles” de las letras o símbolos?
• 6) Cuál es la resolución en pixeles de cada símbolo gráfico en este programa?
• 7) Explique la función de cada pin (desde la perspectiva del puerto de comunicación SPI) que está siendo conectado entre el Arduino y el OLED.

• En el repositorio que en la práctica anterior usted descargó (libopencm3-examples) diríjase al ejemplo adc (para stm32f3discovery). Compile y cargue dicho ejemplo en el STM32.
• Alambre una resistencia variable de la siguiente forma:

TBA

http://libopencm3.org/

https://github.com/libopencm3/libopencm3/wiki/Datasheets

https://github.com/libopencm3/libopencm3-examples