jueves, 26 de enero de 2017

INTRODUCCIÓN A RENESAS RX62N

Antes de comenzar con el listado de prácticas se hará una breve descripción de lo que es la tecnología RX de Renesas.

Renesas empresa líder en microcontroladores de 32 bits que trajo al mercado en el 2011 la familia RX200 y RX600. Una tecnología de microcontroladores que posee una arquitectura RISC de 32 bits y todo un repertorio de periféricos de comunicaciones. En la figura 1 se muestra las diferentes familias de MCU dando lugar al RX con aplicaciones directas tanto al consumo como a la industria, ejemplo de ello están diseñados para electrodomésticos, equipos médicos, automatización, iluminación, comunicaciones, electrónica en general, etc.

Figura 1. Familias de MCU Renesas


Los elementos generales que conforman el RX se muestra en la figura 2. Es un MCU que corre a 100 Mhz y que nos ofrece un performance de 165 DMIPS. De ese core existen varios grupos como RX100, RX200, RX600, RX700 para diversas aplicaciones y configuraciones de memoria, periféricos, I/O, empaquetados, etc.
Figura 2. 


Toda la información técnica sobre la familia RX se encuentra disponible en la página oficial de Renesas. Es recomendable registrarse para así bajar no solo la documentación sino los programas, compiladores, programadores, etc que se necesitaran para poder usar el MCU.

Página de Renesas/RX:


Para poder iniciarse en estas tecnologías también recomiendo el siguiente libro:



En la siguiente entrada describiremos las diversas herramientas, tarjetas, documentación y programas que necesitamos para iniciarnos en este largo y entretenido camino hacia la conquista del RX62N.

miércoles, 25 de enero de 2017

HERRAMIENTAS Y DOCUMENTACIÓN NECESARIA ANTES DE COMENZAR

Antes de comenzar con las prácticas del RX62N es necesario tener las siguientes herramientas y documentación. Si existen versiones superiores de preferencia utilizarlas.

HARDWARE:
  • Tarjeta de demostración YRDKRX62N



SOFTWARE:
  • e² studio 5.2 installer (Web installer)

  • RX Compiler CC-RX_V20500_setup 

  • Peripheral Driver Generator v2.0

  •  Comm Operator (cualquier versión). O también otro SW de Hypeterminal serial


DOCUMENTACIÓN:

  •  R20UT2531EU0100
Renesas RX62N RDK User's Manual
https://www.renesas.com/en-us/doc/products/tools/r20ut2531eu0100_yrdkrx62n_um.pdf
  •  YRDKRX62N schematic
http://webpages.uncc.edu/~jmconrad/ECGR4101-2012-08/notes/YRDKRX62N_3_SCH.pdf
  •  R01UH0186EJ0330
RX62N Group User's Manual: Hardware
https://www.renesas.com/en-us/doc/products/mpumcu/doc/rx_family/r01uh0033ej0140_rx62n.pdf?key=94afe9caf9149a539a1b5b692b58232c 

martes, 24 de enero de 2017

PRACTICA # 1 I/O, LEDS Y SWITCH

OBJETIVO: 
Se configurará el oscilador externo de 12 Mhz para generar 96 Mhz con la que cuenta el MCU R5F562N8 de la tarjeta de evaluación YRDKRX62N. Por medio del Switch 1 activaremos el LED 8.
  • 1. Configurar el Oscilador externo para generar 96 Mhz
  • 2. Configurar las entradas y salidas del R5F562N8
  • 3. Encender un led a través de un switch
  • 4. Debug 


DESARROLLO:
Del manual Renesas RX62N RDK User's Manual ubicamos el LED 8 y el SWITCH 1:


PASOS:
  •  Creación de un proyecto:
1.- Abrir el software e2studio
2.- New/ C Project



3.- Seleccionar Renesas RXC ToolChain después en Next >



4.- Seleccionar el target R5F562N8, debug hardware Segger jLink, después next


5.- Seleccionar C/C++ Source file y por ultimo Finish.



Entorno de desarrollo e2studio configurado:


6.- Configuraremos el oscilador externo:
void SR_Oscilador(void)
{
SYSTEM.SCKCR.BIT.ICK = 0x00;  // ICLK = EXTAL * 8 (96MHz)
SYSTEM.SCKCR.BIT.PSTOP0 = 1;  // Disable SDCLK
SYSTEM.SCKCR.BIT.PSTOP1 = 1;  // Disable BCLK
SYSTEM.SCKCR.BIT.PCK = 0x01;  // PCLK = EXTAL*4 (48MHz)
}

