Mensajes

Vale, hasta aquí he podido llegar, tengo que hacer cosas.

Una vez hayas dibujado el circuito con el Schematic, la forma de meterle la señal es igual que añadiendo las partes: Draw -> Get New Part <- Y en esta ventana que tendras en modo Advanced dale al botón de "Libraries..." Ahi tienes las distintas librerias que incorpora el programa.



Mirate este video: [youtube=640,360]http://www.youtube.com/watch?v=YXvvVLSPaY4[/youtube]

Casualmente hace algo muy similar a lo tuyo.


Hasta aquí llego yo por hoy. Suerte y cuando lo termines ponlo por aquí.


Un saludo.

Vale. Encontrado.


Tienes que abrir el PSPICE Manager. Que es el que creara el proyecto y a la izquierda tienes los distintos programas a utilizar para diseñar el proyecto.


De momento lo que he visto es que desde ahi creas el proyecto y a la izquierda le das  a el Schematic. Para poner componentes en el Schematic le das a Draw en el menu de arriba y ahi le tiene que dar en "Get New Part". Ahi, dale a "Advanced" para buscar en la definicion de los componentes y pones "NAND". Selecciona el primero y dibuja el circuito que tienes en el mensaje anterior que te puse.


Ahora solo falta averiguar como meter las señales en las patillas correspondientes, como en la que te pase anterior mente (en A y en B). Y cómo meter una sonda en la salida.

Buenas.


Mira, lo que te esta pidiendo es la función XOR, que en este caso es esto:

http://commons.wikimedia.org/wiki/File:XOR_from_NAND.svg


Aqui tienes un tutorial en español en youtube para iniciarse en el Schematics de PSPICE. Los programas "Schematic" son para diseñar circuitos, veras que se llaman igual para distintos editorioes como CircuitMaker, por ejemplo.

[youtube=640,360]http://www.youtube.com/watch?v=qHLbP2gaWXk[/youtube]



Aqui tienes una descarga directa a PSPICE: http://dcse.die.upm.es/Grupo4445/91pspstu.exe


Busca el Schematic, en Windows siete con escribir Schematic en el buscador de INICIO sobra, pero en otros sistemas a lo mejor tienes que meterte en la carpeta de archivos de programa de ese programa.

Estoy curioseándolo ahora mismo. El PSPICE consta de varios programas, para diseñar, analizar, etc. Por lo que a lo mejor tienes que usar varios para hacer lo que quieres hacer. (No se si puedes hacerlo todo desde uno solo como en Proteus).


Asi que bueno, busca el programa Schematic y ábrelo, ahi podras hacer las puertas NAND y meter la señal. Cuando tenga noticias nuevas las cuelgo, he visto el mensaje justo cuando estaba haciémdolo.

[Que carrera es esa y que universidad es esa?]

Una pregunta...

Estas en la universidad, en el segundo cuatrimestre de electrónica y todavía no os han enseñado puertas lógicas? Que carrera es esa y que universidad es esa? Yo he hecho un grado superior de Desarrollo de Productos Electrónicos y lo primero que dimos fueron las puertas lógicas, porque de lo contrario no aprendes nada.


Por otro lado: Google. Segundo enlace. Ahí tienes la configuración de una XOR con puertas NAND. Podrías haber buscado un poco... y si no sabes es importante que aprendas a hacerlo porque en este mundillo es esencial manejarse con palabras claves y Google.

https://www.google.es/#hl=es&sclient=psy-ab&q=xor+wikipedia&oq=xor+wikipedia&gs_l=hp.3..0j0i30l2j0i5i30.713.2926.0.3015.13.12.0.1.1.0.180.1516.1j10.11.0...0.0...1c.1.5.psy-ab.wuveoH48U4Q&pbx=1&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&bvm=bv.43287494,d.d2k&fp=d2656515540ffae3&biw=1280&bih=699

