dsPIC: Diseño Practico de Aplicaciones - José María Angulo Usategui

dsPIC: Diseño Practico de Aplicaciones – José María Angulo Usategui

PDF | Español | 23.7 MB

CONTENIDO

Primera Parte : ARQUITECTURA, FUNCIONAMIENTO Y REPOSITORIO DE INSTRUCCIONES

Capítulo 1. EL MUNDO DE LOS DSP

Capítulo 2. CONTROLADORES DIGITALES DE SEÑALES (DSC)

Capítulo 3. ARQUITECTURA DE LA CPU

Capítulo 4. EL CAMINO DE DATOS

Capítulo 5. MODELO DEL PROCESADOR PARA EL PROGRAMADOR

Capítulo 6. LA MEMORIA DE DATOS

Capítulo 7. LA MEMORIA DE PROGRAMA

Capítulo 8. INTERRUPCIONES Y EXCEPCIONES

Capítulo 9. CARACTERÍSTICAS DE LAS INSTRUCCIONES Y MODOS DE DIRECCIONAMIENTO

Capítulo 10. EL REPERTORIO DE INSTRUCCIONES. INSTRUCCIONES MCU 

Capítulo 11. LAS INSTRUCCIONES DSP

Capítulo 12. PERIFÉRICOS Y RECURSOS INTEGRADOS

Segunda parte : PROGRAMACIÓN Y SIMULACIÓN DE APLICACIONES

Aplicación 0. LAS HERRAMIENTAS DE DESARROLLO

Aplicación 1. DISEÑANDO FILTROS

Aplicación 2. EL ENTORNO DE DESARROLLO MPLAB IDE

Aplicación 3. PONIENDO EN MARCHA EL SIMULADOR

Aplicación 4. MANEJANDO LAS INSTRUCCIONES TÍPICAS DE LOS dsPIC 

Aplicación 5. LEYENDO Y ESCRIBIENDO LAS MEMORIAS FLASH Y EEPROM 

Aplicación 6. PROGRAMANDO LOS PERIFÉRICOS CON VISUAL INITIALIZE

Aplicación 7. PERIFÉRICOS AVANZADOS

Tercera parte : LABORATORIO EXPERIMENTAL

Laboratorio 0. EL SISTEMA DE DESARROLLO PIC School

Laboratorio 1. APLICACIÓN DE INSTRUCCIONES DSP CON ENTRADAS Y SALIDAS DIGITALES

Laboratorio 2. MANEJANDO A FONDO LOS TEMPORIZADORES DE 32 BITS

Laboratorio 3. OPTIMIZANDO LA CONVERSIÓN ANALÓGICO/DIGITAL DE ALTA PRECISIÓN

Laboratorio 4. COMUNICACIÓN ENCRIPTADA CON EL USART

Laboratorio 5. CONTROL DE UN MOTOR DE CC MEDIANTE PWM

Laboratorio 6. DISEÑANDO FILTROS

Laboratorio 7. GRABANDO LA MEMORIA FLASH DE PROGRAMA CON UN BOOTLOADER

Laboratorio 8. MANEJANDO A FONDO LAS INTERRUPCIONES

Laboratorio 9. PILOTANDO UNA FÓRMULA 1

dsPIC: Diseño Practico de Aplicaciones – José María Angulo Usategui

DESCARGA | MEGA

LEER MÁS

Lenguaje ensamblador para computadoras basadas en Intel - 5ta Edición – Kip R. Irvine

Lenguaje ensamblador para computadoras basadas en Intel®, 5ta Edición – Kip R. Irvine

PDF | ESPAÑOL |14.88 MB

Contenido

Prefacio

1. Conceptos básicos

2. Arquitectura del procesador IA-32

3. Fundamentos del lenguaje ensamblador

4. Transferencias de datos, direccionamiento y aritmética

5. Procedimientos

6. Procesamiento condicional

7. Aritmética de enteros

8. Procedimientos avanzados

9. Cadenas y arreglos

10. Estructuras y macros

11. Programación en MS Windows

12. Interfaz con lenguajes de alto nivel