7.- El programa principal queda de la siguiente forma:

void main(void)
{
            set_ipl( 0 ); // enable interrupts
            SR_Oscilador();
            SR_INIT_PORTS();

            while(1)
            {
                        if (SW1 == 1)
                        {
                              LED1 = OFF_;
                        }
                        else
                        {
                              LED1 = ON_;
                        }
            }
}
  •  Agregar código, compilar y debug:
1.- Bajar el código de:

2.- Compilar con el icono del martillo y debug con el icono del insecto:

3.- Correr el programa con el icono start:



VÍDEO:

lunes, 23 de enero de 2017

PRACTICA # 2 TIMER 0 y 1 (Cascada a 16 bits)

OBJETIVO:
Se configurará el Timer 0 y el Timer 1 en cascada para generar uno de 16 bits con la que cuenta el MCU R5F562N8 de la tarjeta de evaluación YRDKRX62N. Este nuevo Timer de 16 bits lo utilizaremos para generar funciones de retardo de tiempo como delay_100us y delay_ms por medio de su interrupción.
  •  Configurar el Timer 0 y Timer 1 ambos de 8 bits a uno de 16 bits 
  •  Crear interrupción overflow de timer TMR0 CMIA0
  •  Parpadear un Led cada segundo utilizando las funciones delay_ms

DESARROLLO:
Del manual Renesas RX62N RDK User's Manual ubicamos el LED 8



PASOS:
  •  Creación de un proyecto:
1.- Abrir el software e2studio
2.- New/ C Project / Renesas RXC ToolChain



3.- Seleccionar el target R5F562N8, debug hardware Segger jLink, después next


4.- Seleccionar C/C++ Source file y por ultimo Finish.



5.- Configuraremos Timer 0 y 1 en cascada de 16 bits e iniciamos interrupción CMIA0 en el archivo delay.c:
void InitTimer_0_1(void)
{
         MSTP(TMR0) = 0; //Activate TMR0 unit
         MSTP(TMR1) = 0; //Activate TMR1 unit
         TMR1.TCCR.BIT.CSS = 1;
         TMR1.TCCR.BIT.CKS = 1;  //x = (1/48 Mhz)*(2)*(65535) = 2730.6 us  Count source is PCLK/2 for TMR1
         TMR0.TCCR.BIT.CSS = 3;  // 16-bit mode
         TMR0.TCCR.BIT.CKS = 0;

         TMR0.TCR.BIT.CCLR = 1;  //Count source is TMR1 for TMR0
         TMR0.TCR.BIT.CMIEA = 1; // Enable Interrupt on Compare Match A inside the peripheral module
         IR(TMR0,CMIA0)= 0;    // Clear IRQ if it was on for some reason
         IPR(TMR0,CMIA0)= 2;  // IRQ priority for TMR0.CMIA0 = 2
         IEN(TMR0,CMIA0)= 1; // Enable TMR0.CMIA0 IRQ in the Interrupt Control Unit

         //65535  ---  2730.6 us
         //   T   ---  100 us
         //T = 2400
         TMR01.TCORA = 2400;
         //TMR0.TCORA = 9;    // high 8 bits
         //TMR1.TCORA = 96;    // low 8 bits
}

void Timer_0_1_Start(void)
{
IR(TMR0,CMIA0) = 0;    // Clear IRQ if it was on for some reason
         IEN(TMR0,CMIA0) = 1;  // Enable TMR0.CMIA0 IRQ in the Interrupt Control Unit
}


6.- Agregaremos el siguiente código a la interrupción que está en el archivo interrupt_handlers.c
// TMR0 CMIA0
void Excep_TMR0_CMIA0(void)
{
         G_100usTimer++;
                   if((G_100usTimer % 10) == 0)
                             G_msTimer++;
}


  •  Agregar código, compilar y debug:
1.- Bajar el código de:

2.- Compilar con el icono del martillo y debug con el icono del insecto:


VÍDEO:

domingo, 22 de enero de 2017

PRACTICA # 3 UART


OBJETIVO:
          Se hará uso del módulo del puerto serial UART2 con el que cuenta el MCU R5F562N8 de la tarjeta de evaluación YRDKRX62N. Se le enviara un dato de 8 bits por medio de una hypeterminal serial, el MCU la recibe en su interrupción y ese mismo dato de 8 bits lo reenvía de regreso a la hypeterminal.
  •  Configurar la unidad UART2
  •  Habilitar ambas interrupciones (Send – Receive)
  •  Hacer Eco del dato recibido