Ahi en wikipedia tienes la solución a tu ejercicio... la creación de el circuito para resolver tu problema, ahora solo te falta aprender a usar PSPICE.



No te lo voy a poner todo tan fácil. Con dos búsqueda más he encontrado el PSPICE para descarga de estudiantes y tutoriales en Google y Youtube.



¿En serio que no sabes nada de electrónica y te han preguntado eso? ¿Que carrera es y que universidad? Tengo curiosidad...


¿Qué es una señal periódica? Macho no me jodas... otra busqueda rápida
https://www.google.es/#hl=es&gs_rn=5&gs_ri=psy-ab&tok=89bV6d17-QFHpCMqqUYfAw&pq=pspice&cp=9&gs_id=y&xhr=t&q=se%C3%B1al+periodica&es_nrs=true&pf=p&sclient=psy-ab&oq=se%C3%B1al+per&gs_l=&pbx=1&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&fp=d2656515540ffae3&biw=1280&bih=699




¿Como aumenta un numero binario?

0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111


¿Qué puedes deducir de aquí? Que el bit de la derecha cambia en todos los niveles, por lo tanto lleva una velocidad constante no? Y el segundo bit empezando por la derecha cambia multiplicando por dos el tiempo que tarda el primero. Verdad? Por lo tanto que tienes que hacer? Configura una de las señales a una velocidad de 1 Herzio, mismamente, que sera la que marcara el segundo bit de la derecha que es el que tendría que ir más lento y configura una señal de entrada por otra de las patillas con una señal de 2 Herzios (esto te lo dice el propio enunciado).


Luego, en PSPICE no lo se porque nunca lo he usado, pero seguro que también las hay, en Proteus hay herramientas para poder ver esas señales que tu le pones, como si fuera un organigrama. Y las verás. Verás algo como esto pero con solo dos señales, que podrían ser perfectamente las dos de arriba, dos señales periódicas una que es el doble que la otra:

Soy cabezota, pero sigo en las mismas, en que carrera y en que universidad estas? Por simple curiosidad.


Un saludo.

[no habilites las interrupciones hasta que el FLAG de escritura en la EEPROM se active]

He encontrado esto por ahí:

http://www.ucontrol.com.ar/forosmf/tutoriales-guias-y-cursos-en-ucontrol/datasheet-en-espanol-pic12f629675/msg7676/#msg7676


Es el datasheet en español de ese PIC que estas usando.



Pues a simple vista parece que estas cumpliendo con lo que pide el datasheet. ¿Has probado a debuggear paso a paso y revisando el codigo de el programa con el MPLAB o con Proteus para ver en que paso se queda enganchado?

Es posible que el código de escritura en la EEPROM esté bien y esté fallándote otra cosa.


Por otro lado. ¿No era necesario esperar a que la operación de escritura en la EEPROM se realizase con éxito? Aunque en el datasheet ponga habilitar la interrupción inmediatamente después de mandar la escritura, la escritura requiere un tiempo para que no de fallos y como bien dice, hay que deshabilitar interrupciones para evitar fallos, puesto que no debe interrumpirse.


¿Habías probado alguna vez a escribir la EEPROM de esa manera? ¿Te ha funcionado?


Prueba a darle las ordenes de escritura pero no habilites las interrupciones hasta que el FLAG de escritura en la EEPROM se active. Métele un búcle que compruebe el FLAG.

En tu caso creo que es el bit 7 (EEIF) de el registro PIR1. Asi que ya sabes:

Código [Seleccionar] Expandir

Bucle        btfss  PIR1,EEIF
                goto  Bucle

... Habilita interrupciones y sigue con tu programa




Si te funciona pónnoslo aquí para corroborarlo. Gracias.



Un saludo.

[BITS Z, DC y C DE STATUS]

Es simple compañero.

En las especificaciones de cada comando te suele poner los bits que se ven afectados del STATUS en caso de realizar una operación y la forma de el comando y su uso.