13. Programación en MS-DOS de 16 bits

14. Fundamentos de los discos

15. Programación a nivel del BIOS

16. Programación experta en MS-DOS

17. Procesamiento de punto fl otante y codifi cación de instrucciones

Apéndice A. Referencia de MASM

Apéndice B. El conjunto de instrucciones IA-32

Apéndice C. Interrupciones del BIOS y de MS-DOS

Apéndice D. Respuestas a las preguntas de repaso

Índice

Lenguaje ensamblador para computadoras basadas en Intel®, 5ta Edición – Kip R. Irvine

DESCARGA | MEGA
contraseña : www.freelibros.org

LEER MÁS

Arduino - Libro de Proyectos / Scott Fitzgerald y Michael Shiloh

Arduino - Libro de Proyectos / Scott Fitzgerald y Michael Shiloh

PDF | ESPAÑOL | 16.9 MB 

Contenido

Introduccion

01 Conozca sus herramientas

02 Interface de nave espacial

03 Medidor de enamoramiento

04 Lámpara de mezcla de colores

05 Indicador del estado de ánimo

06 Theremin controlado por luz

07 Teclado musical

08 Reloj de arena digital

09 Rueda de colores motorizada

10 Zoótropo

11 La Bola de Cristal

12 Mecanismo de bloqueo secreto

13 Lámpara sensible al tacto

14 Retocar el logotipo de Arduino

15 Hackear botones

A/Z Glosario

Apuntes y libros recomendados

Arduino - Libro de Proyectos / Scott Fitzgerald y Michael Shiloh

DESCARGA | MEGA

LEER MÁS

Organización y arquitectura de computadores / 7ma Edición / William Stallings

Organización y arquitectura de computadores, 7ma Edición – William Stallings

Español | 163.89 MB | PDF

Contenido:

Prólogo
Capítulo 0. Guía del lector

PRIMERA PARTE: VISIÓN GENERAL
Capítulo 1. Introducción
Capítulo 2. Evolución y prestaciones de los computadores

SEGUNDA PARTE: EL COMPUTADOR
Capítulo 3. Perspectiva de alto nivel del funcionamiento y de las interconexiones del computador
Capítulo 4. Memoria caché
Capítulo 5. Memoria interna
Capítulo 6. Memoria externa
Capítulo 7. Entrada/salida
Capítulo 8. Sistemas operativos

TERCERA PARTE: LA UNIDAD CENTRAL DE PROCESAMIENTO
Capítulo 9. Aritmética del computador
Capítulo 10. Repertorios de instrucciones: características y funciones
Capítulo 11. Repertorio de instrucciones: modos de direccionamiento y formatos
Capítulo 12. Estructura y funcionamiento del procesador
Capítulo 13. Computadores de repertorio reducido de instrucciones
Capítulo 14. Paralelismo en las instrucciones y procesadores superescalares
Capítulo 15. La arquitectura IA-64

CUARTA PARTE: LA UNIDAD DE CONTROL
Capítulo 16. Funcionamiento de la unidad de control
Capítulo 17. Control microprogramado

QUINTA PARTE: ORGANIZACIÓN PARALELA
Capítulo 18. Procesamiento paralelo

APENDICES
Apéndice A. Sistemas de numeración
Apéndice B. Lógica digitales
Apéndice C. Proyectos para enseñar arquitectura y organización de computadores

Glosario
Referencias
Índice analítico
Acrónimos

Organización y arquitectura de computadores, 7ma Edición – William Stallings

DESCARGA | MEGA

LEER MÁS

Operaciones Aritméticas en Assembler con emu8086

¿ Qué es el Lenguaje Ensamblador ?

El ensamblador (en inglés, Assembler o Assembly, que se suele abreviar como Asm) es un lenguaje de programación de ordenadores de bajo nivel (muy cercano al código máquina), por lo que es específico de cada tipo de ordenador (básicamente, de cada procesador). Es más difícil de aprender que los lenguajes de alto nivel, resulta mucho menos legible, y prácticamente no es portable, pero si se domina, es el que dará la mayor velocidad a nuestro programa. 

Características del código ensamblador: 

El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido ya que su estructura se acerca al lenguaje máquina, es decir, es un lenguaje de bajo nivel. 

Los programas hechos, por un programador experto, en lenguaje ensamblador, son generalmente mucho más rápidos y consumen menos recursos del sistema (memoria RAM y ROM.)- (utilizados en programación de juegos) 

Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por un microprocesador ya que, se dispone de instrucciones del CPU que generalmente no están en los lenguajes de alto nivel.

OPERACIONES ARITMÉTICAS BÁSICAS EN EL LENGUAJE ENSAMBLADOR

CON EMU8086

 .model small

.stack 64 .data ;declarando variables globales numero1 db 0 numero2 db 0 suma db 0 resta db 0 multiplicacion db 0 division db 0 modulo db 0 msjn1 db 10,13, "Ingrese el primer numero= ",'$';ingrese n1 msjn2 db 10,13, "Ingrese el segundo numero= ",'$';ingrese n2 ;mensaje para mostrar los resultados msjnS db 10,13, "La suma es= ",'$' msjnR db 10,13, "La resta= ",'$' msjnM db 10,13, "La Multiplicacion es= ",'$' msjnD db 10,13, "La division es = ",'$' msjnMod db 10,13, "El modulo es = ",'$' .code begin proc far ;direccionamiento del procedimiento mov ax, @data mov ds,ax ;solicitar del teclado numero 1 mov ah, 09 lea dx, msjn1 int 21h mov ah, 01 int 21h sub al, 30h mov numero1,al ;solicitar del teclado numero 2 mov ah, 09 lea dx, msjn2 int 21h mov ah, 01 int 21h sub al, 30h mov numero2,al ;operaciones aritmeticas ;SUMA mov al,numero1 add al,numero2 mov suma,al ;RESTA mov al,numero1 sub al,numero2 mov resta,al ;MULTIPLICACION mov al,numero1 mul numero2 mov multiplicacion,al ;DIVISION mov al,numero1 div numero2 mov division,al ;MODULO mov al, numero1 div numero2 mov modulo,ah ;Mostrar los mensajes de los resultados ;mostrando la suma mov ah,09 lea dx,msjnS int 21h mov dl,suma add dl,30h mov ah,02 int 21h ;mostrando la resta mov ah,09 lea dx,msjnR int 21h mov dl,resta add dl,30h mov ah,02 int 21h ;mostrando la multiplicacion mov ah,09 lea dx,msjnM int 21h mov dl,multiplicacion add dl,30h mov ah,02 int 21h ;mostrando la division mov ah,09 lea dx,msjnD int 21h mov dl,division add dl,30h mov ah,02 int 21h ;mostrando el modulo mov ah,09 lea dx,msjnMod int 21h mov dl,modulo add dl,30h mov ah,02 int 21h ;cierre del programa mov ah,4ch int 21h begin endp end

LEER MÁS

Método de Muller con Guide en Matlab

A continuación tendrán que seguir los siguientes comandos  usados en cada caso.

function btnCalcular_Callback(hObject, eventdata, handles) funcion=inline(get(handles.txtF,'string')); x0=str2double(get(handles.txtX0,'string')); x1=str2double(get(handles.txtX1,'string')); x2=str2double(get(handles.txtX2,'string')); e=str2double(get(handles.txtEa,'string')); k=0; xi=0; sigue=1; set(handles.uitable1,'Data',[]); %-----------------------------------------------% while(sigue) xi=x2; k=k+1; h0=x1-x0; h1=x2-x1; d0=(funcion(x1)-funcion(x0))/h0; d1=(funcion(x2)-funcion(x1))/h1; %hallando las constantes a=(d1-d0)/(h1+h0); b=a*h1+d1; c=funcion(x2); raizd=sqrt(b*b-4*a*c); %-----------------------------------------------------% if abs (b+raizd)> abs(b-raizd) den=b+raizd; else den=b-raizd; end %-----------------------------------------------------% dxr=-2*c/den; xr=x2+dxr; sigue=abs(dxr)/xr>e || k<c || abs(funcion(xr))>e; et=abs(xr-x2)/xr; ea=et*100; %para agregar a la tabla de valores hallados newRow ={x0,x1,x2,xr,funcion(x0),funcion(x1),funcion(x2),ea}; oldData = get(handles.uitable1,'Data'); newData=[oldData; newRow]; set(handles.uitable1,'Data',newData) x0=x1; x1=x2; x2=xr; end function btnGraficar_Callback(hObject, eventdata, handles) axes(handles.axes1) funcion=inline(get(handles.txtF,'string')); ezplot(funcion);

Método de Muller

DESCARGA | MEGA

LEER MÁS

Método de la Secante con Guide en Matlab

A continuación tendrán que seguir los siguientes comandos  usados en cada caso.

function btnCalcular_Callback(hObject, eventdata, handles) f=get(handles.edit1,'string'); x0=str2double(get(handles.edit2,'string'));% x1=str2double(get(handles.edit3,'string')); tol=str2double(get(handles.edit4,'string')); syms x; ea(1)=100; set(handles.tabla,'Data',{}) hold off cla set(handles.tabla,'Data',{}) set(handles.respuesta,'string','No hay raiz'); i=1; while abs(ea)>tol; x=x0; g=eval(f); x=x1; gg=eval(f); xi=x1-((gg*(x0-x1))/(g-gg)); ea=abs((xi-x1)/xi)*100; x0=x1; x1=xi; % Mostrara datos en tabla newRow ={i,x xi,ea}; oldData = get(handles.tabla,'Data'); newData=[oldData; newRow]; set(handles.tabla,'Data',newData) i=i+1; end respuesta=sprintf('%0.6f',xi); set(handles.respuesta,'string',respuesta); %Grafica de la funcion hold off fplot(handles.axes1,f,[0 xi+1]); grid on; hold on; zoom on function btnLimpiar_Callback(hObject, eventdata, handles) cla %limpiar tabla set(handles.tabla,'Data',{}) %limpiar textboxs set(handles.edit1,'string',''); set(handles.edit2,'string',''); set(handles.edit3,'string',''); set(handles.edit4,'string',''); set(handles.respuesta,'string','');

Método de la Secante

DESCARGA | MEGA

LEER MÁS

Método de Newton - Raphson con Guide en Matlab

continuación tendrán que seguir los siguientes comandos  usados en cada caso.

function btnCalcular_Callback(hObject, eventdata, handles) try funcion=get(handles.txtFuncion,'string'); x0=str2double(get(handles.txtX0,'string')); porcentajeError=str2double(get(handles.txtPorcentajeError,'string')); syms x iteracion=0; errorCalculado=100; f=sym(funcion); derivada=diff(f,x); set(handles.tabla,'Data',{}) if derivada==0 hold off cla set(handles.tabla,'Data',{}) set(handles.txtRaiz,'string','No hay raiz'); else while errorCalculado>porcentajeError fx=subs(f,x0); dx=subs(derivada,x0); x1=x0-(fx/dx); errorCalculado=abs(((x1-x0)/x1)*100); %mostrar datos en tabla newRow ={iteracion x0 errorCalculado}; oldData = get(handles.tabla,'Data'); newData=[oldData; newRow]; set(handles.tabla,'Data',newData) x0=x1; iteracion=iteracion+1; end respuesta=sprintf('%0.16f',x1); set(handles.txtRaiz,'string',respuesta); %Grafica de la funcion hold off handles.axes1=ezplot(f); grid on; hold on; zoom on end catch msgbox('Un error ha ocurrido. Verifique que ha introducido todos los datos y de la forma adecuada','Error','error') end function btnLimpiar_Callback(hObject, eventdata, handles) %limpiar area de grafico cla %limpiar tabla set(handles.tabla,'Data',{}) %limpiar textboxs set(handles.txtFuncion,'string',''); set(handles.txtX0,'string',''); set(handles.txtPorcentajeError,'string',''); set(handles.txtRaiz,'string','');

Método de Newton - Raphson

DESCARGA | MEGA

LEER MÁS

Método del Punto Fijo con Guide en Matlab

A continuación tendrán que seguir los siguientes comandos  usados en cada caso.

function btnCalcular_Callback(hObject, eventdata, handles) f=inline(get(handles.txtFuncion,'string')); g=inline(get(handles.txtFuncionD,'string')); Xo=str2double(get(handles.txtValorInicial,'string')); Tol=str2double(get(handles.txtTolerancia,'string')); Iter=10; Yn=f(Xo); Error=Tol+1; Cont=0; Z=[Cont,Xo,Yn,Error]; set(handles.uitable1,'Data',[]); while Yn~=0 && Error>Tol && Cont<Iter Xn=g(Xo); Yn=f(Xn); Error=abs((Xn-Xo)/Xn); Cont=Cont+1; Z(Cont,1)=Cont; Z(Cont,2)=Xn; Z(Cont,3)=Yn; Z(Cont,4)=Error; Xo=Xn; newRow ={Cont,Xn,Yn,Error}; oldData = get(handles.uitable1,'Data'); newData=[oldData; newRow]; set(handles.uitable1,'Data',newData) end if Yn==0 fprintf('\n\nSOLUCION:\n') fprintf('%g es raiz\n\n',Xo); else if Error<Tol fprintf('\n\nSOLUCION:\n') fprintf('%g es una aproximacion con un tolerancia de %g\n\n',Xo,Tol); end end

function btnGraficar_Callback(hObject, eventdata, handles) axes(handles.axes1) f=inline(get(handles.txtFuncion,'string')); ezplot(f);

Metodo del Punto Fijo

DESCARGA | MEGA

LEER MÁS

Método de la Falsa Posición con Guide en Matlab

A continuación tendrán que seguir los siguientes comandos  usados en cada caso.

function btnCalcular_Callback(hObject, eventdata, handles) f=get(handles.edit1,'string'); f=inline(f); xai=str2double(get(handles.edit2,'string')); xbi=str2double(get(handles.edit3,'string')); tol=str2double(get(handles.edit4,'string')); i=1; ea(1)=100; if f(xai)*f(xbi)<0; xa(1)=xai; xb(1)=xbi; xf(1)= xb(1)-f(xb(1))*(xa(1) - xb(1))/(f(xa(1))-f(xb(1))); set(handles.tabla,'Data',{}) hold off cla set(handles.tabla,'Data',{}) set(handles.respuesta,'string','No hay raiz'); while abs(ea(i))>=tol if f(xa(i))*f(xf(i))<0 xa(i+1)=xa(i); xb(i+1)=xf(i); end if f(xa(i))*f(xf(i))>0 xa(i+1)=xf(i); xb(i+1)=xb(i); end xf(i+1)= xb(i+1)-f(xb(i+1))*(xa(i+1) - xb(i+1))/(f(xa(i+1))-f(xb(i+1))); ea(i+1)=abs((xf(i+1)-xf(i))/(xf(i+1))*100); % Mostrara datos en tabla newRow ={i xa(i+1) xb(i+1) xf(i+1) ea(i+1)}; oldData = get(handles.tabla,'Data'); newData=[oldData; newRow]; set(handles.tabla,'Data',newData) grid on; plot(i,f(i),'Ok'); hold on; i=i+1; end respuesta=sprintf('%0.6f',xf(i)); set(handles.respuesta,'string',respuesta); fplot(handles.axes1,f,[xai xbi]); grid ezplot(f); grid on; plot(xbi,f(xbi),'+'); zoom on else set(handles.respuesta,'string','No existe la raiz en el intervalo'); zoom on end

function btnLimpiar_Callback(hObject, eventdata, handles) cla %limpiar tabla set(handles.tabla,'Data',{}) %limpiar textboxs set(handles.edit1,'string',''); set(handles.edit2,'string',''); set(handles.edit3,'string',''); set(handles.edit4,'string',''); set(handles.respuesta,'string','');

Método de la Falsa Posición

DESCARGA | MEGA

LEER MÁS