martes, 28 de febrero de 2017

INTRODUCCIÓN A RENESAS RX

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.


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: https://www.renesas.com/en-us/products/microcontrollers-microprocessors/rx.html


RAZONES DE CAMBIAR DE RX62N A RX63N


Para poder iniciarse en estas tecnologías también recomiendo los siguientes libros:





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 RX63N.

lunes, 27 de febrero de 2017

HERRAMIENTAS Y DOCUMENTACIÓN NECESARIA ANTES DE COMENZAR

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

HARDWARE:
  •  Tarjeta de demostración YRDKRX63N
https://www.renesas.com/en-us/products/boards-and-kits/boards-and-kits/device/YRDKRX63N.html


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

  • RX Compiler CC-RX_V20600_setup 
  • Peripheral Driver Generator v2.0

  •  Comm Operator (cualquier versión). O también otro SW de Hypeterminal serial :)
http://www.serialporttool.com/CommOpInfo.htm


DOCUMENTACIÓN:
  •  R20UT2532EU0100
Renesas RX63N RDK User's Manual
https://www.renesas.com/en-us/doc/products/tools/r20ut2532eu0100_yrdkrx63n_um.pdf

  • YRDKRX63N schematic
https://webpages.uncc.edu/~jmconrad/ECGR4101-2013-08/notes/YRDKRX63N_SCH_3.pdf

  • R01UH0041EJ0180
RX63N Group User's Manual: Hardware
https://www.renesas.com/en-us/doc/products/mpumcu/doc/rx_family/r01uh0041ej0180_rx63n631.pdf?key=a346da25f58871ab6ccffd7a9f56e2f8

domingo, 26 de febrero de 2017

PRACTICA # 1 USO DE I/O, LEDS Y SWITCH

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

DESARROLLO:
  • Del manual Renesas RX63N RDK User's Manual ubicamos el LED 4 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 R5F563NBDxFP, debug hardware Segger jLink, después next


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


Entorno de desarrollo e2studio configurado:


6.- Configuraremos el oscilador externo:
void SR_Oscilador(void)
{
    unsigned long i;

            SYSTEM.PRCR.WORD = 0xA503; /* Access registers via PRCR                    */
            SYSTEM.SOSCCR.BYTE = 0x00; /* Sub-clock oscillator ON                      */

            SYSTEM.HOCOPCR.BYTE = 0x00; /* HOCO ON                                      */

            SYSTEM.MOSCWTCR.BYTE = 0x0e; /* Main Clock Oscillator Wait Control Register  */
            /* 262144 states                                */
            SYSTEM.PLLWTCR.BYTE = 0x0e; /* PLL Wait Control Register                    */
            /* 2097152 states                               */

            SYSTEM.MOSCCR.BYTE = 0x00; /* EXTAL ON                                     */
            SYSTEM.PLLCR2.BYTE = 0x01; /* PLL OFF                                      */
            SYSTEM.PLLCR.WORD = 0x0f00; /* x16 @PLL                                     */
            /* Input to PLL = EXTAL                            */
            /* Therefore:                                   */
            /*   PLL = EXTAL                                */
            /*       = 12                                   */
            /*   PLL * 16 = 192MHz                          */
            /* External oscillation input selection         */
            SYSTEM.PLLCR2.BYTE = 0x00; /* PLL ON                                       */

            for (i = 0; i < 2500; i++) /* Wait for stabilisation of PLL and main clock */
            { /* = 20ms                                       */
                        /*   (2500 x 1/125kHz = 20ms)                   */

            }

            /************************************************************************/
            /*                                                                      */
            /*  SYSTEM.SCKCR.BIT.PCKB   = 2; ( b11: b8 ) PLL/4 = 48MHz                           */
            /*  SYSTEM.SCKCR.BIT.PCKA   = 2; ( b15:b12 ) PLL/4 = 48MHz                           */
            /*  SYSTEM.SCKCR.BIT.BCK    = 2; ( b16:b19 ) PLL/4 = 48MHz                           */
            /*  SYSTEM.SCKCR.BIT.PSTOP0 = 1; ( b22     ) SDCLK CLK OUT Disabled     */
            /*  SYSTEM.SCKCR.BIT.PSTOP1 = 1; ( b23     ) BUS CLK OUT   Disabled     */
            /*  SYSTEM.SCKCR.BIT.ICK    = 1; ( b24:b27 ) PLL/2 = 96MHz                           */
            /*  SYSTEM.SCKCR.BIT.FCK    = 2; ( b31:b28 ) PLL/3 = 48MHz                           */
            /*                                                                      */
            /*  SYSTEM.SCKCR2.BIT.UCK   = 2;                        PLL/4 = 48MHz              */
            /*  SYSTEM.SCKCR2.BIT.IEBCK = 3;                        PLL/4 = 48MHz                            */
            /************************************************************************/

            SYSTEM.SCKCR.LONG = 0x21c22222; /* set these bits to the same a this bit   */
            /*                             |||               |                   |             */
            /*                             |++---------------+                   |             */
            /*                                                                    |                                     |             */
            /*                             +-------------------------------------+             */

            SYSTEM.SCKCR2.WORD = 0x0033;
            //          SYSTEM.SCKCR3.WORD = 0x0000;                            /* LOCO -> LOCO         */
            //          SYSTEM.SCKCR3.WORD = 0x0100;                            /* LOCO -> HOCO         */
            //          SYSTEM.SCKCR3.WORD = 0x0200;                            /* LOCO -> MAIN         */
            //          SYSTEM.SCKCR3.WORD = 0x0300;                            /* LOCO -> Sub-Clock    */
            SYSTEM.SCKCR3.WORD = 0x0400; /* LOCO -> PLL          */

            /* Gain access to the Port Function Select Registers */
            MPC.PWPR.BIT.B0WI = 0;
            MPC.PWPR.BIT.PFSWE = 1;
}


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)
                {
                                    LED4 = OFF_;
                        }
                        else
                        {
                                    LED4 = ON_;
                        }
            }
}

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

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