DESARROLLO:
Del manual Renesas RX62N RDK User's Manual ubicamos los pines del UART2:

  • Para poder utilizar el conversor USB-SERIAL necesitamos soldar 3 cables a la tarjeta YRDKRX62N (ya que no se dispone de un socket para estas señales). Los cuales irán a TXD2, RXD2 y GND de la figura página 1 del documento YRDKRX62N schematic.pdf

  •  La conexión con el USB-Serial será:
Conectamos TxD2 --> RxD, TxD --> RxD2 y GND --> GND


PASOS:

  •  Creación de un proyecto:
1.- Abrir el software e2studio
2.- New/ C Project / Renesas RXC ToolChain


3.- Seleccionar el target R5F562N8, debug hardware Segger jLink, después next


4.- Seleccionar C/C++ Source file y por ultimo Finish.


5.- Configuraremos el UART 2 por medio del módulo SCI2 a 9600 bps, 1 bit stop y no paridad en el archivo uart.c:

extern void sci2_init(void)
{
            MSTP(SCI2) = 0; /* Enable module */
            SCI2.SCR.BYTE = 0; /* Reset module */
            IOPORT.PFFSCI.BIT.SCI2S = 1; /* Remap pins to B set */

            PORT5.DDR.BIT.B2 = 0;        // P52 RxD2-B
            PORT5.ICR.BIT.B2 = 1;        // Input buffer enabled
            PORT5.DDR.BIT.B0 = 1;        // P50 TxD2-B

            SCI2.SCR.BIT.CKE = 0;   /* Use internal baudrate generator, SCK pin function os IO port */
            SCI2.SMR.BYTE = 0;      /* PCLK/1, 8N1, async mode, multiprocessor mode disabled */
            SCI2.SCMR.BIT.SMIF = 0; /* Not smart card mode */
            SCI2.SCMR.BIT.SINV = 0; /* No TDR inversion */
            SCI2.SCMR.BIT.SDIR = 0; /* LSB first */
            SCI2.SEMR.BIT.ACS0 = 0; /* Use external clock */
            SCI2.SEMR.BIT.ABCS = 0; /* 16 base clock cycles for 1 bit period */

            /* Set baudrate */
            /* For 16 base clock cycles change formula to PCLK / (32 * BAUD ) - 1 */
            /* For 8 base clock cycles change formula to PCLK / (16 * BAUD ) - 1 */
            // set for 9600BPS with pclk/1   -> n = 0
            // (48000000/64*(2^[(2*n)-1)]*9600)-1
            SCI2.BRR = PCLK_FREQUENCY / (32 * SCI2_BAUDRATE) - 1;

            /* Reset interrupt flags */
            IR(SCI2, TXI2)= 0;
            IR(SCI2, RXI2)= 0;

            /* Set priorities */
            IPR(SCI2, TXI2)= 3;  // highest = 15
            IPR(SCI2, RXI2)= 3;  // highest = 15

            /* Enable interrupts */
            IEN(SCI2, RXI2)= 1;   // Enable Interrupt RX
            IEN(SCI2, TXI2)= 1;   // Enable Interrupt TX

            SCI2.SCR.BYTE |= 0xF0; //enable tx/rx  NOTA: No se puede hacer funcionar el uart si se escriben los bits individuales de abajo ;(

            //SCI2.SCR.BIT.RIE = 1; /* Enable RX interrupt flag */
            //SCI2.SCR.BIT.TIE = 1; /* Enable TX interrupt flag */
            //SCI2.SCR.BIT.RE = 1; /* Enable receiver  */
            //SCI2.SCR.BIT.TE = 1; /* Enable transmitter */

}

6.- Agregaremos el siguiente código a las 2 interrupciónes que está en el archivo interrupt_handlers.c:

// SCI2 RXI2
unsigned char data_uart;
void Excep_SCI2_RXI2(void)
{
            data_uart = SCI2.RDR;
            SCI2.TDR = data_uart;
            IEN(SCI2, TXI2)= 1;   // Enable Interrupt TX2
}

// SCI2 TXI2
void Excep_SCI2_TXI2(void)
{
            IEN(SCI2, TXI2)= 0;   // Disable TX2 interrupt */
}