En el caso de hacer una ADDWF, SWAP, INCF, DECF o cualquier otro comando que te permita guardar en F o en W podras hacerlo de las dos maneras.

Por ejemplo, en el caso de el comando ADDWF:

Sintaxis:

Código [Seleccionar] Expandir

ADDWF      f,d
Estados afectados: C, DC, Z

El contenido del registro W se suma al registro F. Si "d" es 0, el resultado se almacena en W; si "d" es 1, el resultado se guarda en el registro "f".


Al programar en MPLAB tienes que tener en cuenta que MPLAB interpretara ciertos comandos y los convertirá automaticamente sin problemas a lo que tendrían que ser realmente. Con esto quiero decir, que si tu en el comando de ADDWF pones:

Código [Seleccionar] Expandir

ADDWF REGX,F -> Suma W con REGX y lo guarda en REGX.

seria lo mismo que poner:

ADDWF REGX,1

Solo que tu, en vez de ver un 1 ves una F y lo identificas mucho mejor.

Podrías hacer lo mismo con el registro W en vez de poner un 0.


La verdad es que de unos PICS a otros varían algunas cosas, pero en los datasheets de cada PIC esta todo. Veras los comandos y los estados afectados al terminar la operación. Cuando termina la operación si ves un estado afectado tendrás que ver por qué ese estado se ve afectado. Es decir, cuando desborda, si rotas un registro con RRF y sale un 1 que se va al C, etc... pero a eso ya llegarás más adelante.

Por eso te digo que en el caso este, como estas realizando una resta, que posiblemente será inferior a 0, tienes que poner una comprobación después de la operación para ver si el estado que te identifica que es negativo está activo.

Termina de testearlo y me cuentas de nuevo. Haz sumas y mira los estados. Haz restas en las que el resultado sea positivo y mira los estados y haz lo mismo con resultados negativos.


Por cierto. Si trabajas normalmente con MPLAB no hace falta que estes cambiando constantemente los numeros dentro de el programa. En esa misma ventana de "File Registers" en la parte de abajo dale a HEX.


Configura los registros de REGX, REGA y tal en las posiciones que te interesen. Por ejemplo en la 30, 40 y el resultado en la 50.

Y hazlo todo con los registros, es decir, muevo el registro A a W, se lo resto a B y lo almaceno en W, luego lo meto en RESU. Algo asi:

Código [Seleccionar] Expandir

list p=16f876, f=INHX8M, r=hex
include "p16f876.inc"

MINU equ 20
SUST equ 30
RESU equ 40

org 0

Inicio         movf SUST,W
subwf MINU,W
movwf RESU


goto Inicio

end



Con esto asi y con la ventana de FILE REGISTERS simplemente tendrás que indicar la cantidad en FILE REGISTERS, das doble click en el registro y pones la cantidad, simulas el programa paso a paso en MPLAB y vas viendo los estados afectados y en las casillas de los registros el resultado.


Por cierto, importante, asegurate también de revisar y borrar los estados afectados después de una operación, porque puede ser que lo siguiente que hagas también dependa de un estado despues de otra acción (aunque no es el caso) y que como esta afectado por la anterior, a lo mejor en esta no se ha visto afectado y te da error. Digamos que en la primera resta te da negativo, los estados se ven afectados y luego en la segunda resta no se ven afectados, como el estado no ha vuelto a su posición inicial el segundo resultado estará mal.


BITS Z, DC y C DE STATUS

Z: Se pone a 1 después de una operación aritmético lógica con resultado 0. Se queda en 0 cuando el resultado lógico es distinto de 0.

DC: Bit de acarreo o debe. Se pone a 1 cuando hay acarreo en el cuarto bit (este no lo usarás prácticamente).

C: Bit de acarreo o debe en las instrucciones ADDWF, ADDLW, SUBLW, SUBWF. Se pone a 1 cuando hay acarreo en el 8 bit.


¿Esto que quiere decir?

- Que en estas operaciones, o en cualquier programa que quieras detectar que es un 0 podrás hacerlo a través de el bit Z de el status con btfsc.

- Compruebas el carry que estará en 0., que se verá afectado después de realizar la resta y tendrás que hacer el "complemento a dos" sobre el resultado que te ha dado para sacar la cantidad exacta. Que es tu caso. Tenías razón. Al estar en 1 indica que es positivo, y al estar en 0 indica que es negativo.



Entonces, en el programa tendríamos que incluir esto:

Código [Seleccionar] Expandir

list p=16f876, f=INHX8M, r=hex
include "p16f876.inc"

MINU equ 21
SUST equ 31
RESU equ 41
SIMB equ  40


org 0

Inicio bcf SIMB,0 ; Borramos indicador de símbolo, que estara en el bit 0 de SIMB.
movf SUST,W ; Movemos el sustraendo a W.
subwf MINU,W ; Restamos sustraendo a minuendo.
movwf RESU ; Guardamos resultado.

btfsc STATUS,C ; ¿Resultado negativo? ¿C=0?
goto Inicio ; No: Vuelve a inicio y hace otra operación.

bsf SIMB,0 ; Si: Incrementa la marca de el símbolo.
movlw b'11111111' ; Es lo mismo que poner 0xFF, la b indica binario.
xorwf RESU,F ; XOR entre F y W, guarda en RESU.
incf RESU,F ; Haciendo XOR con FF le damos la vuelta y sumándole 1 (incrementando 1 con este comando) para terminar el "Complemento a Dos".

goto Inicio ; Vuelve a inicio y hace otra operación.
end



Y, como vemos, he añadido el complemento a 2.


Si te da "11111100" hazle una operación XOR con FF.

11111100
11111111
-----------
00000011

Y le sumas 1, que te dará el cuatro . No lo he comprobado, pero en teoría debería funcionar. Mañana lo miro, que ya es tarde.


Y ya... rizando el rizo, si sumas dos números que te den un resultado mayor a un byte tendrías que incrementar otro registro al lado de el resultado y... eso ya es otro capítulo.



Vaya testamento... me he liado bastante a escribir. Espero que te haya servido.

Suerte, cualquier duda ya sabes  

Un saludo.

¿Quien manda los datos a través de la USART para recibirlos en el PIC18F2550?


Mira los datasheets de ambos, por normal general suelen incluir una tabla donde especifican la cantidad exacta que tienes que cargar para trabajar a X baudios (9600? mira a ver si aparece en los datasheets). Y si configuras los dos con lo mismo para que trabajen a los mismos baudios, la conexión estaría bien. Después de eso deberías mirar las ordenes de recepción (en caso de que la transmisión sepas que va perfecta, sino compruébala también).

O también puedes aprender a hacerla tu mismo, sin tener que esperar a mandarlo, que lo hagan y que te lo traigan.

http://blog.bricogeek.com/noticias/tutoriales/tutorial-como-hacer-una-placa-pcb-desde-principio-a-fin/


Yo he hecho de estas y es muy fácil. En un par de horas tienes la placa lista.

Creo que lo que hacen realmente las memorias es guardar según una dirección.

Es decir, las memorias tienen registros y en estos registros se almacenan los bytes. Cualquier tipo de memoria funciona asi, porque para poder "dirigirnos" a ellas, mediante Drivers o cualquier instrucción, incluso manualmente siguiendo el proceso que marca el fabricante de su propia memoria en concreto, tenemos que saber que procesos tenemos que seguir para poder comunicarnos con ellas.


Todas las memorias funcionan igual, lo que varía es su hardware. Es decir, RAM, EEPROM, EPROM, ROM, FLASH... Cada una tiene su sistema de almacenamiento y cada una tiene su forma de conexionarse con los demas componentes y cada unas siguen unas instrucciones de control concretas. Unas se pueden grabar una sola vez, otras se pueden grabar varias veces, otras almacenan datos aunque pierdan la tensión, otras, al perder la tensión, se resetean automaticamente (RAM).

Cuando quieres interactuar con una memoria sigues los pasos que te marca el fabricante para poder leer o escribir en ella, que serán impulsos distintos por sus patillas de control, y luego le mandas o lees el dato por sus patillas de entrada y salida de datos.

El proceso es sencillo, todo en un ordenador es un impulso electrico, todo es 1's y 0's, si  mal no recuerdo el 1 eran 5v y el 0 1,3v . Estos impulsos van de un lado a otro por los buses (que no son mas que "cables" , o mas bien vías en el circuito impreso).

Esto no es "tan así" compañero. El uno lógico y el cero lógico dependen de los integrados. Existen distintas familias de integrados y cada integrado tiene un minimo de entrada de tensión para detectar un uno o un máximo de tensión para detectar un cero y un máximo y un minimo de salida de 1 y 0.

Esto se establece en los datasheets de los componentes y se llaman VOL (Voltage Output Low), VOH (Voltage Output High), VIL (Voltage Input Low) y VIH (Voltage Input High).

Las placas de memoria RAM no dejan de ser un conjunto de integrados conexionados entre si para conseguir las placas que tenemos en los ordenadores de XGB. En los ordenadores si que me imagino que habrá un standard de voltajes para compatibilizar al máximo todas las piezas que pueden formar un ordenador.

Pero este tema no es para tratar de esto.



Un saludo!

Código (mpasm) [Seleccionar] Expandir

list p=16F84
include "P16F84.INC"

REGA equ 0x11 ; REGISTRO A
REGB equ 0x12 ; REGISTRO B DE USUARIO
REGC equ 0x13 ; REGISTRO C DE USUARIO
REGAUX equ 0x15 ; REGISTRO TEMPORAL, AL FINAL CONTIENE EL RESULTADO.

org 0x00 ;vector de reset
goto inicio

org 0x05 ;el programa empieza en la posición 5 de la memoria

; Cargamos registros con los datos.
inicio MOVLW 0X01 ; Carga 01 en W.
MOVWF REGA ; Carga W en REGA
MOVLW 0X02
MOVWF REGB
MOVLW 0X0A
MOVWF REGC

;______________________________
BUCLE ;

MOVF REGA,W ; A+B
ADDWF REGB,W ;     "
MOVWF REGAUX ; A+B+A+B -> REGAUX
ADDWF REGAUX,F                 ;      "
MOVF REGC,W ;
SUBWF REGAUX,F ; REGAUX - REGC -> REGAUX
GOTO BUCLE ;

END



Por cierto, volviendo a ver tu código, te recomiendo que si vas a programar en ASM lo hagas lo mas simple posible o cuando empieces a programar con varios modulos (ADC, RS232, I2C, cualquier cosa) te vas a liar con todo.

Empezando por lo más básico, cuando quieras guardar un fichero en W te aconsejo que lo especifiques con W y no con 0, porque sino luego, no lo veras bien (cuando adquieras experiencia sera otra cosa), y lo mismo cuando quieras guardarlo en un mismo fichero.

Por otro lado, consejos. Optimización, cuanto más pequeño sea el programa mejor. Los microchips tienen mucha memoria, pero cuando hagas programas largos una buena optimización es lo mejor, sobre todo cuando usas tablas para sacar caracteres de frases y trabajas sumandole W a PCL, que en un cambio de página puede significar que el programa no te funcione.

Refiriendome a la Optimización: ¿Realmente te hacen falta tantos registros? Te he eliminado el registro final, el registro temporal sera quien lleve el resultado en ultimo momento.

Acostumbrate a mantenerlo siempre lo mas ordenador posible, o no te aclararás ni tu mismo. Te lo digo por pura experiencia.



Un saludo.