3.- Correr el programa con el icono start:


VÍDEO: 


sábado, 25 de febrero 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 R5F563NB de la tarjeta de evaluación YRDKRX63N. 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 RX63N RDK User's Manual ubicamos el LED 4 

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


3.- Seleccionar el target R5F563NB, 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)
{
            /* Enable the timers. */
            //SYSTEM.MSTPCRA.BIT.MSTPA5 = 0;

            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
}

  
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:
--> Practica #2

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


VÍDEO:
                                                                                                                                                  

viernes, 24 de febrero de 2017

PRACTICA # 3 UART

OBJETIVO:
       Se hará uso del módulo del puerto serial UART2 (SCI2) con el que cuenta el MCU R5F563NB de la tarjeta de evaluación YRDKRX63N. 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 (SCI2)
  •  Habilitar ambas interrupciones (Send – Receive)
  •  Hacer Eco del dato recibido

DESARROLLO:

  • Del manual Renesas RX63N RDK User's Manual ubicamos los pines del UART2: 

  • Para poder utilizar el conversor USB-SERIAL necesitamos soldar 2 cables (RX y TX) a la tarjeta YRDKRX63N (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 YRDKRX63N schematic.pdf


  •  La conexión con el USB-Serial será:
Conectamos DB9_TxD --> RxD, TxD--> DB9_RxD 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 R5F563NB, 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:

/* System Clock Settings */
#define                XTAL_FREQUENCY  (12000000L)
#define                PCLK_MUL        (4)
#define                PCLK_FREQUENCY  (XTAL_FREQUENCY * PCLK_MUL)

#define SCI2_BAUDRATE 9600

extern void sci2_init(void)
{
            //SYSTEM.PRCR.WORD = 0xA50B; /* Protect off */

            /* clear ACSE Bit (All-Module Clock Stop Mode Enable) */
            SYSTEM.MSTPCRA.BIT.ACSE = 0;

            MSTP(SCI2) = 0; /* Enable module */

            //SYSTEM.PRCR.WORD = 0xA500; /* Protect on  */

            /* Clear bits TIE, RIE, RE, and TEIE in SCR to 0. Set CKE to internal. */
            SCI2.SCR.BYTE = 0; /* Reset module */

            /* Set up the UART I/O port and pins. */
            MPC.P50PFS.BYTE = 0x4A; /* P50 is TxD2 */
            MPC.P52PFS.BYTE = 0x4A; /* P52 is RxD2 */

            PORT5.PDR.BIT.B0 = 1; /* TxD2 is output. */
            PORT5.PDR.BIT.B2 = 0; /* RxD2 is input. */

            PORT5.PMR.BIT.B0 = 1; /* TxD2 is peripheral. */
            PORT5.PMR.BIT.B2 = 1; /* RxD2 is peripheral. */

            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 interrupciones que está en el archivo interrupt_handlers.c

// SCI2_RXI2
void Excep_SCI2_RXI2(void)
{
            unsigned char data_uart;
            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:
--> Practica #3

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


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


CONEXIÓN: