1 / 141

Introducción

Introducción. Objetivos. Familiarizarse con el manejo de un micro (procesador/controlador) Arquitectura Organización de un SED Entender la documentación Entender la especificación de un SED Desde el punto de vista de la aplicación Desde el punto de vista del propio SED Requisitos de CPU

toya
Download Presentation

Introducción

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Introducción

  2. Objetivos • Familiarizarse con el manejo de un micro (procesador/controlador) • Arquitectura • Organización de un SED • Entender la documentación • Entender la especificación de un SED • Desde el punto de vista de la aplicación • Desde el punto de vista del propio SED • Requisitos de CPU • Requisitos de memoria • Requisitos de I/O • Desarrollar habilidades de diseño y depuración de un SED • Parte hardware • Parte software (en C y/o Ensamblador)

  3. Programa • Introducción • Arquitectura del microcontrolador SIEMENS 80C167 • Registros • Lenguaje Ensamblador: Juego de instrucciones • Modos de direccionamieno • Memoria y mapa de memoria • Periféricos • Puertos paralelo/serie • Timers • Otros: Displays, teclados, etc. • Interrupciones • Programación en alto nivel: Lenguaje C • Proyecto • Hardware/software

  4. Normas y bibliografía • Evaluación (consultar información oficial) • Nota = .7 Teoría+ .3 Lab • Teoría • .3 Pruebas intermedias + .7 Prueba final • Habrá varias pruebas intermedias (Evaluación continua) • Habrá ejercicios para casa (algunos evaluables) • Se pedirá la participación del alumno en clase Incluso se podrán cambiar los porcentajes Fundamental: la asistencia • Bibliografía • Página WEB: Teoría, calendario, prácticas • Manuales Siemens • Libro de programación en C

  5. Introducción al SIEMENS 80C167

  6. SIEMENS 80C167 • Microcontrolador (Embedded Processor) de 16 bits • ALU y Registros de 16 bits • Diseñado para tareas de control industrial • Robusto frente al ruido electromagnético • P.e. PLC’s del LAB • Rango direccionamiento: 16 Mbytes (memoria) • Con memoria RAM interna • Ciertas versiones disponen también de ROM interna • Con muchos dispositivos integrados en el chip • Controladores de comunicaciones serie • Puertos paralelo • Temporizadores (timers) • Convertidor analógico/digital (A/D) • Moduladores PWM (electrónica de potencia).

  7. “Modelo de programador” del 167 Memoria CPU FF FFFF Registros R7 R15 PC R6 R14 PSW R5 R13 SP R4 R12 (SFR’s) R3 R11 R2 R10 R1 R9 00 0001 R0 R8 00 0000 (GPR’s) 00 FE00 00 FE02 I/O (SFR’s) 00 FE0X

  8. Memoria • Organizada en “celdas” de 1 BYTE (8 bits) • Cada byte tiene su DIRECCIÓN • Dada en 24 bits (16 Mbytes) • Se accede a la memoria usando la dirección. Ejemplos • Lectura/escritura (datos/direcciones: 1’s y 0’s) • Registros (CPU): Posiciones de memoria de acceso rápido • I/O. En el 167 el acceso a puertos es similar al acceso a memoria dato = READ (dirección) WRITE(dato, dirección)

  9. Primer ejemplo • Suma de dos datos en ASS 167 Suma (940)+(942) en (942) • Para llenar R0 hacen falta dos bytes! (2 bytes por dato) • En direcciones consecutivas de memoria (940/941) • Parte baja del dato (en R0) en dirección par MOV R0,0x940 ; READ ADD R0,0x942 MOV 0x942,r0 ;WRITE

  10. Más ejemplos: Programas en C y Ensamblador • Primer ejemplo: bucle “for” • En lenguaje C • En lenguaje ensamblador • N = 5; j en 00FA00 H ( j no está inicializada !) for (i=1; i <=N; i++) j += 1; 500 E0 10 MOV R0,#1 ; r0 (i) 502 E0 11 MOV R1,#1 ; auxiliar 504 48 05 CMP R0,#5 ; if i>N 506 DD 05 JMPR cc_sgt,512 ; then goto 512H 508 04 F1 00 FA ADD 0fa00,R1 ; j += 1 50C 08 01 ADD R0,#1 ; i += 1 50E FA 00 04 05 JMPR cc_uc,504 ; salto sin condición 512

  11. Notas • En Ensamblador más largo que en C • Línea ensamblador = operación elemental • “mov” de un dato de memoria-registro (registro-memoria) • Suma dos datos • Compara dos datos • Saltos (con y sin condición) • Las instrucciones se almacenan en memoria en formato BINARIO (1’s y 0’s) • Las instrucciones ocupan 2 ó 4 bytes • Las instrucciones se almacenan en posiciones de memoria CONSECUTIVAS. Se ejecutan en orden • Salvo el los saltos • La DIRECCIÓN (de memoria) de la próxima instrucción a ejecutar se almacena en el PC (Contador de Programa)

  12. Cómo se ejecuta un programa ? • Dos pasos: • Captura de la instrucción (Instruction Fetch, usando el PC) • Ejecución (usando la ALU) • Fetch: Trae la instrucción de memoria, incrementa PC • CPU = MEM(PC); PC++; • Execute: La ALU realiza la operación (suma, resta, etc.)

  13. Programa ensamblador • Traduce las instrucciones de “pnemónico” a binario • Por ejemplo, la instrucción • Se convierte en (Codificación de instrucciones) • Nuestra primera instrucción • que suponemos cargada en la posición 500 H de memoria • Tipos de ensambladores • De línea: No soporta etiquetas (reside en el monitor de la tarjeta) • De PC: Soporta etiquetas (reside en el PC) MOV R0,#1 E0 10

  14. Ejemplo con etiquetas (ensamblador en PC) • Las etiquetas facilitan la programación en ASS • Los campos que forman una instrucción en ASS • Los campos etiqueta y comentario son opcionales • TAB si no se usa el campo de etiqueta MOV R0,#1 ; r0 (i) MOV R1,#1 ; auxiliar bucle: CMP R0,#5 ; if i>N JMPR cc_sgt,fin ; then goto ´fin’ ADD 0fa00H,R1 ; j += 1 ADD R0,#1 ; i += 1 JMPS bucle ; = jmpr cc_uc, fin: etiqueta: operación operandos ;comentario

  15. Operaciones y operandos (resumen) • Operaciones • Transferencia: mov • Aritméticas: add, sub, cmp, neg, mul, div • Lógicas: and, or, cpl • Desplazamientos: shr, shl • Saltos: jmpr cc_uc (cc_eq, cc_ne, cc_ugt, cc_sgt, cc_ule, ...) • Operandos, modos de direccionamiento • Inmediato: #1 • Directo a registro: R0 • Directo a memoria: 0fa00 • Indirecto: [R0] • Números • Decimal 15 • Hexadecimal 0fa00 H (0 por delante si empiezan por letra) • Binario 01001000 B

  16. Modos de direccionamiento. • Directo a registro • mov r0,r1 ; R0 <- R1 • Inmediato • mov r0,#3 ; R0 <- 3 (no olvidar # !) • directo a memoria • mov r0,0fa00H ; R0 <- Mem[fa00 H] • Indirecto (“normal”, post-incremento, pre-decremento) • mov r0,[r1] ; R0 <- Mem[R1](R1 Puntero) • mov r0,[r1+] ; R0 <- Mem[R1], R1 <- R1 + 2 • mov r0,[-r1] ; R1 <- R1 - 2, R0 <- Mem[R1] • mov r0,[r1+#4] ; R0 <- Mem[R1+#4] • A nivel de byte • movb rl0,#3 ; R0 <- 3 • movb rh0,[r1+] ; R0 <- Mem[R1], R1 <- R1 + 1

  17. Tipos de instrucciones • De transferencia de datos • Mov • mov r0,#5 ; carga el número 5 en R0 • Aritméticas • Add, Sub, Neg, Cmp, Mul • add r0,r1 ; R0 <- R0 + R1 • Lógicas • And, Or, Xor, Cpl • Desplazamientos • Shl, Shr, Rol, Ror • Saltos • JMPR: Con condición, sin condición (unconditional) • Jmpr cc_eq, dir • Jmpr cc_uc. dir

  18. Más ejemplos • if ( ) • Alto nivel • Ensamblador if (a == b) a = 0; MOV R0,a CMP R0,b JMPR cc_ne,next MOV R0,#0 MOV a,R0 next:

  19. Otro ejemplo • while ( ) • Alto nivel • Ensamblador i = 0; while (i<10) { a[i] = i; i += 1; } MOV R0,#0 MOV R1,#1 MOV R2,#0fa00h otro: CMP R0,#10 JMPR cc_sge,next MOV [R2],R0 ADD R0,R1 ADD R2,#2 JMPS otro next:

  20. Mapa de memoria del 80C167

  21. Mapa de memoria del 80C167 • Segmentada, en código. Paginada en datos. FF FFFF H FFFF H P3 (RAM I.) C000 H 255 Segmentos de 64 kB P2 8000 H P1 (ROM) 4000 H 01 0000 H P0 (ROM) S0 00 0000 H 0000 H

  22. Página 3: RAM interna + SFR’s • Los registros de control de los periféricos están en P3. Reciben el nombre de Special Function Registers. • Los GPR’s son los registros R0 a R15 (en esta zona de memoria caben más de 16 registros de 16 bits!). FFFF H SFR’s (bit) SFR’s FF00 H SFR’s FE00 H Bit a bit FD00 H GPR’s FC00 H RAM Stack F600 H

  23. SFR’s • Son: • PSW (Processor Status Word). Contiene los flags, ó códigos de condición (para instrucciones de salto. P.e. “jmpr cc_eq,dir”) • N: Negative • C: Carry (acarreo) • V: Overflow (números con signo) • Z: Zero • PC (Program Counter) • IP: Instruction Pointer (16 bits, apunta dentro del segmento) • CSP: Code Segment Pointer (8 bits, apunta al segmento en uso) • SP (Stack Pointer) • Apunta a la zona de Stack (F600 H a FC00 H, crece hacia abajo). • DPP’s (Data Page Pointer Registers) • Otros: Control de periféricos (p.e. Las luces en FFC0 H)

  24. GPR’s • Registros de propósito general (R0 a R15) • Son de 16 bits • Los 8 primeros registros (R0 a R7) se pueden acceder a nivel de byte (8 bits). En este caso reciben los nombres: • RL0 y RH0 (para R0) • Los 4 primeros registros (R0 a R3) pueden almacenar direcciones (punteros) • Ubicados en la zona (FC00 H a FD00 H) • Se puede “reubicar” el banco de registros (los 16) en esta zona de memoria actuando sobre el registro (SFR): • CP (Contex Pointer) • CP inicial = FC00 H • Más: rendimiento, prestaciones, capacidad, etc. No sólo CPU: sistema completo

  25. Puertos de entrada/salida del 80C167

  26. Entrada/salida. Puertos paralelo • 9 puertos, 111 líneas (144 pin) • P0 y P1 (16 bits): Bus de datos y bus de direcciones • P2 (16 bits): de propósito general • Parte baja: Diodos led (y teclado en tarjeta de ampliación) • Parte alta: Interruptores (tarjeta de ampliación) • P3 (16 bits): Vía serie con PC (y display en tarjeta de ampliación) • (P4, 8 bits: parte alta del bus de direcciones) • P5 (16 bits): Entradas A/D. • (P6, 8 bits: de “chip select”). • (P7, 8 bits: de “PWM”). • (P8, 8 bits: de “Capture Compare”)

  27. Puerto 2 • Dos registros de control de 16 bits: DP2 y P2 • DP2 en FFC2 H • DP2 (bits DP2.0 a DP2.15): “Data Direction Register”. Ej: • DP2.0 = 1 : Línea de salida • DP2.0 = 0 : Línea de entrada • P2 en FFC0 H • P2 (bits P2.0 a P2.15): “Data Register”. Ej; • Si DP2.0 = 1, (P2 como registro de escritura) • P2.0 = 1: La Salida P2.0 se pone a 5 V. • P2.0 = 0: La Salida P2.0 se pone a 0 V. • Si DP2.0 = 0, (P2 como registro de lectura) • Si P2.0 = 1: La Entrada P2.0 está a 5 V. • Si P2.0 = 0: La Entrada P2.0 está a 0 V.

  28. Diodos e interruptores • Tenemos diodos (leds) en parte baja P2 (P2.0 a P2.7) e interruptores en la parte alta (P2.8 a P2.15). • ¿Qué nivel lógico tengo que poner en P2.0 para que el diodo se encienda? + 5V + 5V P2.8 P2.0

  29. Ejemplo de manejo de P2 en C • Lee entradas, efectúa cierta operación con las mismas, pone el resultado en los diodos. • ¿Qué operación se realiza con el dato introducido mediante los interruptores? #include <reg167.h> void main(void){ int lect,temp1,temp2; DP2 = 0x00ff; while (1) { lect = P2; temp1 = lect & 0x0f00; temp1 = temp1 >> 8; temp2 = lect & 0xf000; temp2 = temp2 >> 12; P2 = ~(temp1 + temp2); } }

  30. Ejemplo de manejo de P2 en C • De una forma más compacta #include <reg167.h> void main(void){ DP2 = 0x00ff; while (1) { P2 = ~(((P2 & 0x0f00) >> 8) + ((P2 & 0xf000) >> 12)); }

  31. Programación avanzada en Ensamblador

  32. Ejemplo con etiquetas (ensamblador en PC) • Las etiquetas facilitan la programación en ASS • Los campos que forman una instrucción en ASS • Los campos etiqueta y comentario son opcionales • TAB si no se usa el campo de etiqueta MOV R0,#1 ; r0 (i) MOV R1,#1 ; auxiliar bucle: CMP R0,#5 ; if i>N JMPR cc_sge,fin ; then goto ´fin’ ADD 0fa00H,R1 ; j += 1 ADD R0,#1 ; i += 1 JMPS bucle ; = jmpr cc_uc, fin: etiqueta: operación operandos ;comentario

  33. Programando en ensamblador con etiquetas • Línea de ensamblador típica • etiqueta: operanción operandos ; comentario • El primer carácter de la etiqueta en columna 1 • Campos separados por “tabs” • El campo de “etiqueta” se puede suprimir (poner un “tab”) • Usando etiquetas Ini: mov r0, #1 . . Jmpr cc_uc, ini

  34. Tareas que realiza el programa ensamblador • El programa ensamblador (A166) • Traduce el fuente (.a66) a código máquina (.obj) • Cada instrucción tiene su código binario. Ejemplos: • mov Rx, Ry en código máquina F0xy H • donde x e y están codificados en 4 bits cada uno de ellos (los diferentes modos de direccionamiento van en el campo de instrucción) • Esta instrucción completa usa 16 bits (2 bytes) • mov reg, # dato 16 en código máquina E6reg Dato16 • donde reg esta codificado en 8 bits • Esta instrucción completa usa 32 bits (4 bytes) • Resuelve los valores de las etiquetas • Lleva un contador direcciones en memoria de las instrucciones • La etiqueta toma el valor de la dirección de memoria de la instrucción asociada

  35. Instrucción MOV. • Directo a registro • mov r0,r1 ; R0 <- R1 • Inmediato • mov r0,#3 ; R0 <- 3 (no olvidar # !) • directo a memoria • mov r0,0fa00H ; R0 <- Mem[fa00 H] • Indirecto (“normal”, post-incremento, pre-decremento) • mov r0,[r1] ; R0 <- Mem[R1](R1 Puntero) • mov r0,[r1+] ; R0 <- Mem[R1], R1 <- R1 + 2 • mov r0,[-r1] ; R1 <- R1 - 2, R0 <- Mem[R1] • mov r0,[r1+#4] ; R0 <- Mem[R1+#4] • A nivel de byte • movb rl0,#3 ; R0 <- 3 • movb rh0,[r1+] ; R0 <- Mem[R1], R1 <- R1 + 1

  36. Mov: Flags. Extensión de signo. • Flags • Mov actualiza N y Z • p.e. se puede usar “jmpr cc_eq,dir” después del Mov. • Extensión de signo • Movbz • Carga el byte en parte baja, extiende (a los 16 bits) con ceros • Movbs • Carga el byte en parte baja, extiende (a los 16 bits) con bit de signo

  37. Little/Big Endian • En la operación (16 bits) • mov r0,0fa00H ; R0 <- Mem[fa00 H] • El byte (8 bits) almacenado en la posición 0fa00H • Va a la PARTE BAJA del REGISTRO (a RL0) • El byte almacenado en fa01 va a la PARTE ALTA (RH0) • El C167 es un Little-Endian • En los procesadores MOTOROLA • Al revés • En ambos casos NO se permite extraer un word (16 bits) de una dirección impar de memoria.

  38. Programando con etiquetas (para datos) • La pseudoinstrucción EQU permite dar nombres a los distintos datos de programa • Variables (posiciones de memoria, ej 0fa00h) • Constantes var1 equ 0fa00h var2 equ 0fa01h MOVB RL0,var1 MOVB RL1,var2 MOVB var2,RL0 MOVB var1,RL1

  39. Instrucciones aritméticas • Aritmética en “Coma fija complemento a 2” • Números positivos: bit más significativo (bit 15) a 0. • Números negativos: bit más significativo (bit 15) a 1. • -1 -> FFFF H, -2 -> FFFE H, ...., - 2^15-> 8000 H • Sumando dos positivos “nos vamos a los negativos” • 7FFF H + 1 = 8000 H ! (“Overflow”) • Instrucción Add • Add Rx,op ; op: cualquier modo direccionamiento • Add op,Rx ; menos “ortogonal” (que Mov) • Flags • V = 1 si “Overflow” (cambio de signo) • C = 1 si “Carry” (acarreo, no cabe el resultado en 16 bits)

  40. Otras instrucciones aritméticas • ADDB. Suma a nivel de byte • SUB. Resta • SUBB. Resta a nivel de byte • NEG. Complemento a 2 de un número (número “negado”). • MUL. Multiplica números con signo. • MULU. Multiplica números sin signo. • DIV/DIVU. Divide (con y sin signo). • MUL Rx,Ry ; Dos GPR’s • Resultado en 32 bits en registro MD • MDL: Parte baja de MD (16 bits). • MDH: Parte alta de MD (16 bits).

  41. Instrucciones lógicas y desplazamientos. • Lógicas. AND, OR, XOR, CPL • And Rx,op ; op: cualquier modo direccionamiento • And op,Rx ; menos “ortogonal” (que Mov) • Mismos modos direccionamiento de ADD • Actualiza flags Z y N (C y V quedan a 0) • Desplazamientos y “rotates” • Shl op1,op2 • Desplaza a la izquierda op1, el número de posiciones indicadas en op2 • Introduce ceros por la derecha • Rol op1,op2 • Desplaza a la izquierda op1, el número de posiciones indicadas en op2 • El bit que sale por la izquierda se introduce por la derecha

  42. Control de flujo de programa. Saltos. • Sin condición • Jmpr cc_uc, dir ; “dir” dirección de memoria • Con condición. Ej: • cmp op1,op2 ; Instrucción que actualiza el flag Z • jmpr cc_eq, dir ; si Z = 1 • Ejemplos de condición • cc_eq ; Z=1 (operandos iguales) • cc_ ne ; Z=0 (operandos distintos) • cc_ sgt ; op1 > op2 con signo • cc_sge ; op1 >= op2 con signo • cc_ugt ; op1 > op2 sin signo • cc_sle ; op1 < = op2 con signo • etc: todas las combinaciones

  43. Saltos “a nivel de bit” • Salto si el bit está a 1 • jb bit, dir • Salto si el bit está a 0 • jnb bit, dir • Sólo en zonas bit a bit • Otros (Tiempo Real) • jbc (jump if bit set and clear) • jnbs (jump if bit clear and set) FFFF H SFR’s (bit) SFR’s FF00 H SFR’s FE00 H Bit a bit FD00 H GPR’s FC00 H RAM Stack F600 H

  44. “move” a nivel de bit • Poner un bit a 1 • bset bit • Poner un bit a 0 • bclr bit • Mover un bit • bmov bitd, bits • Lógicas (a nivel de bit) • band • bor • bxor

  45. C y Ensamblador • if ( ) • Alto nivel • Ensamblador if (a == b) a = 0; MOV R0,a CMP R0,b JMPR cc_ne,next MOV R0,#0 MOV a,R0 next:

  46. Bucles • for ( ) • Alto nivel • Ensamblador for (i=START; i <= STOP; i++){ a = STOP - i; MOV R0,#START ; r0 (i) MOV R1,#STOP SUB R1,R0 ; r1 (STOP-START) JMPR cc_uc,test for: MOV a,R1 SUB R1,#1 ADD R0,#1 ; i += 1 test: CMP R0,#STOP JMPR cc_sle,for ; i <= STOP next:

  47. Bucles II • for ( ) • Alto nivel • Ensamblador for (i=START; i <= STOP; i++){ a = STOP - i; MOV R0,#START ; r0 (i) MOV R1,#STOP SUB R1,R0 ; r1 (STOP-START) for: MOV a,R1 CMPD1 R1,#0 ; hasta r1 = -1 JMPR cc_sge,for ; i <= STOP next:

  48. Otro ejemplo • while ( ) • Alto nivel • Ensamblador i = 0; while (i<10) { a[i] = i; i += 1; } MOV R0,#0 MOV R1,#1 MOV R2,#0fa00h otro: CMP R0,#10 JMPR cc_sge,next MOV [R2],R0 ADD R0,R1 ADD R2,#2 JMS otro next:

  49. Directivas. “Pseudoinstrucciones” • El ensamblador de Keil (Siemens) no tiene ORG ! • Section: Comienzo de una sección • De código (programa) ó datos, a partir de una POS de memoria • Ends: Cierra la sección • Proc : Comienzo de un procedimiento (subrutina/función) • Endp: Cierra el procedimiento • dsw: Reserva espacio para un word (dsb: para un byte) • equ: Fuera de las secciones • Define una constante/variable (para esto último se prefiere dsw)

  50. Ejemplo completo • Las directivas a usar en el ”for” anterior : $nonsegmented D100 section data at 200H j dsw 1 ; datos D100 ends ej section code at 300H ej1 proc NEAR MOV R0,#START ; código .... fin: nop ; código (final) ej1 endp ej ends end

More Related