Como se puede observar lo que recibe data_uart en su interrupción de vector Excep_SCI2_RXI2 es cargado al registro SCI2.TDR y se habilita su interrupción TXI2 para que lo envié de regreso al puerto UART y así hacer eco de todo lo que se reciba.

  •  Agregar código, compilar y debug:
1.- Bajar el código de:

2.- Si el compilador llega a marcar un error como:

Ir a propiedades del proyecto y agregar BIntPRG_1 como se muestra en la siguiente imagen:



3.- Compilar con el icono del martillo y debug con el icono del insecto:


4.- Abrir Comm operator u alguna otra hypeterminal serial, configurarla a 9600 bps:



CONEXIÓN:

sábado, 21 de enero de 2017

PRACTICA # 4 LCD GRAFICA 96x64 (SPI)

OBJETIVO:
           Se creará el driver para la lcd grafica 96x64 con interfaz de comunicación RSPI. Se mostrará un mensaje de 7 líneas.
  •  Crear y configurar la unidad RSPI0
  •  Inicializar los pines de LCD-CS y LCD-RS
  •  Incluimos todos los archivos de la librería grafica en una carpeta

DESARROLLO:
  • Del manual Renesas RX62N RDK User's Manual ubicamos los pines del LCD:  

  •  Del YRDKRX62N schematic ubicamos el LCD okaya:


PASOS:
  •  Creación de un proyecto:
1.- Abrir el software e2studio
2.- New/ C Project / Renesas RXC ToolChain


3.- Seleccionar el target R5F562N8, debug hardware Segger jLink, después next


4.- Seleccionar C/C++ Source file y por ultimo Finish.


5.- Configuraremos el SPI por medio del módulo RSPI0 a 3 Mhz en el archivo r_cg_serial_SPI.c:

void R_RSPI0_Create(void)
{
            MSTP(RSPI0) = 0; //Enable SPI0

            //PORT C DDR
            PORTC.DDR.BIT.B5 = 1; //An output pin    RSPCK output
            PORTC.DDR.BIT.B6 = 1; //An output pin    MOSI output
            PORTC.DDR.BIT.B7 = 0; //An input pin     MISO = input
            PORTC.ICR.BIT.B7 = 1;

            // inicializa pines
            PORTC.DDR.BIT.B2 = 1; // como salida LCD-CS
            PORT5.DDR.BIT.B1 = 1; // como salida LCD-RS
            PORTC.DDR.BIT.B3 = 1; // como salida
            PORTC.DR.BIT.B3 = 0; // Pull RSTOUT# inverting buffer low so RSTOUT# goes high, releasing reset state.

            //PFGSPI register
            IOPORT.PFGSPI.BIT.RSPIS = 0; //PC as the SPI-A
            IOPORT.PFGSPI.BIT.RSPCKE = 1; //RSPCKA pin is enable
            IOPORT.PFGSPI.BIT.MOSIE = 1; //MOSIA pin is enable
            IOPORT.PFGSPI.BIT.MISOE = 1; //MISOA pin is enable
            IOPORT.PFGSPI.BIT.SSL0E = 0; //SSL0A pin is disable
            IOPORT.PFGSPI.BIT.SSL1E = 0; //SSL1A pin is disable
            IOPORT.PFGSPI.BIT.SSL2E = 0; //SSL2A pin is disable
            IOPORT.PFGSPI.BIT.SSL3E = 0; //SSL3A pin is disable

            //SPPCR register
            RSPI0.SPPCR.BIT.SPLP = 0; //Disable loopback mode
            RSPI0.SPPCR.BIT.SPLP2 = 0; //Disable loopback mode
            RSPI0.SPPCR.BIT.SPOM = 0; //CMOS output
            RSPI0.SPPCR.BIT.MOIFV = 0; //MOSI idle fixed value equal 0
            RSPI0.SPPCR.BIT.MOIFE = 0; //MOSI output value equal final data from previous transfer

            //SPBR register
            //Determine base frequency of operation
            //With 0 and BRDV can this options of frequency:
            //BRDV = 0 => 24MHz
            //BRDV = 1 => 12MHz
            //BRDV = 2 => 6MHz
            //BRDV = 3 => 3MHz
            RSPI0.SPBR = 0x0;   //BRDV = 3 => 3MHz

            //SPDCR register
            RSPI0.SPDCR.BIT.SPFC = 0; //Number of frames
            RSPI0.SPDCR.BIT.SLSEL = 0; //SSL0 to SSL3 as output
            RSPI0.SPDCR.BIT.SPRDTD = 0; //SPDR values are read from the receive buffer
            RSPI0.SPDCR.BIT.SPLW = 0; //SPDR is accessed in words

            //SPCKD register
            RSPI0.SPCKD.BIT.SCKDL = 0; //1 RSPCK delay for clock

            //SSLND register
            RSPI0.SSLND.BIT.SLNDL = 0; //1 RSPCK delay for slave select negation

            //SPND register
            RSPI0.SPND.BIT.SPNDL = 0; //1 RSPCK + 2 PCLK delay for next-access

            //SPCR2 register
            RSPI0.SPCR2.BIT.SPPE = 0; //Parity disable
            RSPI0.SPCR2.BIT.SPOE = 0; //Parity mode
            RSPI0.SPCR2.BIT.SPIIE = 0; //Disable idle interrupt
            RSPI0.SPCR2.BIT.PTE = 0; //Disable the self-diagnostics of the parity circuit

            //SPCMOD0 register (Graphic display)
            RSPI0.SPCMD0.BIT.CPHA = 0; //Data sampling on odd edge, data variation on even edge
            RSPI0.SPCMD0.BIT.CPOL = 0; //RSPCK = 0 when idle
            RSPI0.SPCMD0.BIT.BRDV = 0; //Bit Rate = 3MHz (according with SPBR register)
            RSPI0.SPCMD0.BIT.SSLA = 0; //SSL3-A for graphic display
            RSPI0.SPCMD0.BIT.SSLKP = 0; //Negative all SSL signals upon completion of transfer
            RSPI0.SPCMD0.BIT.SPB = 7; //Data length = 8bits
            RSPI0.SPCMD0.BIT.LSBF = 0; //MSB first
            RSPI0.SPCMD0.BIT.SPNDEN = 0; //Disable next-access delay
            RSPI0.SPCMD0.BIT.SLNDEN = 0; //Disable SSL negation delay
            RSPI0.SPCMD0.BIT.SCKDEN = 0; //An RSPCK delay of 1 RSPCK

            //SPCR register
            RSPI0.SPCR.BIT.SPMS = 1; //SPI operation (four-wire)
            RSPI0.SPCR.BIT.TXMD = 0; //Full-duplex operation
            RSPI0.SPCR.BIT.MODFEN = 0; //Disable detection of mode fault error
            RSPI0.SPCR.BIT.MSTR = 1; //Master mode
            RSPI0.SPCR.BIT.SPEIE = 0; //Disable error interrupt requests
            RSPI0.SPCR.BIT.SPTIE = 1; //enable transmit interrupt requests
            RSPI0.SPCR.BIT.SPRIE = 1; //enable receive interrupt requests
            RSPI0.SPCR.BIT.SPE = 1; //Enable RSPI function

            //SSLP register
            RSPI0.SSLP.BIT.SSLP0 = 1; //SSL0 signal is 1 active
            RSPI0.SSLP.BIT.SSLP1 = 1; //SSL1 signal is 1 active
            RSPI0.SSLP.BIT.SSLP2 = 1; //SSL2 signal is 1 active
            RSPI0.SSLP.BIT.SSLP3 = 1; //SSL3 signal is 1 active

            //SPSCR register
            RSPI0.SPSCR.BIT.SPSLN = 0; //RSPI sequence
}


6.- Inicializamos la LCD con la función en main.c

void SR_LCD_GRAPH(void)
{
            LCDInit();
            LCDClear();
            //LCDTest2();
            LCDFont(FONT_LARGE);

}

7.- La función de envió se muestra a continuación y está en el archivo r_cg_serial_SPI.c:

MD_STATUS R_RSPI0_Send_Receive(uint8_t *  tx_buf, uint16_t tx_num, uint8_t *  rx_buf)
{
    MD_STATUS status = MD_OK;

            RSPI0.SPDR.WORD.H =  0x00ff & *tx_buf;
            //Wait for transfer complete
            while (RSPI0.SPSR.BIT.IDLNF)
            {
                        __nop();
            }
            (void) RSPI0.SPDR.WORD.H ;
            G_SPI_SendingData = 0;
    return (status);

}


8.- El API de usuario RDKRX62N_spi, YRDKRX62N_LCD y el driver ST7579_LCD, glyph_api se encuentran en la carpeta Glyph:



  •  Agregar código, compilar y debug:
1.- Bajar el código de:

2.- Compilar con el icono del martillo y debug con el icono del insecto:



DEMOSTRACIÓN: