Imprimir Página - PIC16F1707 Ejemplos básicos

Título: PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 29 de Octubre de 2015, 17:51:23

:) Que tal amigos hace unos días me compre unos pics por una buena oferta y llego la hora de probarlos, me llamo la atención las capacidades que tiene es de los últimos 16F que saco microchip y esta rondando por los 1.4usd cada uno, lo consulte en digikey. Bueno en la imagen anexa tenemos sus principales características. Abro este hilo para poder ir colgando códigos ejemplo que nos puedan servir a la comunidad y también para que me ayuden a corregir si es que tengo errores. Así mismo si alguien tiene ya ejemplos con este micro no dude en compartirlos.

Saludos

Título: PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 29 de Octubre de 2015, 18:05:53

Algo de lo que mas me gusto son los 8 canales touch que tiene y que corre a 8MPIS :) para ser un 16F lo considero muy bueno, dentro del data sheet encontré que tiene 8 bancos de memoria, lo cual para mi era completamente nuevo ya que siempre he trabajado con micros que tienen máximo 4, cabe mencionar que regularmente trabajo en versiones del MPLAB 8.xx porque me agradan mas, para poder manejar este micro es necesario el MPLABX donde encontré esta instrucción:

MOVLB La cual según lo entendí, mueve una literal al BSR que es el registro de selección de banco. Para poder configurarlo.

Otro registro que considere importante es el OSCCON donde configure el Oscilador interno. De acuerdo al la hoja de datos tenemos:

- Oscilador interno de precisión de hasta 16Mhz con un PLL de 4x entonces la lógica dice que podemos llevarlo a 64Mhz?

Esa es mi duda, yo lo deje así. En cuanto pueda haré la prueba en un osciloscopio para conocer la frecuencia real. Bien el primer código es:

Código: ASM

#INCLUDE "P16F1707.INC"
 
; CONFIG1
; __config 0xF9A4
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
; CONFIG2
; __config 0xDF7F
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
 
    CBLOCK  0X020
    RET
    RET2
    ENDC
 
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETFIE
 CONFIGURA_PIC
    MOVLB   0X01; MOVEMOS UN VALOR AL BSR PARA SABER EN QUE BANCO ESTAMOS
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLB   0X00
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    MOVLB   0X02
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    MOVLB   0X03
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    MOVLB   0X01
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
    MOVLB   0X00
    
 PRINCIPAL
    MOVLW   0XFF
    MOVWF   PORTB
    CALL    RETARDO
    CLRF    PORTB
    CALL    RETARDO
    GOTO    PRINCIPAL
    
    
RETARDO
    MOVLW   0XFF
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN
    END

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 29 de Octubre de 2015, 19:37:17

Tenes mal puesto el titulo, es PIC16F1707 , te olvidaste un 1.
Asi que si podes cambialo, asi de esa forma es correcto, el PIC16F707 es otro pic y tiene muy poco.
Sino cualquier cosa me avisas y lo cambio.

Citar

- Oscilador interno de precisión de hasta 16Mhz con un PLL de 4x entonces la lógica dice que podemos llevarlo a 64Mhz?

No, la entrada al PLL es de 4 a 8Mhz, lo cual llegaria maximo 32Mhz

Citar

MOVLB La cual según lo entendí, mueve una literal al BSR que es el registro de selección de banco. Para poder configurarlo.

Exacto, como ya son mas bancos, imagino que debe ser feo estar cambiando 5 bits y encima buscar el banco con el registro, entonces tenes una instruccion para eso. Los PIC18 ya lo traian a esto, por que tenian 16 bancos facilmente los primeros.
En realidad traen varias mas instrucciones como ya habras visto.

Citar

dentro del data sheet encontré que tiene 8 bancos de memoria

Tiene 32 xD

Y el OSCCON lo tocas para modificar la frecuencia del oscilador interno o activar el PLL si no lo activaste con los fuses, o cambiar el reloj de externo a interno, o al reves.
Tambien en los puertos tenes Open-Drain, Slew-Rate e Input-Level como algo "nuevo"

Tambien hay otras cosas buenas que vas a encontrar :P

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 05 de Noviembre de 2015, 03:34:08

Gracias KILLERJC por tus observaciones ya modifique algunas, :D no he actualizado debido a que he tenido un poco de trabajo. Estaba montandolo en proto todo el circuito ya que no tenia donde simular, me actualice la version de Proteus a la 8.3 y me sorprendio mucho ya que actualizaron los Micros y ya esta este PIC incluido en las librerias para simulación así mismo me di cuenta de que ya hay mas sensores para simular. Hace algunos meses trabaje con la LCD Nokia 5110, despues de unos dias pude hecharla a andar con ensamblador y un SPI por software, para aprender mas y aprovechando que tambien la LCD ya esta en proteus voy a realizar un ejemplo de como utilizarla pero con el SPI que incluye el micro por hardware. De cualquier modo esta abierto este tema por si alguien desea contribuir ;-)

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 05 de Noviembre de 2015, 03:50:03

Te dejo a vos que lo llenes con ejemplos :P

En especial sobre aquellos que cambia sobre la arquitectura de los pics 16F viejos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 05 de Noviembre de 2015, 04:01:07

Jeje gracias KillerJC por ser tan atento :lol: bueno pues creo que siempre es bueno poder aprender mas. Aqui anexo mi diagrama, leyendo la hoja de datos me encontre con algo completamente nuevo.Un Módulo PPS.... :shock: aun no se que es pero lo poco que lei es para asignar los pines de ciertos perifericos a donde tu desees. Crei que para configurar el SPI seria como los otros :? pines ya definidos para SDO y SDI. La sorpresa es que el unico al parecer fijo es SCK.

Pero bueno vamos leyendo un poco mas sobre este PPS y veamos como trabajar con el. :o

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 05 de Noviembre de 2015, 04:06:12

Espero ir entendiéndolo bien, anexo una foto del bloque simplificado de estos PPS. Por lo que entendí y si es que comprendo mal les pido me orienten, tenemos PPS de entrada y PPS de salida. Los cuales pueden permitir entrar información o salir segun sean configurados... eso creo :?

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 05 de Noviembre de 2015, 11:21:41

El PPS es una de las cosas buenas que me gustan de Microchip, Como su nombre lo dice Peripherical Pin Selection permitela seleccion del pin a un modulo, Esto termina con eso de que ciertos pines eran para un modulo, y con esos pines no podias usar el USB por ejemplo. Vi otras empresa pero a lo sumo suelen tener pines fijos o maximo 2 opciones, tal ves por la frencuencia en la cual se manejan y lo complejo que seria hacerlo para 100 pines xD.

El PPS no acepta todos los modulos. sino que acepta algunos nomas
Como entrada creo que acepta todos, Pero solo permite al puerto A y C (bit0 a bit6 de ambos puertos) para servir de entradas.

Como salida solo es posible seleccionar a los siguientes modulos

• EUSART (synchronous operation)
• MSSP (I2C,SPI)
• COG (auto-shutdown)

Por lo tanto vas a tener registros para cada salida de unos de esos modulos

10010 = Rxy source is SDO
10001 = Rxy source is SDA(1)
10000 = Rxy source is SCK/SCL(1)

En el banco 28 tenes para configurar cada pin como entrada, y en el banco 29 tenes los pines para usar como salida.
Algunos requieren estar configurados como entrada Y salida al mismo tiempo, tal cual seria el SDA del I2C , o en la UART si es sincrono, un pin funciona como ambos, entrada y salida.

PD: Seguis teniendo mas cosas, nomas que estas mirando los modulos nomas xD

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 07 de Noviembre de 2015, 03:44:11

KillerJc vaya que si tiene bastantes cosas nuevas para mi :o de las cuales estoy sorprendido. Estuve leyendo un rato el datasheet y bueno pues me encontré efectivamente lo que tu dices, hay que configurar los registros Rxy de acuerdo a lo que necesitemos. Pero antes de eso si no me equivoco, microchip recomienda desbloquear los PPS configurarlos y después volver a bloquearlos para asegurar que no haya cambios inoportunos. Bueno acá el ejemplo de como desbloquear y bloquear sacado del datasheet.

Código: ASM

; suspend interrupts
bcf INTCON,GIE
; BANKSEL PPSLOCK ; set bank
; required sequence, next 5 instructions
movlw 0x55
movwf PPSLOCK
movlw 0xAA
movwf PPSLOCK
; Set PPSLOCKED bit to disable writes or
; Clear PPSLOCKED bit to enable writes
bsf PPSLOCK,PPSLOCKED
; restore interrupts
bsf INTCON,GIE

Bueno pues esa es la recomendación.

Aun no terminaba de comprender Rxy a que se refería y como era que se iban a configurar los PPS. Busque mas información sobre ellos y ahora creo que funciona de la siguiente manera si me equivoco corrijanme por favor.

Rxy

Donde R se refiere al registro.
x al puerto y
y al pin

Para ser mas objetivos si deseo asignar una salida SDO por ejemplo al pin RC0. Como menciono KillerJC anteriormente, hay que mover un valor= B'00010010'

Obtenido de la data en la pagina 140 donde nos indica que al cargar este valor su fuente sera SDO.

Mirar la imagen anexa.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 07 de Noviembre de 2015, 04:34:37

:) Después de jugar un rato con las instrucciones ya logré enviar datos tal cual lo configure. Sin interrupciones solo con la bandera. Es un ejemplo sencillo donde envío un dato vía SPI. Bajo la siguiente configuración.

Código: ASM

; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BCF     PPSLOCK,PPSLOCKED
    BANKSEL RC0PPS
    MOVLW   B'00010010'
    MOVWF   RC0PPS
    MOVLW   B'00010000'
    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BSF     PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL SSP1CON1
    MOVLW   B'00110000'
    MOVWF   SSP1CON1
    BANKSEL PORTB

Con esto configure el RC0 como SDO y el RC1 como SCK.

Obtuve una transmisión correcta con el siguiente código.

Código: ASM

MOVLW   0XFF
    CALL    DATO_SPI
     CALL    RETARDO
    ;;;;;;;;;;;;;;;;;;;;;
    MOVLW   0X03
    CALL    DATO_SPI
     CALL    RETARDO
    GOTO    PRINCIPAL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;    
DATO_SPI
    BSF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPI
    BTFSS   PIR1,SSP1IF
    GOTO    WSPI
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN

Parece que todo OK. si ven algún error me ayudan....

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 07 de Noviembre de 2015, 04:49:37

Bueno como ya solucionamos la parte del SPI que al parecer trabaja bien, ahora veamos que hay con respecto a la LCD Nokia 5110.

Como sabemos es una LCD gráfica con comunicación SPI.

(http://shop.boxtec.ch/images/45040_a.jpg)

Esta es la imagen que encontré adecuada.

Donde tenemos la siguiente información:

- Pin1 Vcc=2.7 a 3.3V
- Pin2 GND
- Pin3 Chip Select
- Pin4 Reset
- Pin5 D/C Selección de Dato o comando
- Pin6 Din Entrada de datos
- Pin7 SCK Señal de Reloj
- Pin 8 LED

Como vemos esta imagen tiene los pines de la misma manera y numeración que en el modelo de proteus.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 07 de Noviembre de 2015, 04:52:29

Sacado de la hoja de datos de la LCD anexo una imagen donde vemos el modo de transmisión de datos de 1 Byte que ha quedado compatible con nuestra configuración.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 07 de Noviembre de 2015, 04:59:57

También sacado del data sheet anexo el set de instrucciones de la LCD. Seguido de el set tenemos la parte de inicializacion de la LCD la cual consta de los siguientes pasos.

- 1. Reset por Software
- 2. Function Set
- 3. Display Control
- 4. Set y Address of RAM
- 5. Set x Address of RAM
- 6. Control de temperatura
- 7. Bias Value

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 07 de Noviembre de 2015, 11:50:06

Excelente.. Como te vas ya a la aplicacion te voy a dejar unas lineas para que las veas y las apliques si es necesario.

- Grabado automatico del contexto al entrar a la interrupcion. Al contexto me refiero a: W,STATUS,FSR0,FSR1,PCLATCH y BSR
- Acceso indirecto: Aca tenes 2.

1- Como ves el acceso a bancos es complejo. Crear un buffer grande lo es ya que deberias estar vigilando constantemente si superaste la direccion para saltar al otro punto de registros del proximo banco, el acceso indirecto te permite hacer esto automaticamente, Entonces si tu acceso indirecto esta en 0x6F en ves de pasar a 0x70 (que se una posicion de memoria comun a todos los bancos, pasa a 0xA0 del otro banco, es decir se saltea todos los SFR tambien
2- Con el acceso indirecto podes acceder a la memoria de programa, como si esta estuviera mapeada de forma lineal, Antes unicamente podias hacerlo con las tablas, ahora con el acceso indirecto tambien. Esto es interesante, ya que te olvidas de estar pensando en que los CALL tendrias qeu cambiar la pagina O ubicar la tabla si o si al comienzo de una pagina de la flash. Sino que el acceso indirecto posee todos los bits y podrias simplemente tomar uno detras de otro.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 07 de Noviembre de 2015, 18:21:33

KillerJC siempre con buenos consejos, mira aun no manejo las interrupciones y me quedo un poco claro lo que me has explicado. Sabes :( siempre he batallado con el direccionamiento indirecto honestamente no lo se usar, me caería bien empezar a hacer algo con los SFRs en este PIC. Que consejo me das como un buen método de aplicación y aprendizaje del uso de el direccionamiento indirecto?

Mientras tanto cuelgo el código realizado para trabajar con esta LCD. Adjunto la imagen de la simulación.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    RET
    RET2
    ENDC
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETFIE
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
    BANKSEL PORTA
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    BANKSEL LATA
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    BANKSEL ANSELA
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    BANKSEL TRISA
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BCF     PPSLOCK,PPSLOCKED
    BANKSEL RC0PPS
    MOVLW   B'00010010'
    MOVWF   RC0PPS
    MOVLW   B'00010000'
    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BSF     PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL SSP1CON1
    MOVLW   B'00110000'
    MOVWF   SSP1CON1
    BANKSEL PORTB
    
    #DEFINE LCD_NOKIA   PORTC,2
    #DEFINE RST_NOKIA   PORTC,3
    #DEFINE DC_NOKIA    PORTC,4
 
    BSF     RST_NOKIA
    BSF     LCD_NOKIA
    CALL    INI_LCD_NOKIA
 PRINCIPAL
 ;H
    MOVLW   0X00
    CALL    DATO_SPI
    MOVLW   B'11111110'
    CALL    DATO_SPI
    MOVLW   B'00010000'
    CALL    DATO_SPI
    MOVLW   B'00010000'
    CALL    DATO_SPI
    MOVLW   B'11111110'
    CALL    DATO_SPI
    MOVLW   0X00
    CALL    DATO_SPI
; O
    MOVLW   B'01111100'
    CALL    DATO_SPI
    MOVLW   B'10000010'
    CALL    DATO_SPI
    MOVLW   B'10000010'
    CALL    DATO_SPI
    MOVLW   B'01111100'
    CALL    DATO_SPI
    MOVLW   0X00
    CALL    DATO_SPI    
;L
    MOVLW   B'11111110'
    CALL    DATO_SPI
    MOVLW   B'10000000'
    CALL    DATO_SPI
    MOVLW   B'10000000'
    CALL    DATO_SPI
    MOVLW   B'10000000'
    CALL    DATO_SPI
    MOVLW   0X00
    CALL    DATO_SPI    
;A
    MOVLW   B'11111100'
    CALL    DATO_SPI
    MOVLW   B'00010010'
    CALL    DATO_SPI
    MOVLW   B'00010010'
    CALL    DATO_SPI
    MOVLW   B'11111100'
    CALL    DATO_SPI
    MOVLW   0X00
    CALL    DATO_SPI
  
        MOVLW   0X00
    CALL    DATO_SPI
    
    
    CALL    RETARDO
    GOTO    PRINCIPAL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
INI_LCD_NOKIA
    BCF     RST_NOKIA
    NOP
    BSF     RST_NOKIA
    ;CREAMOS UN RESET POR SOFTWARE DE LA LCD
    MOVLW   B'00100001'; SELECCIONAMOS MODO SET INSTRUCTION
    CALL    COMANDO_SPI
    MOVLW   B'11001111'; DEFINIMOS CONTRASTE
    CALL    COMANDO_SPI
    MOVLW   B'00100000';SLECCIONAMOS MODO NORMAL DE INSTRUCCION
    CALL    COMANDO_SPI
    MOVLW   B'00001100';DEFINIMOS MODO NORMAL DE DISPLAY
    CALL    COMANDO_SPI
    ;;;;;;;;;;;;;;;;;;;;;;;;; ACABAMOS LA INICIALIZACION DE LA LCD
    RETURN
DATO_SPI
    BSF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPI
    BTFSS   PIR1,SSP1IF
    GOTO    WSPI
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
COMANDO_SPI
    BCF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPIC
    BTFSS   PIR1,SSP1IF
    GOTO    WSPIC
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    
    
RETARDO
    MOVLW   0XFF
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN
    END

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 07 de Noviembre de 2015, 19:38:25

Te puedo dar ejemplos de aplicacion que seria mejor con un acceso indirecto que uno directo. El mas clasico es un buffer. Comencemos por un buffer de 4 lugares. En el que recibis datos por la UART o SPI y vas guardando los valores, finalmente tenes que hacer un checksum de esos valores. Como harias con direccionamiento directo el guardar estos 4 lugares ?

Código: ASM

Guardado
        MOVF    Indice, W       ;El indice de mi dato
        ADDWF   PCL, F          ; Utilizo una tabla para ir al programa donde debo guardarlo
        GOTO    Dato0
        GOTO    Dato1
        GOTO    Dato2
 
        MOVF    DatoUART, W
        MOVWF   Buffer3
        CLRF    Indice          ; Comienzo de nuevo
        RETURN
 
Dato0
        MOVF    DatoUART, W     ; Tomo dato y guardo
        MOVWF   Buffer0
        RETURN
Dato1
        MOVF    DatoUART, W
        MOVWF   Buffer1
        RETURN
Dato2
        MOVF    DatoUART, W
        MOVWF   Buffer2
        RETURN

Y eso es solo para guardarlo. Ahora debo sumarlos

Código: ASM

MOVF    Buffer0, W
        ADDWF   Buffer1, W
        ADDWF   Buffer2, W
        ADDWF   Buffer3, W

Bien, solo 4 instrucciones, bastante simple, o podria sumarlos apenas van llegando eso me ahorraria instrucciones. Ahora veamos usando acceso indirecto

Antes de comenzar cargo en el FSR los el valor de buffer0, es decir su direccion.

Código: ASM

MOVLW   low(Buffer0)
        MOVWF   FSR0L
        MOVLW   high(Buffer0)
        MOVWF   FSR0H

Lo que hago con eso es decir que cuando yo acceda a INDF0 , es lo mismo que acceder a la direccion de memoria que esta cargada en FSR0, en mi caso de acceder a INDF0 accederia a Buffer0. En los PIC16 normales harias eso, aca tenes una instruccion que lo hace por si solo, solo tenes que indicarle que FSR estas tratando y que hace depues
Ahora a guardar el dato:

Código: ASM

Guardado
        MOVLW   d'4'
        MOVWF   Contador
Loop
        MOVF    DatoUART, W
        MOVWI   FSR0++
        DECFSZ  Contador, F
        RETURN
 
Recargar_FSR
 
        MOVLW   low(Buffer0)
        MOVWF   FSR0L
        MOVLW   high(Buffer0)
        MOVWF   FSR0H
        RETURN

La instruccion MOVWI, lo que hace es guardar el dato de W en la direccion que tiene FSR0 (Buffer0 ) Luego a esa direccion la incrementa por 1 apuntando ahora a Buffer1 (Al incrementar por 1 tiene en cuenta ambos registros FSR0 L y H). Entonces la proxima ves que entre va a guardar W en Buffer1 y va a apuntar a Buffer2 y asi hasta que guarde en Buffer3 y apunte a lo que sigue, ahi en ese momento me va a dar una igualdad el codigo y va a reponer el valor de FSR

Para sumar seria algo parecido

Código: ASM

Guardado
        MOVLW   d'4'
        MOVWF   Contador
        CLRF    Suma_Total
        CALL    Recargar_FSR    ;Nos aseguramos que empezamos del comienzo
Loop:
        MOVIW   FSR0++
        ADDWF   Suma_Total, F
        DECFSZ  Contador, F
        GOTO    Loop                    ; Todavia quedan para sumar asi que vuelve al loop
        RETURN                          ; No queda mas nada

Nuevamente veo a que llegue al final y de ser asi salgo. Esta ves la instruccion es inversa (MOVIW ), tomo desde donde apunta el FSR0 y lo guardo en W. Y luego aumento FSR0.

Perfecto, pero para que complicarse la vida por 4 valores? Ahora supone que tenes un buffer de 32 lugares. No es nada lindo hacerlo con acceso directo, Y con acceso indirecto solo deberia cambiar esto (en ambos lugares ):

Código: ASM

MOVLW   d'4'

por un

Código: ASM

MOVLW   d'32'

Y listo funcionando :P.

Solo hay incrementos ? No. Esa instruccion permite pre y post incremento y decremento

Código: ASM

MOVWI FSR0++      ; Guarda y luego aumenta
MOVWI  ++FSR0     ; Aumenta y luego guarda
MOVWI  FRS0--       ; Guarda y luego decrementa
MOVWI  --FRS0       ; Decrementa y luego guarda.
MOVWI  k[FSR0]     ; Guarda solamente, no incrementa ni decrementa., igual que hacer MOVWF INDF0

--------------------------------------------------------------------------------------------------------------

Ahora veamos un poco mas tu ejemplo.
viste el codigo que te llevo hacer un Hola no ?

Entonces hagamos algo simple para comenzar.

Vamos a crear una tabla ( no recuerdo si esta correctamente definida asi, no tuve tiempo de mirar el manual del MPASM )

Tabla:
.dt 0x00, 0xFE, 0x10, 0x10, 0xFE, 0xFC, 0x82, 0x82, 0x7C
.dt 0x00, 0xFE, 0x80, 0x80, 0x80, 0x00, 0xFC, 0x12, 0x12
.dt 0xFC, 0x00

Es un total de ... 20 datos que envias. En ves de binario los puse como hexadecimal

Código: ASM

Tabla:
.dt 0x00, 0xFE, 0x10, 0x10, 0xFE, 0xFC, 0x82, 0x82, 0x7C
.dt 0x00, 0xFE, 0x80, 0x80, 0x80, 0x00, 0xFC, 0x12, 0x12
.dt 0xFC, 0x00
 
 
        MOVLW   low(Tabla)              ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   high(Tabla) | 0x80
        MOVWF   FSR0H
 
        MOVLW   d'20'                   ;Pongo la cantidad de datos a enviar
        MOVWF   Contador
 
Loop
        MOVIW   FSR0++                  ; Leo la tabla guardo en W y apunto al siguiente dato
        CALL    DATO_SPI                ; LLamo a la funcion de enviar
        DEFSZ   Contador, F             ; Decremetno el contador y si llego a 0 salgo, sino envio el siguiente
        GOTO    Loop
        ;Fin

Y listo. con acceso indirecto accediste a la memoria de programa, tomaste todos los datos que necesitaste y listo. Pero esto seguro que lo hiciste antes.. antes hacias:

Código: ASM

ADDWF   PCL, F
        RETLW   0x00
        RETLW   0xFE
        RETLW   0x10
        RETLW   0x10
        RETLW   0xFE
        ....
        RETLW   0x00

O podias usar la misma tabla que antes.. Pero esto se complicaba si la tabla estaba entre 2 paginas.
Recorda que PCL es un registros de 8 bits y por lo tanto solo puede direccionar 256 lugares. Si querias uno mas ya se ponia mas complejo por que tenias que modificar PCLATH a la entrada y a la salida de la funcion.

Esto con el acceso indirecto que permite leer la memoria de programa no hace falta. Ya que FSR0 ( Ly H ) son 16 bits y permiten direccionar toda la memoria, si hay un incremento de 1 no es complicacion para el mismo.

EDIT: Estos codigos ninguno esta probado, asi que tal ves tengan errores, pero es para que te des una idea de como usarlos, seguro que no deben de estar MUY errados. pero si puden tener algunos errores.
Corregido el tema de usar un contador

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 07 de Noviembre de 2015, 20:32:49

Otro ejemplo bastante simple y "tonto" seria el de tener que estar cambiando de bancos a cada rato. Aunque el PIC agrupa todo en un solo banco, a veces tenes que cambiar.
Supongamos que estas continuamente cambiando el valor de LATB, y ademas queres leer el PORTB. Uno esta en el banco 2 y otro en el banco 0.

Formas mas comun:

Código: ASM

MOVLB   0
        ;Leo PORTB
        MOVF    PORTB, W
 
        MOVLB   2
        ;Escribo LATB
        MOVLW   0x10
        MOVWF   LATB

Ahora con acceso indirecto, al comienzo le cargo el valor de direccion del LATB

Código: ASM

MOVLW   low(LATB)
        MOVWF   FSR0L
        MOVLW   high(LATB)
        MOVWF   FSR0H

Luego lo unico que hago es:

Código: ASM

MOVLB   0       ; Estoy en el banco 0, me aseguro
        ;Leo PORTB
        MOVF    PORTB, W
 
        ;Escribo LATB
        MOVLW   0x10
        MOVWF   INDF0

Como el acceso indirecto tiene 16 bits para direccionar no le hace falta tener que cambiar de "bancos". En cambio las instrucciones comunes que usan acceso directo ( es decir el dato esta en su opcode) solo usan 8 bits, por lo tanto es necesario cambiar de "banco". Para el acceso indirecto no existen los bancos, es lo mejor que podes tener ya que podes direccionar toda la memoria. Utiles en casos como grandes lugares de datos a rellenar. o incluso pedir datos.

Si quisiera leer los datos del PORTA, PORTB y PORTC como estan todos seguidos podria hacerlo tanto como un acceso directo como indirecto.
Como ves es medio complejo cargar la direccion en los registros, pero si va a un PIC18 te encontras que tenes una instruccion que te permite cargar la direccion.

Entonces en ves de hacer lo que hicismos arriba solo haria un

Código: [Seleccionar]

LFSR 0, LATB
Y cargaria toda la direccion ( por mas que sean mas de 8 bits ) al FSR0. Esto en los PIC18, este no lo posee.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 08 de Noviembre de 2015, 05:32:35

KillerJc muchas gracias por esos ejemplos. Vamos por partes para que termine de entender:

Cuando hablamos de FSRL y FSRH entiendo que estamos refiriéndonos a la dirección únicamente?
y cuando hablamos de INDF es el dato o valor contenido dentro de esa dirección o el que vamos a mover a esa direccion?

La instrucción MOWI es nueva para mi y me quedo clara. Un pequeño ejemplo si no me equivoco si yo tengo un DatoX alojado en una dirección 0x34 por decir un ejemplo. Puedo cargar un valor a DatoX poniendo las direcciones en FSRl y FSRH. Y la literal cargarla a INDF?

La instrucción MOVIW es inversa tal cual lo dijiste del INDF movemos a W y aumenta en 1 FSR. Entendido.

Muy claros todos los ejemplos ahora, una pregunta algo tonta las direcciones de los registros que utilizo como variables siempre las he utilizado con un CBLOCK 0x020 entonces la primera enseguida corresponde a 0x020 y así sucesivamente? Si es así hasta que dirección me limita?

Y respecto al último ejemplo, anexo una imagen de los SFRs sacada del Data donde encierro la dirección del registro LATA, aquí dos preguntas. La dirección que yo debería cargar es FSRH=0x01 y FSRL=0x0C ?

Y la otra es, si yo no le indico al FSR que incremente o decremente guarda la última dirección? Por ejemplo si siempre quisiera mostrar datos por LATB puedo dejar la dirección y solo mandarlos al INDF?

Perdón se me olvidaba, en los PIC18F esa última instrucción que mencionas es para cargar la dirección del registro que indicas?

LFSR 0, LATB

De tu ejemplo, LFSR 0,LATB quiero entender que LSFR es algo como cargar al FSR con dirección de R(LatB). El cero a que se refiere?

Gracias KillerJC y disculpa tantas preguntas. Me interesa aprender a manejarlos.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 08 de Noviembre de 2015, 10:08:17

Empecemos por que no hay preguntas tontas.

Citar

Cuando hablamos de FSRL y FSRH entiendo que estamos refiriéndonos a la dirección únicamente?
y cuando hablamos de INDF es el dato o valor contenido dentro de esa dirección o el que vamos a mover a esa direccion?

Exacto, tenes varios FSR, en ese pic hay 2 FSR0 y FSR1, cada uno con su propio INDF. en los FSR la direccion y el INDF como decis accedes a la direccion que apunta el FSR

Citar

La instrucción MOWI es nueva para mi y me quedo clara. Un pequeño ejemplo si no me equivoco si yo tengo un DatoX alojado en una dirección 0x34 por decir un ejemplo. Puedo cargar un valor a DatoX poniendo las direcciones en FSRl y FSRH. Y la literal cargarla a INDF?

Correcto. La instruccion es nueva para mi tambien. Pero la MOVWI te permite hacerlo sin tener que especificar que lo moves a INDF. Por eso puse que podias hacerlo de 2 formas

MOVWI k[FSR0]
MOVWF INDF0

Ambos son equivalentes. Utilizas distintas instrucciones,, pero el objetivo es el mismo, es guardar lo de W a donde apunta el FSR0, y no incrementar ni nada.

Citar

Muy claros todos los ejemplos ahora, una pregunta algo tonta las direcciones de los registros que utilizo como variables siempre las he utilizado con un CBLOCK 0x020 entonces la primera enseguida corresponde a 0x020 y así sucesivamente? Si es así hasta que dirección me limita?

Tenes que entender que hace CBLOCK, Con CBLOCK vos lo unico que haces es darle un valor constante a una palabra. Esto hace que tu codigo sea absoluto, es decir vos controlas exactamente donde va a estar cada variable

CBLOCK 0x20
Var1
Var2
ENDC

Var1 es una constante 0x20, y Var2 es una constante 0x21
Esto al ser una constante permite que uno pueda hacer:

MOVLW Var1
MOVLW Var2

Y es correcto, por que justamente Var1 es una constante. Hay otras formas para definir una variable, yo en un post de PIC18 creo que se trato el tema.
http://www.todopic.com.ar/foros/index.php?topic=45254.msg376570#msg376570

El usarlo asi o no hace de tu codigo por ahi mas dependiente del PIC y mas dificil de portar a otro PIC, ya que no solo te preocuparias sobre las instrucciones que son distintas sino que ademas tendrias que ver la memoria exacta. De la forma que digo yo el compilador se encarga solo de acomodar las variables donde hay lugar. Y puede evitar algunos problemas

Ahora respondiendo tu pregunta, No estas limitado en direccion. Personalmente si yo hubiera necesitado de variables muy usadas las hubiera posicionado de 0x70 a 0x7F que es compartido por todos los bancos, sino podes usar cualquier direccion que este como General Purpose Register, es decir:
0x20 a 0x6F - Banco 0
0xA0 a 0xEF - Banco 1
0x120 a 0x16F - Banco 2

Esos serian los unicos limites a respetar.

Citar

Y respecto al último ejemplo, anexo una imagen de los SFRs sacada del Data donde encierro la dirección del registro LATA, aquí dos preguntas. La dirección que yo debería cargar es FSRH=0x01 y FSRL=0x0C ?

Si asi es. Pero supongamos que cambias de micro y LATB ahora se encuentra en 0x0212 , si pones solo constantes vas a tener que cambiar eso tambien. con low(LATB) te da 0x0C y con high(LATB) te da 0x01, si por alguna razon existiera 3 bytes por que la memoria es MUY grande (24 bits), podrias usar upper(xx) esto daria el byte mas importante. Pero lo que queria recalcar es que usando high y low te olvidas de luego cambiar lo demas. si te fijas en tu .inc LATB esta definido como

LATB EQU 0x10C

Citar

Y la otra es, si yo no le indico al FSR que incremente o decremente guarda la última dirección? Por ejemplo si siempre quisiera mostrar datos por LATB puedo dejar la dirección y solo mandarlos al INDF?

El FSR no se modifica jamas por si solo, vos cargas la direccion, y a no ser que vos expresamente pidas con una instruccion que incremente o decremente, no lo va a hacer y va a mantener la misma direccion. Con lo cual tenes las dos opciones que nombre antes tanto con el MOVWI /IW como MOVWF para "acceder" a INDFx

Citar

Perdón se me olvidaba, en los PIC18F esa última instrucción que mencionas es para cargar la dirección del registro que indicas?

LFSR 0, LATB

De tu ejemplo, LFSR 0,LATB quiero entender que LSFR es algo como cargar al FSR con dirección de R(LatB). El cero a que se refiere?

La instruccion que puse no recuerdo si es correcta o no. Pero no debe estar muy lejos. Esa instruccion ocupa 2 lugares de memoria, pero en su opcode pueden tener hasta 12bits ( y no 8 como la mayoria ) entonces lo que hace es cargar los 12 bits de direccion de LATB a FSR0 , el 0 indica a que FSR lo envio.

Cualquier otra pregunta que se te ocurra, podes hacerla sin problemas

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 08 de Noviembre de 2015, 11:09:52

Creo que explicas demasiado bien KillerJC ((:-)) muchisimas gracias, bueno pues como me dejas la puerta abierta a otras preguntas. Los otros FSRs, funcionan igual? Y acaso sirven para poder manejar direccionamiento indirecto con 2 registros diferentes sin que se alteren el uno al otro?

Saludos y de nuevo muchas gracias.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 08 de Noviembre de 2015, 23:29:39

En ese PIC tenes 2 FSR, independientes uno de otro. Y si funcionan igual.

En otros PICs a veces algun FSR tiene unas propiedas mas. Por ejemplo en el PIC18 el FSR2 se usa en el modo extendido de instrucciones, los demas FSR ( 0 y 1 ) no se pueden usar para el acceso a memoria + offset. En fin esto es un caso especial, y activar el set de instrucciones extendido es un caso MUY raro de ver si alguno programa en ASM.

Respecto a un programa que use 2 FSR podria ser el de copiar un buffer a otro lado.

FSR0 = Buffer0
FSR1 = Buffer1

Y luego haces un

MOVIW FSR0++
MOVWI FSR1++

Repetis eso varias veces y estarias copiando los valores a otro buffer. Por mas que sean 64 valores solo necesitas repetir esas 2 instrucciones 64 veces. El FSR0 seria el origen y el FSR1 el destino, podria haber cargado la ultima posicion de memoria y haber invertido el buffer

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 09 de Noviembre de 2015, 00:57:16

Excelente información KillerJC :-/ deberiamos tener en el foro puntos por consejos dados y tu estarias repleto de puntos. Bueno sigo trabajando en ejemplos y los colgaré espero no equivocarme. Solo una pregunta más, las tablas las he manejado muy poco solo con el PCL y a lo mucho unos 20 saltos no más. Como ingreso la dirección de la tabla? Es decir como se donde le puedo asignar un origen? Si ocupo varias tablas para generar distintos caracteres que direccion le puedo dar a cada una?

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 09 de Noviembre de 2015, 01:23:35

De la misma forma que te di el ejemplo antes.. Supongamos que tenes una tabla

Código: ASM

Tabla:
.dt 0x00, 0xFE, 0x10, 0x10, 0xFE, 0xFC, 0x82, 0x82, 0x7C
.dt 0x00, 0xFE, 0x80, 0x80, 0x80, 0x00, 0xFC, 0x12, 0x12
.dt 0xFC, 0x00
 
 
        MOVLW   low(Tabla)              ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   high(Tabla) | 0x80
        MOVWF   FSR0H

El .dt hace que los datos que pones se transformen en instrucciones RETLW

.dt 0xFC, 0x00, 0x75

El compilador lo transforma en

RETLW 0xFC
RETLW 0x00
RETLW 0x75

Y Tabla ( es decir la etiqueta ) es la direccion del primer elemento de todos esos RETLW

Citar

Si ocupo varias tablas para generar distintos caracteres que direccion le puedo dar a cada una?

No entiendo por que necesitas tantos caracteres, si las letras estan en la ROM

Si vos decis que queres tener varios mensajes a mostrar en el LCD podrias tener algo asi:

Código: ASM

Mensaje1: .dt "Hola Hola Hola",0x00
Mensaje2: .dt "Aca otro mensaje",0x00
Mensaje3: .dt "Nuevo mensaje",0x00

Entonces luego cargas en el FSR la direccion de Mensaje1 2 o 3 segun quieras mostrar y envias al LCD hasta que encuentre un 0x00 el cual le va a indicar que termine el string ese

Código: ASM

Enviar_mensajes
 
        MOVLW   low(Mensaje1)           ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   high(Mensaje1) | 0x80
        MOVWF   FSR0H
        CALL Enviar                     ;Envio Mensaje1
 
        MOVLW   low(Mensaje2)           ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   high(Mensaje2) | 0x80
        MOVWF   FSR0H
        CALL Enviar                     ;Envio Mensaje2
 
        MOVLW   low(Mensaje3)           ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   high(Mensaje3) | 0x80
        MOVWF   FSR0H
        CALL Enviar                     ;Envio Mensaje3
 
        RETURN
 
Enviar
        MOVIW   FSR0++          ; W = [FSR0] , luego FSR0 = FSR0 + 1
        CALL    Enviar_a_LCD    ; Llamo a la rutina para que envie el valor de W
        MOVIW   k[FSR0]         ; Pregunto si el valor que esta ahora es 0, W = [FSR0], la instruccion actualiza Z
        BTFSS   STATUS,Z        
        GOTO    Enviar          ; No es 0 entonces la palabra sigue
        RETURN                  ; Es 0 entonces salgo

Observa que en los comentarios puse [FSR0] como para indicar el contenido de lo que apunta el FSR0.

Si tenes mas dudas te las repsondo, si seguis con los ejemplos veo si es posible indicarte algo para que quede mas compacto por ejemplo.

------------------

EDIT: No se si el valor que se carga es correcto y perteneciente a la etiqueta, tal ves para acceder correctamente a la memoria de probramaa se necesite ponerle un 1 en el bit 7
Tal cual puse en el caso del Mensaje 3.
Esto por que se necesita ese bit en 1 para acceder a la memoria de programa. Hay que probar , ya que es nuevo para mi tambien.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: RALF2 en 09 de Noviembre de 2015, 12:05:11

Hola amigos.
Killerjc, que hace esta instruccion: MOVLW low(Tabla), low(tabla) es una etiqueta?no entiendo como haces el llamado a la tabla y la toma de datos de la misma :? me lo podrias aclarar :mrgreen:

Gracias

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 09 de Noviembre de 2015, 12:34:11

Tabla es una etiqueta. La etiqueta no es mas que una direccion. Ejemplo cuando haces:

Código: ASM

Loop:
   GOTO  Loop

Eso es un loop infinito, "Loop" representa la direccion. "Loop" no es una instruccion y no ocupa espacio de memoria. Entonces el compilador luego reemplaza eso. Suponete que ese GOTO ocupa la posicion de memoria 0x350 , entonces Loop vale/representa 0x350, el compilador luego cuando lo pasa a codigo maquina o opcode pasa eso a

Código: ASM

GOTO 0x350

Recorda que el GOTO recibe un literal de hasta 11 bits ( no como la mayoria que solo acepta 8 bits )

Ahora con eso en mente, en el que el Label ( Etiqueta ) es simplemente la direccion. Cuando uno hace esto:

Código: ASM

low(Loop)

el resultado es un numero igual a 0x50 y si hago el high() el numero es un 0x03, como eso es un numero, muevo ese numero a W y luego lo pongo en el registro FSR, asi indicando el comienzo.

Solo decirte que este PIC es "especial" y permite que el acceso indirecto pueda acceder a la memoria de programa, ya que para el acceso directo esta mapeado como una memoria lineal
Un error mio es poner los valores asi nomas

Código: ASM

MOVLW   low(Tabla)              ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   high(Tabla)
        MOVWF   FSR0H

Eso es incorrecto. La direccion de memoria es correcta, pero la memoria mapeada comienza en 0x8000 para la flash.
Es decir En el acceso indirecto (FSR) la direccion 0x8000 corresponde al 0x0000 de la flash

Por eso mi edit diciendo que me habia equivocado. Y lo correcto seria

Código: ASM

MOVLW   low(Tabla)           ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   high(Tabla) | 0x80       ; Aca ademas de tomar la direccion alta de memoria le pongo un 1 al bit 7 asi acceder a la flash
        MOVWF   FSR0H

Espero que esto resuelva tu pregunta y ademas aclare a Pinolillo el error que estuve cometiendo todo este tiempo en los anteriores post. Tal ves sea mejor editarlos a todos asi nadie termina confundido la primera ves que lo lee e intenta probarlos
EDITADO y corregido lo anterior

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: RALF2 en 09 de Noviembre de 2015, 13:21:39

A ok, ahora si entiendo, no habia visto esas instruccion en asm de low(table) o high(tabla) de alli mi duda :mrgreen:
Y bien claro lo del acceso a la memoria flash por medio de los FSR :mrgreen:

Gracias

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 09 de Noviembre de 2015, 13:29:45

Lo que ahora me hiciste dudar es si es low(Tabla) y high(Tabla)

Y puede ser

Código: ASM

MOVLW   LOW Tabla              ;Cargo Valor inicial de la tabla
        MOVWF   FSR0L
        MOVLW   HIGH (Tabla | 0x8000)
        MOVWF   FSR0H

Esto me pasa por que se me mezclan todos los assemblers entre pic16/18/dsPIC

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 09 de Noviembre de 2015, 21:06:03

Que tal KillerJC ya quede un poco confundido con lo de la memoria, :shock: no me terminaba de quedar clara la dirección que me genera cada etiqueta, y en los ejemplos que me diste en MOVLW LOW(TABLA) no sabia si era literalmente hablando escribirlo. Y sí si fue así :) es nuevo para mi todo esto pero es bastante interesante saber que puedes optimizar mucho código. Bueno la primera que modificación que hice fue esta:

Código: ASM

INIT_NOKIA
    MOVIW   FSR0++
    CALL    COMANDO_SPI
    ;MOVIW   k[FSR0]
    ;BTFSS   STATUS,Z
    ;GOTO    INIT_NOKIA
     MOVIW   FSR0++
     CALL    COMANDO_SPI
     MOVIW   FSR0++
     CALL    COMANDO_SPI
     MOVIW   FSR0++
     CALL    COMANDO_SPI
     MOVIW   FSR0++
    CALL    COMANDO_SPI
    RETURN

Esto lo hice así porque al principio no me funcionaba bien esta instrucción:

Código: ASM

MOVIW   k[FSR0]

Primero me genero un error, despues busque información sobre esa instrucción y lei que K es una constante que se suma a FSR0 cuando se mueve a W entonces al estar asignando cualquier numero no me funcionaba porque nunca se activaba mi bit Zero.

Finalmente el código de inicialización me quedo así y funciono perfectamente.

Código: ASM

INIT_NOKIA
    MOVIW   FSR0++
    CALL    COMANDO_SPI
    MOVIW   [FSR0]
    BTFSS   STATUS,Z
    GOTO    INIT_NOKIA
    RETURN
    
    
    INICIA_NOKIA: dt 0X21,0XCF,0X20,0X0C,0X00

Sustituyendolo por los MOVLW de configuración que tenia en un principio.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 09 de Noviembre de 2015, 21:14:37

Perdón y mis direcciones quedaron de la siguiente manera:

Código: ASM

MOVLW   LOW(INICIA_NOKIA)
    MOVWF   FSR0L
    MOVLW   HIGH(INICIA_NOKIA)
    MOVWF   FSR0H

Entonces con lo último que me dices, está bien mi codigo? Refiriendonos a la parte de las direcciones de la tabla?. Las instrucciones de las direcciones en tabla como lo acabamos de hacer si se han asignado de manera correcta se puede hacer esto con cualquier PIC? y por último no se si he encontrado el correcto data pero no encuentro las direcciones donde tengo los caracteres de esta LCD, no la he manejado mucho solo he realizado pequeños dibujitos en ella pero nunca mire que ya tenia los caracteres, no sera mucha molestia si me dices en que parte puedo encontrarlos?

Saludos y de nuevo muchas gracias.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 09 de Noviembre de 2015, 21:48:14

Bueno aca otra modificación del mismo programa ahora usando los FSRs para enviar los mensajes, en definitiva mucho mejor. :-/

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    RET
    RET2
    CONTADOR_BYTES
    ENDC
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETFIE
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
    BANKSEL PORTA
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    BANKSEL LATA
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    BANKSEL ANSELA
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    BANKSEL TRISA
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BCF     PPSLOCK,PPSLOCKED
    BANKSEL RC0PPS
    MOVLW   B'00010010'
    MOVWF   RC0PPS
    MOVLW   B'00010000'
    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BSF     PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL SSP1CON1
    MOVLW   B'00110000'
    MOVWF   SSP1CON1
    BANKSEL PORTB
    
    #DEFINE LCD_NOKIA   PORTC,2
    #DEFINE RST_NOKIA   PORTC,3
    #DEFINE DC_NOKIA    PORTC,4
 
    BSF     RST_NOKIA
    BSF     LCD_NOKIA
    CALL    INI_LCD_NOKIA
 
 PRINCIPAL
    MOVLW   LOW(HOLA_MENSAJE)
    MOVWF   FSR0L
    MOVLW   HIGH(HOLA_MENSAJE)
    MOVWF   FSR0H
    MOVLW   .20
    CALL    MENSAJE_X_BYTES
    GOTO    PRINCIPAL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MENSAJE_X_BYTES
    MOVWF   CONTADOR_BYTES
WRITING_LCD    
    MOVIW   FSR0++
    CALL    DATO_SPI
    DECFSZ  CONTADOR_BYTES,F
    GOTO    WRITING_LCD
    RETURN
    
    
    
INI_LCD_NOKIA
    BCF     RST_NOKIA
    NOP
    BSF     RST_NOKIA
    ;CREAMOS UN RESET POR SOFTWARE DE LA LCD
    MOVLW   LOW(INICIA_NOKIA)
    MOVWF   FSR0L
    MOVLW   HIGH(INICIA_NOKIA)
    MOVWF   FSR0H
INIT_NOKIA
    MOVIW   FSR0++
    CALL    COMANDO_SPI
    MOVIW   [FSR0]
    BTFSS   STATUS,Z
    GOTO    INIT_NOKIA
    RETURN
SET_Y
    ADDLW   B'01000000'
    CALL    COMANDO_SPI
    RETURN
SET_X
    ADDLW   B'10000000'
    CALL    COMANDO_SPI
    RETURN
    
    
    INICIA_NOKIA: dt 0X21,0XCF,0X20,0X0C,0X00
   
    HOLA_MENSAJE: dt 0XFE,0X10,0X10,0XFE,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X80,0X80,0X80,0X00,0XFC,0X12,0X12,0XFC,0X00;A
 
 
 
DATO_SPI
    BSF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPI
    BTFSS   PIR1,SSP1IF
    GOTO    WSPI
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
COMANDO_SPI
    BCF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPIC
    BTFSS   PIR1,SSP1IF
    GOTO    WSPIC
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    
RETARDO
    MOVLW   0XFF
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN
    END

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 09 de Noviembre de 2015, 22:09:23

Jugando un poco mas logramos un saludo para la comunidad. :)

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    RET
    RET2
    CONTADOR_BYTES
    ENDC
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETFIE
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
    BANKSEL PORTA
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    BANKSEL LATA
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    BANKSEL ANSELA
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    BANKSEL TRISA
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BCF     PPSLOCK,PPSLOCKED
    BANKSEL RC0PPS
    MOVLW   B'00010010'
    MOVWF   RC0PPS
    MOVLW   B'00010000'
    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BSF     PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL SSP1CON1
    MOVLW   B'00110000'
    MOVWF   SSP1CON1
    BANKSEL PORTB
    
    #DEFINE LCD_NOKIA   PORTC,2
    #DEFINE RST_NOKIA   PORTC,3
    #DEFINE DC_NOKIA    PORTC,4
 
    BSF     RST_NOKIA
    BSF     LCD_NOKIA
    CALL    INI_LCD_NOKIA
 
 PRINCIPAL
    MOVLW   .1
    CALL    SET_Y
    MOVLW   .30
    CALL    SET_X
    MOVLW   LOW(HOLA_MENSAJE)
    MOVWF   FSR0L
    MOVLW   HIGH(HOLA_MENSAJE)
    MOVWF   FSR0H
    MOVLW   .20
    CALL    MENSAJE_X_BYTES
    MOVLW   .3
    CALL    SET_Y
    MOVLW   .23
    CALL    SET_X
    MOVLW   LOW(TODO_MENSAJE)
    MOVWF   FSR0L
    MOVLW   HIGH(TODO_MENSAJE)
    MOVWF   FSR0H
    MOVLW   .21
    CALL    MENSAJE_X_BYTES
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    MOVLW   LOW(PIC_MENSAJE)
    MOVWF   FSR0L
    MOVLW   HIGH(PIC_MENSAJE)
    MOVWF   FSR0H
    MOVLW   .14
    CALL    MENSAJE_X_BYTES
    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    CALL    RETARDO
    GOTO    PRINCIPAL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MENSAJE_X_BYTES
    MOVWF   CONTADOR_BYTES
WRITING_LCD    
    MOVIW   FSR0++
    CALL    DATO_SPI
    DECFSZ  CONTADOR_BYTES,F
    GOTO    WRITING_LCD
    RETURN
    
    
    
INI_LCD_NOKIA
    BCF     RST_NOKIA
    NOP
    BSF     RST_NOKIA
    ;CREAMOS UN RESET POR SOFTWARE DE LA LCD
    MOVLW   LOW(INICIA_NOKIA)
    MOVWF   FSR0L
    MOVLW   HIGH(INICIA_NOKIA)
    MOVWF   FSR0H
INIT_NOKIA
    MOVIW   FSR0++
    CALL    COMANDO_SPI
    MOVIW   [FSR0]
    BTFSS   STATUS,Z
    GOTO    INIT_NOKIA
    RETURN
SET_Y
    ADDLW   B'01000000'
    CALL    COMANDO_SPI
    RETURN
SET_X
    ADDLW   B'10000000'
    CALL    COMANDO_SPI
    RETURN
    
    
    INICIA_NOKIA: dt 0X21,0XCF,0X20,0X0C,0X00
   
    HOLA_MENSAJE: dt 0XFE,0X10,0X10,0XFE,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X80,0X80,0X80,0X00,0XFC,0X12,0X12,0XFC,0X00;A
    TODO_MENSAJE: dt 0X02,0X02,0XFE,0X02,0X02,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X82,0X82,0X7C,0X00,0X7C,0X82,0X82,0X7C,0X00
    PIC_MENSAJE:  dt 0X00,0X00,0XFE,0X12,0X12,0X0C,0X00,0XFE,0X00,0X7C,0X82,0X82,0X44,0X00
 
 
 
 DATO_SPI
    BSF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPI
    BTFSS   PIR1,SSP1IF
    GOTO    WSPI
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
COMANDO_SPI
    BCF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPIC
    BTFSS   PIR1,SSP1IF
    GOTO    WSPIC
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    
RETARDO
    MOVLW   0XFF
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN
    END

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 09 de Noviembre de 2015, 22:52:45

Bueno parece que ultimamente le estoy errando a todo..

Citar

por último no se si he encontrado el correcto data pero no encuentro las direcciones donde tengo los caracteres de esta LCD, no la he manejado mucho solo he realizado pequeños dibujitos en ella pero nunca mire que ya tenia los caracteres, no sera mucha molestia si me dices en que parte puedo encontrarlos?

Es correcto, nomas que yo me equivoque con un LCD 2x16, Ese es un LCD grafico asi que no posee una ROM con caracteres

Citar

Esto lo hice así porque al principio no me funcionaba bien esta instrucción:
MOVIW k[FSR0]

Para mi es nueva la instruccion tambien, y solo tome lo del datasheet, me parecia raro esa k, pero como estba escrito asi en el datasheet procedi a copiarlo de esa forma. Como te decia, es nueva para mi y nunca la use, solo sabia para que se usaba.

Citar

Entonces con lo último que me dices, está bien mi codigo? Refiriendonos a la parte de las direcciones de la tabla?. Las instrucciones de las direcciones en tabla como lo acabamos de hacer si se han asignado de manera correcta se puede hacer esto con cualquier PIC?

Tal ves el compilador ya le agrega el 1 a la direccion de la etiqueta, eso no va a modificar el programa ya que los CALL/GOTO solo usan 11 bits.
Como es nuevo para mi tambien, me asegure con ponerle el bit a 1. Por si las dudas el compilador no lo tomaba. Pero si en algun momento queres leer la memoria flash recorda que tenes ese 1.
Nuevamente se el funcionamiento pero me faltaba probarlo para decirte exactametne si funciona asi o no.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 10 de Noviembre de 2015, 14:12:17

Bueno parece que si esta bien el código ahora la idea es empezar a trabajar con el módulo ADC para poder hacer algo más con este micro.

Acá el bloque de la configuración del ADC vamos viendo como realizar la correcta configuración.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 10 de Noviembre de 2015, 14:29:36

De la hoja de datos, tiene el siguiente procedimiento:

1. Configure Port:
• Disable pin output driver (Refer to the TRIS
register)
• Configure pin as analog (Refer to the ANSEL
register)
2. Configure the ADC module:
• Select ADC conversion clock
• Configure voltage reference
• Select ADC input channel
• Turn on ADC module
3. Configure ADC interrupt (optional):
• Clear ADC interrupt flag
• Enable ADC interrupt
• Enable peripheral interrupt
• Enable global interrupt(1)
4. Wait the required acquisition time(2).
5. Start conversion by setting the GO/DONE bit.
6. Wait for ADC conversion to complete by one of
the following:
• Polling the GO/DONE bit
• Waiting for the ADC interrupt (interrupts
enabled)
7. Read ADC Result.
8. Clear the ADC interrupt flag (required if interrupt
is enabled).

Con el código:

Código: ASM

;This code block configures the ADC
;for polling, Vdd and Vss references, FRC
;oscillator and AN0 input.
;
;Conversion start & polling for completion
; are included.
;
BANKSEL ADCON1 ;
MOVLW B’11110000’ ;Right justify, FRC
;oscillator
MOVWF ADCON1 ;Vdd and Vss Vref
BANKSEL TRISA ;
BSF TRISA,0 ;Set RA0 to input
BANKSEL ANSEL ;
BSF ANSEL,0 ;Set RA0 to analog
BANKSEL ADCON0 ;
MOVLW B’00000001’ ;Select channel AN0
MOVWF ADCON0 ;Turn ADC On
CALL SampleTime ;Acquisiton delay
BSF ADCON0,ADGO ;Start conversion
BTFSC ADCON0,ADGO ;Is conversion done?
GOTO $-1 ;No, test again
BANKSEL ADRESH ;
MOVF ADRESH,W ;Read upper 2 bits
MOVWF RESULTHI ;store in GPR space
BANKSEL ADRESL ;
MOVF ADRESL,W ;Read lower 8 bits
MOVWF RESULTLO ;Store in GPR space

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 11 de Noviembre de 2015, 04:26:36

Bueno después de pelear un rato con los bancos de memoria nuevamente... Aquí esta el código ejemplo para un ADC con el PIC16F1707. Es el primero e iremos haciendo modificaciones.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    RET
    RET2
    CONTADOR_BYTES
    RESULTHI
    RESULTLO
    ENDC
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETFIE
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
    BANKSEL PORTA
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    BANKSEL LATA
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    BANKSEL ANSELA
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    BANKSEL TRISA
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
;    BANKSEL PPSLOCK
;    MOVLW   0X55
;    MOVWF   PPSLOCK
;    MOVLW   0XAA
;    MOVWF   PPSLOCK
;    BCF            PPSLOCK,PPSLOCKED
;    BANKSEL RC0PPS
;    MOVLW   B'00010010'
;    MOVWF   RC0PPS
;    MOVLW   B'00010000'
;    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;    BANKSEL PPSLOCK
;    MOVLW   0X55
;    MOVWF   PPSLOCK
;    MOVLW   0XAA
;    MOVWF   PPSLOCK
;    BSF            PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;    BANKSEL SSP1CON1
;    MOVLW   B'00110000'
;    MOVWF   SSP1CON1
;;;; VAMOS A CONFIGURAR EL ADC
    BANKSEL ADCON1 ;
    MOVLW   B'01100000' 
    MOVWF   ADCON1 
    BANKSEL TRISA 
    BSF     TRISA,0     
    BANKSEL ANSELA ;
    BSF     ANSELA,0 
    BANKSEL PORTB
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
 
 
PRINCIPAL
    CALL    CONV_ADC
    MOVF    RESULTHI,W
    BANKSEL LATC
    MOVWF   LATC
    BANKSEL PORTC
    CALL    RETARDO
    GOTO    PRINCIPAL
 
CONV_ADC
    BANKSEL ADCON0 ;
    MOVLW   B'00000001' ;Select channel AN0
    MOVWF   ADCON0 ;Turn ADC On  
    BSF     ADCON0,ADGO ;Start conversion
    BTFSC   ADCON0,ADGO ;Is conversion done?
    GOTO    $-1 ;No, test again
    BANKSEL ADRESH ;
    MOVF    ADRESH,W ;Read upper 2 bits
    MOVWF   RESULTHI ;store in GPR space
    BANKSEL ADRESL ;
    MOVF    ADRESL,W ;Read lower 8 bits
    MOVWF   RESULTLO ;Store in GPR space
    RETURN
RETARDO
    MOVLW   0X0F
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN 
 
    END

Anexa la imagen de la simulación en proteus.

Bueno pues les platico que tuve problemas al mandar los datos, ya que en principio quería sacarlos por el PORTC. Pero recordé que es por el LATC así que tuve que moverme a ese banco para poder actualizar los datos del ADC correctamente.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 11 de Noviembre de 2015, 10:35:27

Si solo tenes esos "registros" Usa:

Código: ASM

CBLOCK  0X70
    RET
    RET2
    CONTADOR_BYTES
    RESULTHI
    RESULTLO
    ENDC

Eso te va a ahorrar un par de errores que tenes. Como este:

Código: ASM

BANKSEL ADRESL ;
    MOVF    ADRESL,W ;Read lower 8 bits
    MOVWF   RESULTLO ;Store in GPR space

RESULTLO lo definiste como si fuera del banco 0, pero ahi estarias cambiando la direccion 0xA4 y no 0x24. Si pones todos tus regisrtos desde el 0x70 ( solo 15 puede haber ubicados ahi )
Podes acceder desde cualquier banco al banco 0. es decir si vos accedes a 0xF0 o 0x170 estarias accediendo a 0x70, es asi en esa porcion de memoria para evitar estar cambiando mucho de bancos.

La parte de configuracion del canal del ADC si no vas a cambiar el canal no hace falta que lo pongas dentro de la rutina, y pasalo a la configuracion.

Tenes repetido la limpieza de PORTx, que es innecesaria, ya que si tenes LATx simplemente limpias eso y listo.

Cambie el RETFIE por un RETURN, de esa forma si entra a una interrupcion por error, simplemente sale, con RETFIE se vuelven a activar las interrupciones, por lo cual existiria la posibilidad de que vuelta a entrar.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X70
    RET
    RET2
    CONTADOR_BYTES
    RESULTHI
    RESULTLO
    ENDC
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETURN
CONFIGURA_PIC
        BANKSEL OSCCON
        MOVLW   B'11111011'
        MOVWF   OSCCON
        MOVLW   B'00011111'
        MOVWF   OSCTUNE
 
        BANKSEL LATA
        CLRF    LATA
        CLRF    LATB
        CLRF    LATC
        BANKSEL ANSELA
        CLRF    ANSELA
        CLRF    ANSELB
        CLRF    ANSELC
        BANKSEL TRISA
        CLRF    TRISA
        CLRF    TRISB
        CLRF    TRISC
 
;;;; VAMOS A CONFIGURAR EL ADC
        BANKSEL ADCON1          ; El mismo que el de TRISx
        MOVLW   B'01100000' 
        MOVWF   ADCON1 
        MOVLW   B'00000001'     ;Select channel AN0
        MOVWF   ADCON0          ;Turn ADC On  
        BSF     TRISA,0     
        BANKSEL ANSELA          ;
        BSF     ANSELA,0 
 
 
PRINCIPAL
        CALL    CONV_ADC
        MOVF    RESULTHI,W
        BANKSEL LATC
        MOVWF   LATC
        CALL    RETARDO
        GOTO    PRINCIPAL
 
CONV_ADC
        BANKSEL ADCON0          ;
        BSF     ADCON0,ADGO     ;Start conversion
        BTFSC   ADCON0,ADGO     ;Is conversion done?
        GOTO    $-1             ;No, test again
        MOVF    ADRESH,W        ;Read upper 2 bits
        MOVWF   RESULTHI        ;store in GPR space
        MOVF    ADRESL,W        ;Read lower 8 bits
        MOVWF   RESULTLO        ;Store in GPR space
        RETURN
RETARDO
        MOVLW   0X0F
        MOVWF   RET
        MOVWF   RET2
ESP
        DECFSZ  RET,F
        GOTO    ESP
        MOVLW   0XFF
        MOVWF   RET
        DECFSZ  RET2,F
        GOTO    ESP
        RETURN 
 
    END

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 15 de Noviembre de 2015, 04:18:51

Muchisimas gracias KillerJC por las observaciones. Ya cambie el código y esta perfecto. Ahora trabajare en unir los dos últimos programas LCD+ADC con esto haber que aplicación le podemos dar.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 15 de Noviembre de 2015, 04:38:33

Ya un poco entrados juntamos ambos programas esperando no cometer errores. Acá el código y anexo el circuito, es sencillo lo unico que hace es mostrar el byte alto del ADC en la LCD. Ojo no gráfica si no que mandamos directo el byte lo que nos puede simular un movimiento.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    RET
    RET2
    CONTADOR_BYTES
    ADC_VALUE
    ENDC
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETURN
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
    BANKSEL PORTA
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    BANKSEL LATA
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    BANKSEL ANSELA
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    BANKSEL TRISA
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
;CONFIGURAMOS ADC
    BANKSEL ADCON1          ; El mismo que el de TRISx
    MOVLW   B'01100000' 
    MOVWF   ADCON1 
    MOVLW   B'00000001'     ;Select channel AN0
    MOVWF   ADCON0          ;Turn ADC On  
    BSF     TRISA,0     
    BANKSEL ANSELA          ;
    BSF     ANSELA,0 
; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
 
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BCF     PPSLOCK,PPSLOCKED
    BANKSEL RC0PPS
    MOVLW   B'00010010'
    MOVWF   RC0PPS
    MOVLW   B'00010000'
    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BSF     PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL SSP1CON1
    MOVLW   B'00110000'
    MOVWF   SSP1CON1
    BANKSEL PORTB
    
    #DEFINE LCD_NOKIA   PORTC,2
    #DEFINE RST_NOKIA   PORTC,3
    #DEFINE DC_NOKIA    PORTC,4
 
    BSF     RST_NOKIA
    BSF     LCD_NOKIA
    CALL    INI_LCD_NOKIA
 
 PRINCIPAL
    CALL    CONV_ADC
    MOVF    ADC_VALUE,W
    CALL    DATO_SPI
    CALL    RETARDO
    GOTO    PRINCIPAL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SUBRUTINA ADC
CONV_ADC
        BANKSEL ADCON0          ;
        BSF     ADCON0,ADGO     ;Start conversion
        BTFSC   ADCON0,ADGO     ;Is conversion done?
        GOTO    $-1             ;No, test again
        MOVF    ADRESH,W        ;Read upper 2 bits
        BANKSEL ADC_VALUE
        MOVWF   ADC_VALUE        ;store in GPR space
        RETURN
    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MENSAJE_X_BYTES
    MOVWF   CONTADOR_BYTES
WRITING_LCD    
    MOVIW   FSR0++
    CALL    DATO_SPI
    DECFSZ  CONTADOR_BYTES,F
    GOTO    WRITING_LCD
    RETURN
    
    
    
INI_LCD_NOKIA
    BCF     RST_NOKIA
    NOP
    BSF     RST_NOKIA
    ;CREAMOS UN RESET POR SOFTWARE DE LA LCD
    MOVLW   LOW(INICIA_NOKIA)
    MOVWF   FSR0L
    MOVLW   HIGH(INICIA_NOKIA)
    MOVWF   FSR0H
INIT_NOKIA
    MOVIW   FSR0++
    CALL    COMANDO_SPI
    MOVIW   [FSR0]
    BTFSS   STATUS,Z
    GOTO    INIT_NOKIA
    RETURN
SET_Y
    ADDLW   B'01000000'
    CALL    COMANDO_SPI
    RETURN
SET_X
    ADDLW   B'10000000'
    CALL    COMANDO_SPI
    RETURN
    
    
    INICIA_NOKIA: dt 0X21,0XCF,0X20,0X0C,0X00
   
    HOLA_MENSAJE: dt 0XFE,0X10,0X10,0XFE,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X80,0X80,0X80,0X00,0XFC,0X12,0X12,0XFC,0X00;A
    TODO_MENSAJE: dt 0X02,0X02,0XFE,0X02,0X02,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X82,0X82,0X7C,0X00,0X7C,0X82,0X82,0X7C,0X00
    PIC_MENSAJE:  dt 0X00,0X00,0XFE,0X12,0X12,0X0C,0X00,0XFE,0X00,0X7C,0X82,0X82,0X44,0X00
 
 
 
 DATO_SPI
    BSF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPI
    BTFSS   PIR1,SSP1IF
    GOTO    WSPI
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
COMANDO_SPI
    BCF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPIC
    BTFSS   PIR1,SSP1IF
    GOTO    WSPIC
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    
RETARDO
    MOVLW   0XFF
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN
    END

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 15 de Noviembre de 2015, 05:18:14

;-) Bueno pues ya es algo tarde por aca pero les dejo un codigo ejemplo que aun le falta pero me entretuvo un rato. Estoy pensando ahora como sera la manera mas fácil de obtener por la lectura del adc un tipo graficador como el que hice pero en lugar de utilizar 1 byte y utilice 2 para que se vea mejor. El procedimiento para lograr esto fue: Comparar el valor del ADC en 8 partes de 32 si era mayor le asignaba un valor fijo para que pareciera que la gráfica crece o disminuye. Espero que les sirva de algo.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    RET
    RET2
    CONTADOR_BYTES
    ADC_VALUE
    GH
    GL
    ENDC
 
    ORG     0X00
    GOTO    CONFIGURA_PIC
    ORG     0X04
    RETURN
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
    BANKSEL PORTA
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    BANKSEL LATA
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    BANKSEL ANSELA
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    BANKSEL TRISA
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
;CONFIGURAMOS ADC
    BANKSEL ADCON1          ; El mismo que el de TRISx
    MOVLW   B'01100000' 
    MOVWF   ADCON1 
    MOVLW   B'00000001'     ;Select channel AN0
    MOVWF   ADCON0          ;Turn ADC On  
    BSF     TRISA,0     
    BANKSEL ANSELA          ;
    BSF     ANSELA,0 
; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
 
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BCF     PPSLOCK,PPSLOCKED
    BANKSEL RC0PPS
    MOVLW   B'00010010'
    MOVWF   RC0PPS
    MOVLW   B'00010000'
    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BSF     PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL SSP1CON1
    MOVLW   B'00110000'
    MOVWF   SSP1CON1
    BANKSEL PORTB
    
    #DEFINE LCD_NOKIA   PORTC,2
    #DEFINE RST_NOKIA   PORTC,3
    #DEFINE DC_NOKIA    PORTC,4
 
    BSF     RST_NOKIA
    BSF     LCD_NOKIA
    CALL    INI_LCD_NOKIA
 
 PRINCIPAL
    MOVLW   .0
    CALL    SET_Y
    MOVLW   .0
    CALL    SET_X
    MOVLW   LOW(ADC_TEXT)
    MOVWF   FSR0L
    MOVLW   HIGH(ADC_TEXT)
    MOVWF   FSR0H
    MOVLW   .16
    CALL    MENSAJE_X_BYTES
    MOVLW   .2
    CALL    SET_Y
    MOVLW   .0
    CALL    SET_X
UPDATE_ADC  
    CALL    CONV_ADC
    MOVF    ADC_VALUE,W
    CALL    CONVIERTE_ADC
;    MOVF    GH,W
    CALL    DATO_SPI
    CALL    RETARDO
    GOTO    UPDATE_ADC
;;;; SUBRUTINA PARA CONVERTIR EL ADC EN VALOR 0-7
CONVIERTE_ADC
    SUBLW   .250
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .1
    MOVF    ADC_VALUE,W
    SUBLW   .223
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .2
    MOVF    ADC_VALUE,W
    SUBLW   .191
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .4
    MOVF    ADC_VALUE,W
    SUBLW   .159
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .8
    MOVF    ADC_VALUE,W
    SUBLW   .127
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .16
    MOVF    ADC_VALUE,W
    SUBLW   .95
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .32
    MOVF    ADC_VALUE,W
    SUBLW   .63
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .64
    MOVF    ADC_VALUE,W
    SUBLW   .31
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .128
    RETLW   .128
    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SUBRUTINA ADC
CONV_ADC
        BANKSEL ADCON0          ;
        BSF     ADCON0,ADGO     ;Start conversion
        BTFSC   ADCON0,ADGO     ;Is conversion done?
        GOTO    $-1             ;No, test again
        MOVF    ADRESH,W        ;Read upper 2 bits
        BANKSEL ADC_VALUE
        MOVWF   ADC_VALUE        ;store in GPR space
        RETURN
    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MENSAJE_X_BYTES
    MOVWF   CONTADOR_BYTES
WRITING_LCD    
    MOVIW   FSR0++
    CALL    DATO_SPI
    DECFSZ  CONTADOR_BYTES,F
    GOTO    WRITING_LCD
    RETURN
    
    
    
INI_LCD_NOKIA
    BCF     RST_NOKIA
    NOP
    BSF     RST_NOKIA
    ;CREAMOS UN RESET POR SOFTWARE DE LA LCD
    MOVLW   LOW(INICIA_NOKIA)
    MOVWF   FSR0L
    MOVLW   HIGH(INICIA_NOKIA)
    MOVWF   FSR0H
INIT_NOKIA
    MOVIW   FSR0++
    CALL    COMANDO_SPI
    MOVIW   [FSR0]
    BTFSS   STATUS,Z
    GOTO    INIT_NOKIA
    RETURN
SET_Y
    ADDLW   B'01000000'
    CALL    COMANDO_SPI
    RETURN
SET_X
    ADDLW   B'10000000'
    CALL    COMANDO_SPI
    RETURN
    
    
    INICIA_NOKIA: dt 0X21,0XCF,0X20,0X0C,0X00
    ADC_TEXT:     dt 0XFC,0X12,0X12,0XFC,0X00,0XFE,0X82,0X82,0X7C,0X00,0X7C,0X82,0X82,0X44,0X00,0X44
    HOLA_MENSAJE: dt 0XFE,0X10,0X10,0XFE,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X80,0X80,0X80,0X00,0XFC,0X12,0X12,0XFC,0X00;A
    TODO_MENSAJE: dt 0X02,0X02,0XFE,0X02,0X02,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X82,0X82,0X7C,0X00,0X7C,0X82,0X82,0X7C,0X00
    PIC_MENSAJE:  dt 0X00,0X00,0XFE,0X12,0X12,0X0C,0X00,0XFE,0X00,0X7C,0X82,0X82,0X44,0X00
 
 
 
 DATO_SPI
    BSF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPI
    BTFSS   PIR1,SSP1IF
    GOTO    WSPI
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
COMANDO_SPI
    BCF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPIC
    BTFSS   PIR1,SSP1IF
    GOTO    WSPIC
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    
RETARDO
    MOVLW   0X3F
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN
    END

Saludos y buenas noches

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 15 de Noviembre de 2015, 14:10:35

Bueno te dejo un codigo para que puedas reemplazar:

Lo tuyo:

Código: ASM

CONVIERTE_ADC
    SUBLW   .250
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .1
    MOVF    ADC_VALUE,W
    SUBLW   .223
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .2
    MOVF    ADC_VALUE,W
    SUBLW   .191
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .4
    MOVF    ADC_VALUE,W
    SUBLW   .159
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .8
    MOVF    ADC_VALUE,W
    SUBLW   .127
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .16
    MOVF    ADC_VALUE,W
    SUBLW   .95
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .32
    MOVF    ADC_VALUE,W
    SUBLW   .63
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .64
    MOVF    ADC_VALUE,W
    SUBLW   .31
    BTFSC   STATUS,C
    GOTO    $+2
    RETLW   .128
    RETLW   .128

(Que posee ese GOTO/BTFSC/RETLW de mas al final )

Por esto:

Código: ASM

SWAPF   ADC_VALUE, F
        LSRF    ADC_VALUE, W
        SWAPF   ADC_VALUE, F
        ANDLW   0x07
        BRW
        RETLW   .128
        RETLW   .64
        RETLW   .32
        RETLW   .16
        RETLW   .8
        RETLW   .4
        RETLW   .2
        RETLW   .1

Explicacion, es simple.. vos estas usando solo 8 partes de 32 bits cada una. En resumen es como si dividiera por 32 el numero.

adc_result = aaax xxxx

Al dividirlo por 32 las x se irian y quedaria: 0000 0aaa
El SWAPF cambia los nibbles ADC_RESULT = xxxx aaax
Luego una rotacion para que me quede W = 0xxx xaaa
Procedo a dejar como estaba antes ADC_RESULT ( en cosa que otra cosa lo necesite) ADC_RESULT = aaax xxxx
Finalmente le hago una AND a W para forzar el maximo a 0000 0111 como entrada en la tabla.
Fin.

Todo esto fue para no modificar el ADC_RESULT, si este valor ya no importaba. Entonces podria haber ahorrado un SWAPF mas.

PD: No te va a dar el mismo valor ya que al final no respetaste que las partes sean exactas, por ejemplo veo que tenes un 250 por ahi. Asi que tal ves difiera un poco.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 23 de Noviembre de 2015, 03:21:24

Muy buenos consejos KillerJC para optimizacion de codigo. Pregunta como funciona esta parte del codigo que me has sugerido?

Código: ASM

BRW
        RETLW   .128
        RETLW   .64
        RETLW   .32
        RETLW   .16
        RETLW   .8
        RETLW   .4
        RETLW   .2
        RETLW   .1

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 23 de Noviembre de 2015, 03:41:42

Es una tabla ... Lo mismo que haces con:

ADDWF PCL
RETLW ...
...
...
RETLW ....

Nomas que ese PIC posee una instruccion que lo hace por uno.. que es BRW
Esa instruccion le suma al PC el valor de W. W vale de 0 a 7 (0000 0111) por las condiciones que le pusimos antes y eso se traduce en la tabla:

Código: ASM

BRW
        RETLW   .128   ;W=0
        RETLW   .64    ;W=1
        RETLW   .32    ;W=2
        RETLW   .16    ;W=3
        RETLW   .8     ;W=4
        RETLW   .4     ;W=5
        RETLW   .2     ;W=6
        RETLW   .1     ;W=7

Lo bueno es que no tengo que ir al banco donde esta el PCL , se observa tambien que antes dije PC solamente, y no PCL, esto es por que la instruccion BRW le suma el valor de W a todo el PC ( 14bits ), y no me tengo que preocupar por las "paginas", en cambio con ADDWF si lo tenia que hacer, ya que solo modifica los 8 bits de menor peso ( PCL ) y debo cargar antes el valor de la parte superior en PCLATH si es que me excedo. Lo cual requiere un poco mas de cuidado si es que uno no posiciona la tabla en un lugar que evite esto.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 03 de Diciembre de 2015, 22:41:25

Bueno retomando la parte de código que Killer me recomendó anexo un pequeño código que se ha ido acompletando que es para graficar la señal del ADC + mostrar el valor del ADC de 0 a 255. Por favor si hay algo que podamos mejorar me hacen los comentarios.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    RET
    RET2
    CONTADOR_BYTES
    ADC_VALUE
    GH
    GL
    CENTENAS
    DECENAS
    UNIDADES
    BCD_AUX
    X_POS
    ENDC
;***********************************************************************************************
;********************************* VECTOR DE RESET DEL PIC *************************************
;***********************************************************************************************
    ORG     0X00
    GOTO    CONFIGURA_PIC
;***********************************************************************************************
;***************************** VECTOR DE INTERRUPCION DEL PIC **********************************
;***********************************************************************************************
    ORG     0X04
    RETURN
;***********************************************************************************************
;********************************* CONFIGURACION DEL PIC ***************************************
;***********************************************************************************************
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
;***********************************************************************************************
;*************************** CONFIGURACION DE PUERTOS DEL PIC **********************************
;***********************************************************************************************
    BANKSEL PORTA
    CLRF    PORTA
    CLRF    PORTB
    CLRF    PORTC
    BANKSEL LATA
    CLRF    LATA
    CLRF    LATB
    CLRF    LATC
    BANKSEL ANSELA
    CLRF    ANSELA
    CLRF    ANSELB
    CLRF    ANSELC
    BANKSEL TRISA
    CLRF    TRISA
    CLRF    TRISB
    CLRF    TRISC
;CONFIGURAMOS ADC
    BANKSEL ADCON1          ; El mismo que el de TRISx
    MOVLW   B'01100000' 
    MOVWF   ADCON1 
    MOVLW   B'00000001'     ;Select channel AN0
    MOVWF   ADCON0          ;Turn ADC On  
    BSF     TRISA,0     
    BANKSEL ANSELA          ;
    BSF     ANSELA,0 
; NOS POSICIONAMOS EN BANCO DE PPSLOCK
; PARA DELBLOQUEARLO
 
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BCF     PPSLOCK,PPSLOCKED
    BANKSEL RC0PPS
    MOVLW   B'00010010'
    MOVWF   RC0PPS
    MOVLW   B'00010000'
    MOVWF   RC1PPS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL PPSLOCK
    MOVLW   0X55
    MOVWF   PPSLOCK
    MOVLW   0XAA
    MOVWF   PPSLOCK
    BSF     PPSLOCK,PPSLOCKED
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    BANKSEL SSP1CON1                ; ME HUBICO EN EL BANCO QUE CONTIENE EL REGISTRO SSP1CON
    MOVLW   B'00110000'             ; CARGO EL VALOR DE CONFIGURACION PARA SPI
    MOVWF   SSP1CON1                ; LO GUARDO EN SSP1CON PARA PODER USAR EL MODO SPI
    BANKSEL PORTB                   ; ME REGRESO AL BANCO 0
;***********************************************************************************************
;****************** DEFINICION DE LOS PINES DEL PROGRAMA ***************************************
;***********************************************************************************************    
    #DEFINE LCD_NOKIA   PORTC,2     ; DEFINE EL PIN DEL CHIP SELECT
    #DEFINE RST_NOKIA   PORTC,3     ; DEFINE EL PIN DE RESET
    #DEFINE DC_NOKIA    PORTC,4     ; DEFINE EL PIN DE INSTRUCCION/DATO DE LA LCD
 
    BSF     RST_NOKIA               ; PONGO EN ALTO EL RESET DE LA LCD
    BSF     LCD_NOKIA               ; PONGO EN ALTO EL CHIP SELECT DE LA LCD
;***********************************************************************************************
;********************* RUTINIA DE INICIALIZACION DE LA LCD NOKIA 5110 **************************
;***********************************************************************************************
    CALL    INI_LCD_NOKIA
;***********************************************************************************************
;**************************** LOOP PRINCIPAL DE FUNCIONAMIENTO *********************************
;***********************************************************************************************
    CLRF    X_POS
 PRINCIPAL
    CALL    RETARDO                 ; LLAMAMOS UN RETARDO
    MOVLW   .0                      ; CARGO EL VALOR DEL RENGLON DONDE DESEO ESCRIBIR
    CALL    SET_Y                   ; LLAMO RUTINA DE SET POSICION EN Y
    MOVLW   .0                      ; CARGO EL VALOR DE LA COLUMNA DONDE DESEO ESCRIBIR
    CALL    SET_X                   ; LLAMO RUTINA DE SET POSICION EN X
    MOVLW   LOW(ADC_TEXT)           ; MUEVO LA DIRECCION DE LA TABLA ADC_TEXT (LOW)
    MOVWF   FSR0L                   ; A MI REGISTRO FSR0L
    MOVLW   HIGH(ADC_TEXT)          ; MUEVO LA DIRECCION DE LA TABLA ADC_TEXT (HIGH)
    MOVWF   FSR0H                   ; AL REGISTRO FSR0H
    MOVLW   .17                     ; NUMERO DE BYTES A TRANSMITIR
    CALL    MENSAJE_X_BYTES         ; LLAMO A SUBRUTINA DE TRANSMISION DE BYTES
    CALL    MUESTRA_VALOR           ; LLAMAMOS A SUBRUTINA QUE MOSTRARA EL VALOR CONTENIDO DEL ADC 8 BITS 
    MOVLW   .2                      ; MUEVO MI CURSOR A RENGLON 2
    CALL    SET_Y                   ; LLAMO MI SET POSICION Y
    MOVF    X_POS,W                 ; MUEVO MI CURSOR A COLUMNA 0
    CALL    SET_X                   ; LLAMO MI SET POSICION X
;***********************************************************************************************
;******************* RUTINA DE LECTURA Y PROCESAMIENTO DEL ADC CH=0 ****************************
;***********************************************************************************************
UPDATE_ADC  
    CALL    CONV_ADC                ; LLAMO A MI RUTINA DE CONVERSION ADC    
    MOVF    ADC_VALUE,W             ; REGRESA CON ADRESH CARGADO A W Y LO MOVEMOS A ADC_VALUE
    CALL    GRAFICA_ADC             ; LLAMAMOS A LA RUTINA DE CONVERSION PARA LA LCD
    CALL    DATO_SPI                ; LLAMAMOS LA TRANSMISION DEL DATO
    INCF    X_POS,F                 ; DESPUES DE ENVIAR DATO INCREMENTAMOS POS X PARA TENER MOVIMIENTO EN SEÑAL
    MOVLW   .84                     ; DEBEMOS ASEGURAR NO PASAR DE 83
    SUBWF   X_POS,W                 ; PARA ELLO RESTAMOS 84 PARA SABER SI HA LLEGADO Y REINICIAR POSICION
    BTFSS   STATUS,Z                ; SI HA LLEGADO LA RESTA ARROJARA 0 Y PODREMOS REINICIAR
    GOTO    PRINCIPAL               ; NO FUE CERO REGRESO A PRINCIPAL
    CLRF    X_POS                   ; YA LLEGO AL LIMITE REINICIO VARIABLE
    GOTO    PRINCIPAL               ; NOS REGRESAMOS A PRINCIPAL
;***********************************************************************************************
;************************ RUTINA PARA MOSTRAR VALOR ADC 8 BITS *********************************
;***********************************************************************************************   
MUESTRA_VALOR
    BANKSEL ADC_VALUE               ; ME ASEGURO ESTAR EN BANCO DONDE ESTA ADC_VALUE (MI REGISTRO)
    MOVF    ADC_VALUE,W             ; MOVEMOS ADC_VALUE A W PARA OBTENER 3 BYTES CON EL DATO
    CALL    CONVERSION_BCD          ; RUTINA DE CONVERISON BINARIO>>BCD
    MOVF    CENTENAS,W              ; MOVEMOS CENTENAS A W PARA SABER CON QUE NÚMERO QUEDO
    CALL    ENVIA_NUMERO            ; RUTINA DE ESCRITURA DE NUMEROS EN LCD
    MOVF    DECENAS,W               ; MOVEMOS CENTENAS A W PARA SABER CON QUE NÚMERO QUEDO
    CALL    ENVIA_NUMERO            ; RUTINA DE ESCRITURA DE NUMEROS EN LCD
    MOVF    UNIDADES,W              ; MOVEMOS CENTENAS A W PARA SABER CON QUE NÚMERO QUEDO
    CALL    ENVIA_NUMERO            ; RUTINA DE ESCRITURA DE NUMEROS EN LCD
    RETURN  
ENVIA_NUMERO
    BRW                             ; INSTRUCCION CON FUNCION A TABLA SIN PCL
    GOTO    SEND0                   ;
    GOTO    SEND1
    GOTO    SEND2
    GOTO    SEND3
    GOTO    SEND4
    GOTO    SEND5
    GOTO    SEND6
    GOTO    SEND7
    GOTO    SEND8
    GOTO    SEND9
;***********************************************************************************************
;***************************** RUTINAS PARA MANDAR VALORES EN LCD ******************************
;*********************************************************************************************** 
SEND9
    MOVLW   B'01001100'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 9
    MOVLW   B'10010010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'10010010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'01111100'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND8
    MOVLW   B'01101100'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 8
    MOVLW   B'10010010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'10010010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'01101100'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND7
    MOVLW   B'01100010'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 7
    MOVLW   B'00010010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'00001010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'00000110'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND6
    MOVLW   B'01111100'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 6
    MOVLW   B'10010010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'10010010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'01100100'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND5
    MOVLW   B'01001110'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 5
    MOVLW   B'10001010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'10001010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'01110010'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND4
    MOVLW   B'00110000'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 3
    MOVLW   B'00101000'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'00100100'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'11111110'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND3
    MOVLW   B'01000100'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 3
    MOVLW   B'10010010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'10010010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'01101100'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND2
    MOVLW   B'11000100'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 2
    MOVLW   B'10100010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'10010010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'10001100'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
SEND1
    MOVLW   B'00000000'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 1
    MOVLW   B'10000100'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'11111110'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'10000000'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN    
SEND0
    MOVLW   B'01111100'             ; CONSTRUIMOS CON 4 BYTES
    CALL    DATO_SPI                ; EL NUMERO 0
    MOVLW   B'10000010'             ; DEJANDO UN ESPACIO
    CALL    DATO_SPI                ; AL FINAL DEL NUMERO
    MOVLW   B'10000010'             ; DADO POR 0X00
    CALL    DATO_SPI                ; MANDAMOS 5 BYTES SEGUIDOS POR 
    MOVLW   B'01111100'             ; EL CANAL SPI
    CALL    DATO_SPI                ; PARA CONSTRUIR COMPLETO EL NUMERO
    MOVLW   B'00000000'             ; SIN PERDER FORMA
    CALL    DATO_SPI
    RETURN
;***********************************************************************************************
;***************************** RUTINA PARA CONVERTIR BIN A BCD *********************************
;***********************************************************************************************   
CONVERSION_BCD
        MOVWF   BCD_AUX             ; MUEVO EL VALOR DE W A BCD_AUX
        CLRF    UNIDADES            ; LIMPIO REGISTRO UNIDADES
        CLRF    DECENAS             ; LIMPIO REGISTRO DECENAS
        CLRF    CENTENAS            ; LIMPIO REGISTRO CENTENAS
S_CENTENAS
        MOVLW   .100                ; CARGO 100 A W
        SUBWF   BCD_AUX,W           ; LE RESTO LOS 100 PARA SABER SI ES MAYOR O MENOR
        BTFSC   STATUS,C            ; PREGUNTO SI HUBO ACARREO
        GOTO    SUMA_CENTENAS       ; SI ES MAYOR SUMO CENTENAS
        GOTO    S_DECENAS           ; SI ES MENOR DEJO EN 0 CENTENAS Y ACTUALIZO DECENAS
SUMA_CENTENAS
        MOVWF   BCD_AUX             ; GUARDAMOS EL ULTIMO VALOR 
        INCF    CENTENAS,F          ; INCREMENTO CENTENAS Y GUARDO
        GOTO    S_CENTENAS          ; REGRESO A SUMAR SI ES AUN MAS GRANDE
S_DECENAS   
        MOVLW   .10                 ; CARGO 10 A W
        SUBWF   BCD_AUX,W           ; LE RESTO 10 PARA SABER SI ES MAYOR O MENOR
        BTFSC   STATUS,C            ; PREGUNTAMOS SI HAY ACARREO
        GOTO    SUMA_DECENAS        ; SI HUBO VAMOS A SUMAR DECENAS
        GOTO    SUMA_UNIDADES       ; SI NO VAMOS A SUMAR UNIDADES
SUMA_DECENAS
        MOVWF   BCD_AUX             ; GUARDAMOS VALOR
        INCF    DECENAS,1           ; INCREMENTAMOS DECENAS EN 1 Y GUARDAMOS
        GOTO    S_DECENAS           ; REGRESAMOS PARA SABER SI HAY MAS DECENAS EN VARIABLE
SUMA_UNIDADES
        MOVF    BCD_AUX,W           ; MOVEMOS AUXILIAR A UNIDADES
        MOVWF   UNIDADES            ; YA QUE ES EL ÚLTIMO VALOR QUE NOS QUEDA
        RETURN    
;***********************************************************************************************
;****************************** RUTINA PARA GRAFICAR 1 RENGLON *********************************
;***********************************************************************************************
GRAFICA_ADC
    SWAPF   ADC_VALUE, F            ; INTERCAMBIAMOS NIBLES 
    LSRF    ADC_VALUE, W            ; ROTAMOS A LA IZQUIERDA
    SWAPF   ADC_VALUE, F            ; REGRESAMOS ADC_VALUE A SU VALOR ORIGINAL PARA POST PROCESAMIENTOS
    ANDLW   0x07                    ; ANDEAMOS EL VALOR DADO PARA RESTRINGIR A 8 VALORES B'XXXXX111'
    BRW                     ;
    RETLW   .128            ; W=0
    RETLW   .64             ; W=1
    RETLW   .32             ; W=2
    RETLW   .16             ; W=3
    RETLW   .8              ; W=4
    RETLW   .4              ; W=5
    RETLW   .2              ; W=6
    RETLW   .1              ; W=7
;***********************************************************************************************
;*************************************** RUTINA CONVERSION ADC *********************************
;***********************************************************************************************
CONV_ADC
        BANKSEL ADCON0              ; NOS UBICAMOS EN EL BANCO QUE CONTIENE A ADCON0
        BSF     ADCON0,ADGO         ; PRENDEMOS EL BIT GO PARA INICIAR LA CONVERSION ADC
        BTFSC   ADCON0,ADGO         ; SALTAMOS UNA INSTRUCCION SI ES QUE YA TERMINO LA CONVERSION ADC
        GOTO    $-1                 ; REGRESAMOS UNA LINEA DE CODIGO PARA SABER SI YA TERMINO CONVERSION ADC
        MOVF    ADRESH,W            ; MOVEMOS ADRESH A W UNA VEZ ACABADA LA CONVERSION
        BANKSEL ADC_VALUE           ; NOS UBICAMOS EN BANCO QUE CONTIENE A VARIABLE DECLARADA
        MOVWF   ADC_VALUE           ; MOVEMOS EL RESULTADO DE ADRESH A NUESTRA VARIABLE
        RETURN
;***********************************************************************************************
;******************************* RUTINA DE ESCRITURA SPI X BYTES *******************************
;***********************************************************************************************
MENSAJE_X_BYTES
    MOVWF   CONTADOR_BYTES          ; MOVEMOS A NUESTRO REGISTRO CONTADOR BYTES EL # EN W
WRITING_LCD    
    MOVIW   FSR0++                  ; MOVEMOS INDF A W E INCREMENTAMOS FSR0 EN 1
    CALL    DATO_SPI                ; TRASNMITIMOS VIA SPI EL BYTE EN W
    DECFSZ  CONTADOR_BYTES,F        ; DECREMENTAMOS 1 EL CONTADOR Y SALTAMOS HASTA 0
    GOTO    WRITING_LCD             ; REGRESAMOS A SEGUIR ESCRIBIENDO LA LCD
    RETURN
;***********************************************************************************************
;************************** RUTINA DE INICIALIZACION DE LCD NOKIA5110 **************************
;***********************************************************************************************    
INI_LCD_NOKIA
    BCF     RST_NOKIA                ; CREAMOS UN SOFTWARE POR RESET EN LA LCD
    NOP                              ; PERDEMOS UN CICLO DE INSTRUCCION
    BSF     RST_NOKIA                ; REGRESAMOS DEL RESET
    MOVLW   LOW(INICIA_NOKIA)
    MOVWF   FSR0L
    MOVLW   HIGH(INICIA_NOKIA)
    MOVWF   FSR0H
INIT_NOKIA
    MOVIW   FSR0++
    CALL    COMANDO_SPI
    MOVIW   [FSR0]
    BTFSS   STATUS,Z
    GOTO    INIT_NOKIA
    RETURN
;***********************************************************************************************
;************************** RUTINA DE POSICIONAMIENTO EN Y (RENGLONES) *************************
;***********************************************************************************************
SET_Y
    ADDLW   B'01000000'
    CALL    COMANDO_SPI
    RETURN
;***********************************************************************************************
;************************** RUTINA DE POSICIONAMIENTO EN X (COLUMNAS) **************************
;***********************************************************************************************
SET_X
    ADDLW   B'10000000'
    CALL    COMANDO_SPI
    RETURN
;***********************************************************************************************
;*************************** ZONA DE DECLARACION DE TABLAS PARA DATOS **************************
;***********************************************************************************************   
    INICIA_NOKIA: dt 0X21,0XCF,0X20,0X0C,0X00
    ADC_TEXT:     dt 0XFC,0X12,0X12,0XFC,0X00,0XFE,0X82,0X82,0X7C,0X00,0X7C,0X82,0X82,0X44,0X00,0X14,0X00
    HOLA_MENSAJE: dt 0XFE,0X10,0X10,0XFE,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X80,0X80,0X80,0X00,0XFC,0X12,0X12,0XFC,0X00;A
    TODO_MENSAJE: dt 0X02,0X02,0XFE,0X02,0X02,0X00,0X7C,0X82,0X82,0X7C,0X00,0XFE,0X82,0X82,0X7C,0X00,0X7C,0X82,0X82,0X7C,0X00
    PIC_MENSAJE:  dt 0X00,0X00,0XFE,0X12,0X12,0X0C,0X00,0XFE,0X00,0X7C,0X82,0X82,0X44,0X00
 
  
 
 
 DATO_SPI
    BSF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPI
    BTFSS   PIR1,SSP1IF
    GOTO    WSPI
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
COMANDO_SPI
    BCF     DC_NOKIA
    BCF     LCD_NOKIA
    BANKSEL SSP1BUF
    MOVWF   SSP1BUF
    BANKSEL PIR1
    BCF     PIR1,SSP1IF
WSPIC
    BTFSS   PIR1,SSP1IF
    GOTO    WSPIC
    BCF     PIR1,SSP1IF
    BANKSEL PORTA
    BSF     LCD_NOKIA
    RETURN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
    
RETARDO
    MOVLW   0X3F
    MOVWF   RET
    MOVWF   RET2
ESP
    DECFSZ  RET,F
    GOTO    ESP
    MOVLW   0XFF
    MOVWF   RET
    DECFSZ  RET2,F
    GOTO    ESP
    RETURN
    END

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 04 de Diciembre de 2015, 05:52:27

Sigamos jugando con tablas y accesos indirectos!

Código: ASM

MUESTRA_VALOR
 
    BANKSEL ADC_VALUE               ; ME ASEGURO ESTAR EN BANCO DONDE ESTA ADC_VALUE (MI REGISTRO)
    MOVF    ADC_VALUE,W             ; MOVEMOS ADC_VALUE A W PARA OBTENER 3 BYTES CON EL DATO
 
    CALL    CONVERSION_BCD          ; RUTINA DE CONVERISON BINARIO>>BCD
 
    CLRF    FSR1H                   ; Set de puntero para el valor centena, las variables deben estar ubicadas en ORDEN y SEGUIDAS Centenas, Decenas, Unidades para que funcione
    MOVLW   CENTENAS                ; No puse LOW() por que es una constante, aunque no se si afectaria
    MOVWF   FSR1L
 
Loopete
 
    MOVLW   LOW(NUMS)               ; MUEVO LA DIRECCION DE LA TABLA NUMS (LOW)
    MOVWF   FSR0L                   ; A MI REGISTRO FSR0L
    MOVLW   HIGH(NUMS)              ; MUEVO LA DIRECCION DE LA TABLA NUMS (HIGH)
    MOVWF   FSR0H                   ; AL REGISTRO FSR0H
 
    BCF     STATUS,C                ; Carry = 0, para la rotacion me aseguro
    RLF     INDF1,W                 ; W = x*2
    RLF     WREG,W                  ; W = x*2*2 = x*4
    ADDWF   FSR0L,F                 ; Sumo a la base de la tabla para obtener el offset
    BTFSC   STATUS,C                ; Correccion por si se excedio, una precaucion solo por si se puso en un borde la tabla
    INCF    FSR0H,F
 
    MOVLW   .4                      ; NUMERO DE BYTES A TRANSMITIR
    CALL    MENSAJE_X_BYTES         ; LLAMO A SUBRUTINA DE TRANSMISION DE BYTES
 
    CLRW                            ; Envio el 0x00 que habia que enviar siempre al final, es esto, o ocupar "9 bytes", en realiadad 9 palabras de memoria mas mas en tabla
    CALL    DATO_SPI
 
    MOVLW   UNIDADES                ; El valor a que apunta es las unidades? es decir se envio las unidades recien?
    SUBWF   FSR1L,W
    BTFSC   STATUS,Z                ; Si: Sale
    RETURN
    INCF    FSR1L,F                 ; No: Envia el proximo
    GOTO Loopete
 
 
 
 
;***********************************************************************************************
;***************************** RUTINAS PARA MANDAR VALORES EN LCD ******************************
;*********************************************************************************************** 
 
 
 
NUMS:   dt 0x7C, 0x82, 0x82, 0x7C               ;0
        dt 0x00, 0x84, 0xFE, 0x80               ;1
        dt 0xC4, 0xA2, 0x92, 0x8C               ;2
        dt 0x44, 0x92, 0x92, 0x6C               ;3
        dt 0x30, 0x28, 0x24, 0xFE               ;4
        dt 0x4E, 0x8A, 0x8A, 0x72               ;5
        dt 0x7C, 0x92, 0x92, 0x64               ;6
        dt 0x62, 0x12, 0x0A, 0x06               ;7
        dt 0x6C, 0x92, 0x92, 0x6C               ;8
        dt 0x4C, 0x92, 0x92, 0x7C               ;9

Solo para jugar un poco mas con los accesos indirectos nada mas, podria haber puesto un contador en ves de verificar las direcciones.
Tambien se me ocurrio implementar una Tabla que contenga las direcciones de los registros a enviar y el orden, de esa forma los registros podian estar en cualquier valor, pero para hacerlo simple requeria de al menos 3 punteros o utilizar mas registros como para tener un "almacenamiento temporal" y luego volver a cargarlo. Aunque solo sirve para registros del primer banco, necesitaria un registro mas para hacerlo para todos los bancos. Ya que necesitaria 2 bytes para la direccion por cada registro

Código: ASM

;***********************************************************************************************
;************************ RUTINA PARA MOSTRAR VALOR ADC 8 BITS *********************************
;***********************************************************************************************   
MUESTRA_VALOR
 
    BANKSEL ADC_VALUE               ; ME ASEGURO ESTAR EN BANCO DONDE ESTA ADC_VALUE (MI REGISTRO)
    MOVF    ADC_VALUE,W             ; MOVEMOS ADC_VALUE A W PARA OBTENER 3 BYTES CON EL DATO
 
    CALL    CONVERSION_BCD          ; RUTINA DE CONVERISON BINARIO>>BCD
 
    MOVLW   HIGH(REG_A_ENVIAR)      ; Valor de la tabla en FSR1
    CLRF    FSR1H               
    MOVLW   LOW(REG_A_ENVIAR)
    MOVWF   FSR1L
 
Loopete
 
    MOVIW   FSR1++                  ; Es 0? salgo, se termino
    BTFSC   STATUS,Z
    RETURN
 
    MOVWF   FSR1H_AUX               ; Dato recuperado desde W, valores de direccion de registros, guardo momentaneamente
    MOVF    FSR1L                   ; Guardo FSR1L - Tabla
    MOVWF   FSR1L_AUX               ; Seteo FSR1L - Registro
    MOVF    FSR1H_AUX               ; Guardo FSR1H - Tabla
    MOVWF   FSR1L                   ; Seteo FSR1H = 0x00
    MOVF    FSR1H
    MOVWF   FSR1H_AUX
    CLRF    FSR1H
 
 
    MOVLW   LOW(NUMS)               ; MUEVO LA DIRECCION DE LA TABLA NUMS (LOW)
    MOVWF   FSR0L                   ; A MI REGISTRO FSR0L
    MOVLW   HIGH(NUMS)              ; MUEVO LA DIRECCION DE LA TABLA NUMS (HIGH)
    MOVWF   FSR0H                   ; AL REGISTRO FSR0H
 
    BCF     STATUS,C                ; Carry = 0, para la rotacion me aseguro
    RLF     INDF1,W                 ; W = x*2
    RLF     WREG,W                  ; W = x*2*2 = x*4
    ADDWF   FSR0L,F                 ; Sumo a la base de la tabla para obtener el offset
    BTFSC   STATUS,C                ; Correccion por si se excedio, una precaucion solo por si se puso en un borde la tabla
    INCF    FSR0H,F
 
    MOVLW   .4                      ; NUMERO DE BYTES A TRANSMITIR
    CALL    MENSAJE_X_BYTES         ; LLAMO A SUBRUTINA DE TRANSMISION DE BYTES
 
    CLRW                            ; Envio el 0x00 que habia que enviar siempre al final, es esto, o ocupar "9 bytes", en realiadad 9 palabras de memoria mas mas en tabla
    CALL    DATO_SPI
 
    MOVF    FSR1L_AUX               ; Recupero el valor de la tabla anterior
    MOVWF   FSR1L
    MOVF    FSR1H_AUX
    MOVWF   FSR1H
 
    GOTO Loopete                    ; Repito hasta que sea 0x00 y salga
 
 
 
 
;***********************************************************************************************
;***************************** RUTINAS PARA MANDAR VALORES EN LCD ******************************
;*********************************************************************************************** 
 
 
REG_A_ENVIAR:
        dt CENTENAS,DECENAS,UNIDADES,0x00
 
NUMS:   dt 0x7C, 0x82, 0x82, 0x7C               ;0
        dt 0x00, 0x84, 0xFE, 0x80               ;1
        dt 0xC4, 0xA2, 0x92, 0x8C               ;2
        dt 0x44, 0x92, 0x92, 0x6C               ;3
        dt 0x30, 0x28, 0x24, 0xFE               ;4
        dt 0x4E, 0x8A, 0x8A, 0x72               ;5
        dt 0x7C, 0x92, 0x92, 0x64               ;6
        dt 0x62, 0x12, 0x0A, 0x06               ;7
        dt 0x6C, 0x92, 0x92, 0x6C               ;8
        dt 0x4C, 0x92, 0x92, 0x7C               ;9

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 11 de Febrero de 2016, 02:57:45

Gracias KillerJC en unos minutos más lo implementó para saber como queda. Dos preguntas más. Como me recomiendas leer la frecuencia a la que esta entrando la señal del ADC? Y la otra pregunta es sobre como podría implementar una "ROM" con todos los caracteres ASCII? Digo si es posible

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 11 de Febrero de 2016, 03:12:01

Cita de: Pinolillo16 en 11 de Febrero de 2016, 02:57:45

Gracias KillerJC en unos minutos más lo implementó para saber como queda. Dos preguntas más. Como me recomiendas leer la frecuencia a la que esta entrando la señal del ADC? Y la otra pregunta es sobre como podría implementar una "ROM" con todos los caracteres ASCII? Digo si es posible

A no ser que tengas una senoidal y quieras medir eso es la unica razon por la que mediria "frecuencia". Si es una señal aleatoria se complica ( y no se por que lo harias realmente).
Creo que lo mejor es un circuito externo ( 2 diodos de clamping + resistencia ) y que observar cuando pasa de 1 a 0 y con un timer ver el tiempo del mismo, o podes hacer uso del CCP.

Respecto a los caracteres ASCII, si es posible, pero te va a llevar tiempo hacerlos todos o casi todos. Y luego los vas a tener que poner con .dt al igual que se hizo lo demas. Incluso los podes poner en una direccion especifica con un ORG antes. Eso depende de vos nomas. Y recorda que te va a consumir bastante flash.
Pero por que hacerlo uno mismo cuando podria sacarlo de otro lado?

http://sunge.awardspace.com/glcd-sd/node4.html

Agregar los .dt y quitar todo lo demas. WIN, tenes tu tabla ya realizada :P obviamente que comienza de 0x20 ( 32 ), asi que si usas la tabla esa al valor a escribir deberias restarle 0x20 asi coincide con los de la tabla :)

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 26 de Febrero de 2016, 03:57:04

jejej disculpa la demora KillerJC deberás que estas lleno de mucha información muy interesante. La verdad no he tenido mucho tiempo libre para seguir practicando, y bueno respecto a los caracteres eso haré para ya tener listos todos. Sobre el calculo de la frecuencia realmente solo lo decia pensado en alguna aplicación interesante como hacer un mini osciloscopio pero creo que es mas dificil. Alguna idea que tengas para seguir trabajando con esta LCD Nokia? Este PIC me ha gustado mucho respecto algunos otros mas maduros.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 26 de Febrero de 2016, 04:02:17

Para complementar un poco este post. Me decidi a manejar ahora una LCD 1602 que básicamente muchos conocen, debido a la restriccion que hay en cuanto el numero de pines hice la interfaz de 4 bits. No me rompi la cabeza mucho para adecuar la muy famosa libreria de LCD 4BIT. Aqui el código de la Librería:

Código: ASM

CBLOCK
LCD_DATO
LCD_GuardaDato
LCD_Auxiliar1
LCD_Auxiliar2
ENDC
 
CHAR_X_LINEA    EQU     .16             ; Número de caracteres por línea de la pantalla.
 
#DEFINE  RS             PORTC,0
#DEFINE  RE             PORTC,1
#DEFINE  LCD_BUS        PORTB
 
INI_LCD
;*********************************************************
    BANKSEL T1CON
    MOVLW   B'00110000'             ; CONFIGURO TMR1
    MOVWF   T1CON                   ; PARA RETARDOS
;*********************************************************
        
    BCF         RE                      ; DESHABILITAMOS PIN 
    BCF         RS                      ; ACTIVAMOS MODO COMANDO PONIENDO RS EN 0
    CALL        RET_10ms                ; RETARDO PARA ESTABILIZACIÓN LCD
    MOVLW       B'00110000'             ;
    CALL        LCD_WRITE               ; ESCRIBIMOS DATO EN LCD
    CALL        RET_5ms 
    MOVLW       B'00110000'     
    CALL        LCD_WRITE
    CALL        RET_100us
    MOVLW       B'00110000'     
    CALL        LCD_WRITE
    CALL        RET_100us               ; Este retardo es necesario para simular en PROTEUS.
    MOVLW       B'00100000'             ; Interface de 4 bits.
    CALL        LCD_WRITE
    CALL        RET_100us               ; Este retardo es necesario para simular en PROTEUS.
    CALL        LCD_2Lineas4Bits5x7     ; LCD de 2 líneas y caracteres de 5x7 puntos.
    CALL        LCD_CLEAR               ; Pantalla encendida y limpia. Cursor al principio
    CALL        LCD_C_OFF               ; de la línea 1. Cursor apagado.
    CALL        LCD_CursorIncr          ; Cursor en modo incrementar.
    RETURN
LCD_WRITE
    ANDLW       B'11110000'             ; Se queda con el nibble alto del dato que es el
    MOVWF       LCD_DATO                ; que hay que enviar y lo guarda.
    MOVF        LCD_BUS,W               ; Lee la información actual de la parte baja
    ANDLW       B'00001111'             ; del Puerto B, que no se debe alterar.
    IORWF       LCD_DATO,F              ; Enviará la parte alta del dato de entrada
    MOVF        LCD_DATO,W              ; Recupera el dato a enviar.
    MOVWF       LCD_BUS                 ; Envía el dato al módulo LCD.
    BSF         RE                      ; Permite funcionamiento del LCD mediante un pequeño
    BCF         RE                      ; pulso y termina impidiendo el funcionamiento del LC
    RETURN
LCD_CursorIncr                          ; Cursor en modo incrementar.
    MOVLW       B'00000110'
    BRA         LCD_CMD
LCD_L1                                                  ; Cursor al principio de la Línea 1.
    MOVLW       B'10000000'                             ; Dirección 00h de la DDRAM
    BRA         LCD_CMD
LCD_L2                                                  ; Cursor al principio de la Línea 2.
    MOVLW       B'11000000'                             ; Dirección 40h de la DDRAM
    BRA         LCD_CMD
LCD_L3                                                  ; Cursor al principio de la Línea 3
    MOVLW       B'10010100'                             ; Dirección 14h de la DDRAM
    BRA         LCD_CMD
LCD_L4                                                  ; Cursor al principio de la Línea 4
    MOVLW       B'11010100'                             ; Dirección 54h de la DDRAM
    BRA         LCD_CMD
LCD_PosicionLinea1                                      ; Cursor a posición de la Línea 1, a partir de la
    IORLW       b'10000000'                             ; dirección 00h de la DDRAM más el valor del
    BRA         LCD_CMD         ; registro W.
LCD_PosicionLinea2                                      ; Cursor a posición de la Línea 2, a partir de la
    IORLW       b'11000000'                             ; dirección 40h de la DDRAM más el valor del
    BRA         LCD_CMD         ; registro W.
LCD_OFF                                                         ; Pantalla apagada.
    MOVLW       B'00001000'
    BRA         LCD_CMD
LCD_C_ON                                                ; Pantalla encendida y cursor encendido.
    MOVLW       B'00001110'
    BRA         LCD_CMD
LCD_C_OFF                                               ; Pantalla encendida y cursor apagado.
    MOVLW       B'00001100'
    BRA         LCD_CMD
LCD_CLEAR                                                       ; Borra toda la pantalla, memoria DDRAM y pone el 
    MOVLW       B'00000001'                             ; cursor a principio de la línea 1.
    BRA LCD_CMD
LCD_2Lineas4Bits5x7                                     ; Define la pantalla de 2 líneas, con caracteres
    MOVLW       B'00101000'                             ; de 5x7 puntos y conexión al PIC mediante bus de
LCD_CMD
    BCF RS                              ; Activa el Modo Comando, poniendo RS=0.
    BRA LCD_Envia
ENVIAR_DATO
    BSF RS                              ; Activa el "Modo Dato", poniendo RS=1.
    CALL        LCD_CodigoCGROM                 ; Obtiene el código para correcta visualización.
LCD_Envia
    MOVWF       LCD_GuardaDato                  ; Guarda el dato a enviar.
    CALL        LCD_WRITE                       ; Primero envía el nibble alto.
    SWAPF       LCD_GuardaDato,W                ; Ahora envía el nibble bajo. Para ello pasa el
                                                ; nibble bajo del dato a enviar a parte alta del byte.
    CALL        LCD_WRITE                       ; Se envía al visualizador LCD.
    BTFSS       RS                              ; Debe garantizar una correcta escritura manteniendo 
    CALL        RET_1ms                         ; 2 ms en modo comando y 50 µs en modo cáracter.
    CALL        RET_100us
    RETURN      
LCD_CodigoCGROM
    MOVWF       LCD_DATO                                ; Guarda el valor del carácter y comprueba si es
LCD_EnheMinuscula                                       ; un carácter especial.
    SUBLW       'ñ'                                    ; ¿Es la "ñ"?
    BTFSS       STATUS,Z
    GOTO        LCD_EnheMayuscula               ; No es "ñ".
    MOVLW       B'11101110'                             ; Código CGROM de la "ñ".
    MOVWF       LCD_DATO
    GOTO        LCD_FinCGROM
LCD_EnheMayuscula
    MOVF        LCD_DATO,W                              ; Recupera el código ASCII de entrada.
    SUBLW       'Ñ'                                    ; ¿Es la "Ñ"?
    BTFSS       STATUS,Z
    GOTO        LCD_Grado                               ; No es "Ñ".
    MOVLW       b'11101110'                             ; Código CGROM de la "ñ". (No hay símbolo para
    MOVWF       LCD_DATO                                ; la "Ñ" mayúscula en la CGROM).
    GOTO        LCD_FinCGROM    
LCD_Grado
    MOVF    LCD_DATO,W                          ; Recupera el código ASCII de entrada.
    SUBLW       'º'                                    ; ¿Es el símbolo "º"?
    BTFSS   STATUS,Z
    GOTO    LCD_FinCGROM                        ; No es "º".
    MOVLW   b'11011111'                         ; Código CGROM del símbolo "º".
    MOVWF   LCD_DATO
LCD_FinCGROM
    MOVF        LCD_DATO,W                              ; En (W) el código buscado.
    RETURN
LCD_LineaEnBlanco
    MOVLW   CHAR_X_LINEA
    BRA     LCD_EnviaBlancos
LCD_UnEspacioBlanco
    MOVLW   .1
    BRA     LCD_EnviaBlancos
LCD_DosEspaciosBlancos
    MOVLW   .2
    BRA     LCD_EnviaBlancos
LCD_TresEspaciosBlancos
    MOVLW   .3
LCD_EnviaBlancos
    MOVWF   LCD_Auxiliar1                       ; (LCD_Auxiliar1) se utiliza como contador.
LCD_EnviaOtroBlanco     
    MOVLW       ' '                                             ; Esto es un espacio en blanco.
    CALL        LCD_DATO                        ; Visualiza tanto espacios en blanco como se
    DECFSZ      LCD_Auxiliar1,F                 ; haya cargado en (LCD_Auxiliar1).
    GOTO        LCD_EnviaOtroBlanco
    RETURN
 
; Subrutinas "LCD_ByteCompleto" y "LCD_Byte" --------------------------------------------
;
; Subrutina "LCD_ByteCompleto", visualiza el byte que almacena el registro W en el
; lugar actual de la pantalla. Por ejemplo, si (W)=b'10101110' visualiza "AE".
;
; Subrutina "LCD_Byte" igual que la anterior, pero en caso de que el nibble alto sea cero 
; visualiza en su lugar un espacio en blanco. Por ejemplo si (W)=b'10101110' visualiza "AE"
; y si (W)=b'00001110', visualiza " E" (un espacio blanco delante).
;
; Utilizan la subrutina "LCD_Nibble" que se analiza más adelante.
LCD_Byte
        movwf   LCD_Auxiliar2                   ; Guarda el valor de entrada.
        andlw   b'11110000'                             ; Analiza si el nibble alto es cero.
        btfss   STATUS,Z                                ; Si es cero lo apaga.
        goto    LCD_VisualizaAlto               ; No es cero y lo visualiza.
        movlw   ' '                                             ; Visualiza un espacio en blanco.
        call    LCD_DATO
        goto    LCD_VisualizaBajo
 
LCD_ByteCompleto
        movwf   LCD_Auxiliar2                   ; Guarda el valor de entrada.
LCD_VisualizaAlto
        swapf   LCD_Auxiliar2,W                 ; Pone el nibble alto en la parte baja.
        call    LCD_Nibble                              ; Lo visualiza.
LCD_VisualizaBajo
        movf    LCD_Auxiliar2,W                 ; Repite el proceso con el nibble bajo.
LCD_Nibble
        andlw   b'00001111'                             ; Se queda con la parte baja.
        movwf   LCD_Auxiliar1                   ; Lo guarda.
        sublw   0x09                                    ; Comprueba si hay que representarlo con letra.
        btfss   STATUS,C        
        goto    LCD_EnviaByteLetra
        movf    LCD_Auxiliar1,W
        addlw   '0'                                             ; El número se pasa a carácter ASCII sumándole
        goto    LCD_FinVisualizaDigito  ; el ASCII del cero y lo visualiza.
LCD_EnviaByteLetra
        movf    LCD_Auxiliar1,W
        addlw   'A'-0x0A                                ; Sí, por tanto, se le suma el ASCII de la 'A'.
LCD_FinVisualizaDigito
        goto    LCD_DATO                        ; Y visualiza el carácter. Se hace con un "goto"
                                                                        ; para no sobrecargar la pila.
 
RET_37us
        BCF     PIR1,TMR1IF
        MOVLW   0XFF
        MOVWF   TMR1H
        MOVLW   0XDC
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        RETURN
RET_100us
        BCF     PIR1,TMR1IF
        MOVLW   0XFF
        MOVWF   TMR1H
        MOVLW   0X9C
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        RETURN
RET_1ms
        BCF     PIR1,TMR1IF
        MOVLW   0XFC
        MOVWF   TMR1H
        MOVLW   0X18
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        RETURN
RET_5ms
        BCF     PIR1,TMR1IF
        MOVLW   0XEC
        MOVWF   TMR1H
        MOVLW   0X78
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        RETURN
RET_10ms
        BCF     PIR1,TMR1IF
        MOVLW   0XD8
        MOVWF   TMR1H
        MOVLW   0XF0
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        RETURN
RET_50ms
        BCF     PIR1,TMR1IF
        MOVLW   0X3C
        MOVWF   TMR1H
        MOVLW   0XB0
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        RETURN
RET_100ms
        BCF     PIR1,TMR1IF
        MOVLW   0X3C
        MOVWF   TMR1H
        MOVLW   0XB0
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        BCF     PIR1,TMR1IF
        MOVLW   0X3C
        MOVWF   TMR1H
        MOVLW   0XB0
        MOVWF   TMR1L
        BSF     T1CON,TMR1ON
        BTFSS   PIR1,TMR1IF
        GOTO    $-1
        BCF     T1CON,TMR1ON
        RETURN
RET_500ms
        MOVLW   .5
        MOVWF   TIME_AUX
        CALL    RET_100ms
        DECFSZ  TIME_AUX,F
        GOTO    $-2
        RETURN
RET_1s
        MOVLW   .10
        MOVWF   TIME_AUX
        CALL    RET_100ms
        DECFSZ  TIME_AUX,F
        GOTO    $-2
        RETURN

Como se ve al final, genere unas rutinas para retardos con el timer 1. Fueron sustituidos en la libreria. Y para empezar este pequeño código de prueba.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    TIME_AUX
    LCD_AUX
    ENDC
;***********************************************************************************************
;********************************* VECTOR DE RESET DEL PIC *************************************
;***********************************************************************************************
    ORG     0X00
    GOTO    CONFIGURA_PIC
;***********************************************************************************************
;***************************** VECTOR DE INTERRUPCION DEL PIC **********************************
;***********************************************************************************************
    ORG     0X04
    RETURN
;***********************************************************************************************
;********************************* CONFIGURACION DEL PIC ***************************************
;***********************************************************************************************
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
;***********************************************************************************************
;*************************** CONFIGURACION DE PUERTOS DEL PIC **********************************
;***********************************************************************************************
    BANKSEL PORTA                   ; ME COLOCO EN EL BANCO DE LOS PORTX
    CLRF    PORTA                   ; LIMPIO PINES ASIGNADOS A PORTA
    CLRF    PORTB                   ; LIMPIO PINEAS ASIGNADOS A PORTB
    CLRF    PORTC                   ; LIMPIO PINEAS ASIGNADOS A PORTC
    BANKSEL LATA                    ; NOS DIRIGIMOS A BANCO DE MEMORIA DONDE ESTA LATX
    CLRF    LATA                    ; LIMPIAMOS LATCH DE PUERTO A
    CLRF    LATB                    ; LIMPIAMOS LATCH DE PUERTO B
    CLRF    LATC                    ; LIMPIAMOS LATCH DE PUERTO C
    BANKSEL ANSELA                  ; ME HUBICO EN BANCO DONDE SE ENCUENTRA ANSELX
    CLRF    ANSELA                  ; LIMPIO REGISTROS ADC ASIGNADOS A PORTA 
    CLRF    ANSELB                  ; LIMPIO REGISTROS ADC ASIGNADOS A PORTB
    CLRF    ANSELC                  ; LIMPIO REGISTROS ADC ASIGNADOS A PORTC
    BANKSEL TRISA                   ; ME HUBICO EN BANCO QUE CONTIENE A TRISX
    CLRF    TRISA                   ; CONFIGURO PORTA COMO SALIDAS
    CLRF    TRISB                   ; CONFIGURO PORTB COMO SALIDAS
    CLRF    TRISC                   ; CONFIGURO PORTC COMO SALIDAS
;;CONFIGURAMOS ADC
;    BANKSEL ADCON1          ; El mismo que el de TRISx
;    MOVLW   B'01100000' 
;    MOVWF   ADCON1 
;    MOVLW   B'00000001'     ;Select channel AN0
;    MOVWF   ADCON0          ;Turn ADC On  
;    BSF     TRISA,0     
;    BANKSEL ANSELA          ;
;    BSF     ANSELA,0 
 
    
    
;***************************************************************************************************
;********************** DEFINICION DE PINES Y BUS DE CONTROL LCD 16X2 ******************************
;***************************************************************************************************    
        CALL    INI_LCD
 PRINCIPAL
        CALL    LCD_L1
        CALL    MENSAJE_UNO
        CALL    RET_1s
        CALL    LCD_L2
        CALL    MENSAJE_DOS
        CALL    RET_1s
        CALL    LCD_CursorIncr
        GOTO    PRINCIPAL
        
MENSAJE_UNO
        MOVLW   HIGH(MENSAJE_PIC)
        MOVWF   FSR0H
        MOVLW   LOW(MENSAJE_PIC)
        MOVWF   FSR0L
        GOTO    SENDING_TEXT
MENSAJE_DOS
        MOVLW   HIGH(MENSAJE_PIC2)
        MOVWF   FSR0H
        MOVLW   LOW(MENSAJE_PIC2)
        MOVWF   FSR0L
        GOTO    SENDING_TEXT
SENDING_TEXT
        CALL    RET_100ms
        MOVIW   FSR0++
        CALL    ENVIAR_DATO
        MOVIW   [FSR0]
        BTFSS   STATUS,Z
        BRA     SENDING_TEXT
        RETURN
 
;***************************************************************************************************
;******************************* ZONA DE DECLARACION DE TABLAS PARA DATOS **************************
;***************************************************************************************************   
 
        MENSAJE_PIC:  dt "Hola Amigos del Foro", 0X00
        MENSAJE_PIC2: dt "Prueba de Tablas", 0X00
 
  #INCLUDE<LCD_4BIT.INC>
 
    END

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 26 de Febrero de 2016, 04:18:46

Te quedo muy bueno. Felicidades!

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 29 de Febrero de 2016, 23:11:26

Bueno gracias KillerJC es muy bueno recibir una felicitacion de tu parte. ;-) ahora trabajare en un pequeño proyecto donde debo implementar un menu de configuración. Hice el código para poder navegar solo con dos opciones.

Código: ASM

#INCLUDE "P16F1707.INC"
 __CONFIG _CONFIG1, _FOSC_INTOSC & _WDTE_OFF & _PWRTE_OFF & _MCLRE_OFF & _CP_OFF & _BOREN_OFF & _CLKOUTEN_OFF
 __CONFIG _CONFIG2, _WRT_OFF & _PPS1WAY_ON & _ZCDDIS_OFF & _PLLEN_ON & _STVREN_ON & _BORV_LO & _LPBOR_OFF & _LVP_OFF
 
    CBLOCK  0X020
    TIME_AUX
    LCD_AUX
    C1
    C2
    ENDC
;***********************************************************************************************
;********************************* VECTOR DE RESET DEL PIC *************************************
;***********************************************************************************************
    ORG     0X00
    GOTO    CONFIGURA_PIC
;***********************************************************************************************
;***************************** VECTOR DE INTERRUPCION DEL PIC **********************************
;***********************************************************************************************
    ORG     0X04
    RETURN
;***********************************************************************************************
;********************************* CONFIGURACION DEL PIC ***************************************
;***********************************************************************************************
 CONFIGURA_PIC
    BANKSEL OSCCON
    MOVLW   B'11111011'
    MOVWF   OSCCON
    MOVLW   B'00011111'
    MOVWF   OSCTUNE
;***********************************************************************************************
;*************************** CONFIGURACION DE PUERTOS DEL PIC **********************************
;***********************************************************************************************
    BANKSEL PORTA                   ; ME COLOCO EN EL BANCO DE LOS PORTX
    CLRF    PORTA                   ; LIMPIO PINES ASIGNADOS A PORTA
    CLRF    PORTB                   ; LIMPIO PINEAS ASIGNADOS A PORTB
    CLRF    PORTC                   ; LIMPIO PINEAS ASIGNADOS A PORTC
    BANKSEL LATA                    ; NOS DIRIGIMOS A BANCO DE MEMORIA DONDE ESTA LATX
    CLRF    LATA                    ; LIMPIAMOS LATCH DE PUERTO A
    CLRF    LATB                    ; LIMPIAMOS LATCH DE PUERTO B
    CLRF    LATC                    ; LIMPIAMOS LATCH DE PUERTO C
    BANKSEL ANSELA                  ; ME HUBICO EN BANCO DONDE SE ENCUENTRA ANSELX
    CLRF    ANSELA                  ; LIMPIO REGISTROS ADC ASIGNADOS A PORTA 
    CLRF    ANSELB                  ; LIMPIO REGISTROS ADC ASIGNADOS A PORTB
    CLRF    ANSELC                  ; LIMPIO REGISTROS ADC ASIGNADOS A PORTC
    BANKSEL TRISA                   ; ME HUBICO EN BANCO QUE CONTIENE A TRISX
    CLRF    TRISA                   ; CONFIGURO PORTA COMO SALIDAS
    CLRF    TRISB                   ; CONFIGURO PORTB COMO SALIDAS
    CLRF    TRISC                   ; CONFIGURO PORTC COMO SALIDAS
    
    BSF     TRISC,7                 ; PINES DEFINIDOS COMO ENTRADA
    BSF     TRISC,6                 ; CORRESPONDIENTE A BOTONES USUARIO
    
    
#DEFINE UP      PORTC,7             ; BOTON PARA INCREMENTAR
#DEFINE DOWN    PORTC,6             ; BOTON PARA DECREMENTAR
 
    CURSOR  EQU B'01111110'
    
    
;***************************************************************************************************
;********************** DEFINICION DE PINES Y BUS DE CONTROL LCD 16X2 ******************************
;***************************************************************************************************    
        CALL    INI_LCD
MAIN_SCREEN
        MOVLW   CURSOR
        MOVWF   C1
        CALL    LCD_L1MENU
        CALL    MENSAJE_UNO
        CALL    LCD_L2MENU
        CALL    MENSAJE_DOS
        CALL    WRITE_CURSOR
PRINCIPAL
        BTFSS   UP
        BRA     CAMBIA_CURSOR
        BTFSS   DOWN
        BRA     CAMBIA_CURSOR
        GOTO    PRINCIPAL
CAMBIA_CURSOR
        BTFSS   UP
        GOTO    CAMBIA_CURSOR
        BTFSS   DOWN
        GOTO    CAMBIA_CURSOR
        MOVF    C1,W
        SUBLW   CURSOR
        BTFSS   STATUS,Z
        GOTO    CAMBIA_C1
        MOVLW   ' '
        MOVWF   C1
        MOVLW   CURSOR
        MOVWF   C2
        CALL    WRITE_CURSOR
        GOTO    PRINCIPAL
CAMBIA_C1
        MOVLW   CURSOR
        MOVWF   C1
        MOVLW   ' '
        MOVWF   C2
        CALL    WRITE_CURSOR
        GOTO    PRINCIPAL
WRITE_CURSOR
        CALL    LCD_L1
        MOVF    C1,W
        CALL    ENVIAR_DATO
        CALL    LCD_L2
        MOVF    C2,W
        CALL    ENVIAR_DATO
        RETURN
        
MENSAJE_UNO
        MOVLW   HIGH(MENSAJE_PIC)
        MOVWF   FSR0H
        MOVLW   LOW(MENSAJE_PIC)
        MOVWF   FSR0L
        GOTO    SENDING_TEXT
MENSAJE_DOS
        MOVLW   HIGH(MENSAJE_PIC2)
        MOVWF   FSR0H
        MOVLW   LOW(MENSAJE_PIC2)
        MOVWF   FSR0L
        GOTO    SENDING_TEXT
SENDING_TEXT
        MOVIW   FSR0++
        CALL    ENVIAR_DATO
        MOVIW   [FSR0]
        BTFSS   STATUS,Z
        BRA     SENDING_TEXT
        RETURN
 
;***************************************************************************************************
;******************************* ZONA DE DECLARACION DE TABLAS PARA DATOS **************************
;***************************************************************************************************   
 
;        MENSAJE_PIC:  dt "Absoluto x 2 Ch", 0X00
;       MENSAJE_PIC2: dt "Diferencial", 0X00
        
        MENSAJE_PIC:  dt "Opcion 1", 0X00
        MENSAJE_PIC2: dt "Opcion 2", 0X00
 
  #INCLUDE<LCD_4BIT.INC>
 
    END

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 16 de Marzo de 2016, 22:33:20

Bueno pues me quiero hacer un espacio, esta vez para diseñarme una tarjeta entrenadora para este PIC. Entonces quisiera que me dieran su punto de vista que puedo implementar?

Pensaba lo siguiente, electronica de alimentacion basica, conexion para LCD Nokia 5110 y LCD 16x2. Pero la pregunta es que mas puedo incorporar?

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 16 de Marzo de 2016, 23:19:16

La verdad que yo solo hice una ves una tarjeta entrenadora. Luego me di cuenta de lo limitado que era y ahora la tengo guardada y no la toque nunca mas. Limitado en el sentido que no se adapta a todas las situaciones sino que terminas rebuscandotela para poder hacer funcionar algo que tal ves si tuvieras la libertad de acomodar los pines seria muy facil.
No quiero decir que no sirva, muchos aca han realizado tarjetas entrenadoras para varios PICs, algunos ejemplos creo que Suky hizo una, LABmouse otra dsRRBOARD, y hay miles mas que han usado una en proyectos y me parece excelente. Recuerdo una que tenia CAN/ LIN / etc etc etc, creo que era de MGLSOFT.

Pero al menos mi intento no me gusto para nada ejeje. Y termina siendo mas rapido poner un par de cablecitos en el protoboard.

Asi que no te podria ayudar demasiado en eso.

Si tiene UART tiene que tener una salida UART, ya que hay muchas cosas UART, a no ser que incorpores algunas en la placa y las demas lo dejes aparte.
Si tiene I2C podes conectar muchas cosas por I2C, esta esta mucho mejor por que podes poner lo que quieras que se maneje por I2C y dejar un conector para agregar en cualquier caso.
SPI Comparte normalmente con I2C, asi que en ese sentido lo veo un poco mas complejo tener los 2 juntos, a no ser que pueda remapearse el SPI a otro pin que no sea I2C.
Tener salidas de puertos al exterior.

Recuerdo que la placa que habia realizado ( encima la habia hecho con bastantes errores ) podia con jumpers pasar de leds a jumpers y 2 canales con potenciometros + 1 con un pin que podia tomar de afuera. Todo eso llevo a una placa bastante grande y con muchas muchas vias soldadas todas a mano, en un laburo para nada lindo.

EDIT: lo unico que sobrevivio fue un video:

La placa supereior izquierda posee simplemente un boton de reset, cristal para el oscilador, cristal 32Khz para timer1 + 1 pin de GND para conectar la masa del osciloscopio. Todos los demas conectores son los puertos, el cual tienen ademas salidas de tension +5V,+3.3V y GND. La hice para conectarle el dsPIC33FJ32MC202 que tengo y un PIC32MX795L512 ( o algo asi eran, no recuerdo bien ). La de la derecha es la que comentaba. Creo que esa fue una prueba de la interrupcion del timer.

Pero bueno eso fue hace 5 años atras, cuando recien retomaba los PICs ya que hacia mucho que no los tocaba, y cuando pedi ayuda sobre los dsPIC en ASM y nadie ayudo xD jeje, que momentos tristes :(
http://www.todopic.com.ar/foros/index.php?topic=35392.msg294820#msg294820
Eso me paso por aficionado al ASM y bueno eso hace que no quiero que nadie se quede sin una respuesta al menos ( aunque sea una respuesta pobre ).

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 01 de Abril de 2016, 05:05:38

:shock: Killer JC tenías toda la razón sobre este entrenador que estaba planeando por ahí hice dos o tres intentos diferentes pero no me convencieron ya que cada uno lo hice pensando en aplicaciones distintas Jaja mejor seguiré complementando más este post con algunos ejemplos.

Bueno ya encarrerados con SPI quisiera pedir tu opinión sobre que otros dispositivos con este protocolo puedo hacer funcionar, verás me ha llamado mucho la atención manejar memorias SD con este micro, no he leído mucho al respecto pero te pregunto de acuerdo a tu experiencia que tan complejo es hacerlo en Asm? Y también si el micro tiene suficiente memoria para poder hacer lecturas y escrituras de la SD?

Así mismo me gustaría me recomendaras otro dispositivo interesante para usarlo con SPI?

Muchas gracias

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 01 de Abril de 2016, 06:04:06

Cita de: Pinolillo16 en 01 de Abril de 2016, 05:05:38

Bueno ya encarrerados con SPI quisiera pedir tu opinión sobre que otros dispositivos con este protocolo puedo hacer funcionar, verás me ha llamado mucho la atención manejar memorias SD con este micro, no he leído mucho al respecto pero te pregunto de acuerdo a tu experiencia que tan complejo es hacerlo en Asm? Y también si el micro tiene suficiente memoria para poder hacer lecturas y escrituras de la SD?

Así mismo me gustaría me recomendaras otro dispositivo interesante para usarlo con SPI?

Si solo vas a grabar la SD como si fuera una memoria comun, deberias investigar como es la rutina de inicializacion de la SD para que funcione con SPI ( creo que lo podes sacar de cualquier libreria FAT ) y luego grabar directamente (no recuerdo si hay algo mas que hacer aca), ya que implementar FAT en ASM realmente no le veo sentido, seria complicarse demasiado para algo que usando C lo tendrias realizado. Y si lo haces luego te sirva unicamente para ese solo micro, o tengas que implementar muchisimos cambios para llevarlo a otro, lo cual deja de ser viable gastarse cientos de horas en eso. Incluso si lo haces en C , lo compilas y luego lo "mejoras" desde alli.

Respecto a la memoria del micro son 2 , el mayor limitador es la Flash, y la otra es la RAM, para poder crear un buffer grande y continuo.
Que ese PIC lo tiene un poco mas facil, pero como decia implementar FAT creo que seria un suicidio jeje. Si grabarlo en crudo.

Y dispositivos con SPI no se realmente, hay muchos y no se me ocurre ninguno. Ademas hay que ver que conseguis por que tal ves supongamos un acelerometro lo conseguis pero posee interfaz I2C, a pesar que exista uno con SPI.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 07 de Abril de 2016, 04:23:49

Que tal, amigos. Bueno el planteamiento es el siguiente:

Para la complementación de este post deseo implementar un lector de temperatura. Después de hacerlo para seguir manejando SPI comenzare con la uSD como le había comentado a KillerJC. Bueno como tengo a la mano un MAX31855J y Termopar J, son los que deseo implementar. Anteriormente con otro micro ya lo había realizado con un SPI por software tratando bit a bit, en vista de que manejarlo vía hardware es mucho mejor implemente el siguiente código:

Código: ASM

GET_TEMP1
        CLRF    BYTE1
        CLRF    BYTE2
        CLRF    BYTE3
        CLRF    BYTE4
        BANKSEL SSP1BUF
        CLRF    SSP1BUF
        BANKSEL PIR1
        BCF     PIR1,SSP1IF
        BCF     MAX1
        BTFSS   PIR1,SSP1IF
        GOTO    $-1
        BCF     PIR1,SSP1IF
        BANKSEL SSP1BUF
        MOVF    SSP1BUF,W
        BANKSEL BYTE1
        MOVWF   BYTE1
 
        BANKSEL SSP1BUF
        CLRF    SSP1BUF
        BANKSEL PIR1
        BCF     PIR1,SSP1IF
        BTFSS   PIR1,SSP1IF
        GOTO    $-1
        BCF     PIR1,SSP1IF
        BANKSEL SSP1BUF
        MOVF    SSP1BUF,W
        BANKSEL BYTE2
        MOVWF   BYTE2
        
        BANKSEL SSP1BUF
        CLRF    SSP1BUF
        BANKSEL PIR1
        BCF     PIR1,SSP1IF
        BTFSS   PIR1,SSP1IF
        GOTO    $-1
        BCF     PIR1,SSP1IF
        BANKSEL SSP1BUF
        MOVF    SSP1BUF,W
        BANKSEL BYTE3
        MOVWF   BYTE3
 
        BANKSEL SSP1BUF
        CLRF    SSP1BUF
        BANKSEL PIR1
        BCF     PIR1,SSP1IF
        BTFSS   PIR1,SSP1IF
        GOTO    $-1
        BCF     PIR1,SSP1IF
        BANKSEL SSP1BUF
        MOVF    SSP1BUF,W
        BANKSEL BYTE4
        MOVWF   BYTE4
        
        BSF     MAX1
        
        MOVLW   '+'
        MOVWF   SIGNO_AUX
        BTFSS   BYTE1,7
        GOTO    KEEP_WS1
        MOVLW   '-'
        MOVWF   SIGNO_AUX
 
        BCF     BYTE1,7
        MOVF    BYTE1,W
        MOVWF   TEMP_AUX
        SWAPF   TEMP_AUX,F
        BCF     TEMP_AUX,0
        BCF     TEMP_AUX,1
        BCF     TEMP_AUX,2
        BCF     TEMP_AUX,3
        MOVF    BYTE2,W
        MOVLW   B'11110000'
        ANDWF   BYTE2,F
        SWAPF   BYTE2,F
        MOVF    BYTE2,W
        ADDWF   TEMP_AUX,F
        MOVF    TEMP_AUX,W
        RETURN

El punto es que si logro la lectura pero deseo me ayuden a obtener la temperatura real. En la simulación con proteus mis datos no coinciden para nada.

En la imagen anexa obtenida de la hoja de datos del MAX me dice que en los primeros 2 bytes tengo la temperatura del termopar bien con mi programa pretendo hacer lo siguiente:

BYTE1 = SIGNO + 7 BITS DE TEMPERATURA
BYTE2= 4 BITS DE TEMPERATURA + 2 BITS DE DECIMALES + BIT RESERVADO + BIT FAULT

Dados estos primeros Bytes. Solo quiero primero obtener el Byte Bajo de temperatura que es donde encontrare temperaturas de 0 a 255°C

Para ello el procedimiento de acuerdo al código es:

- Pregunto por Signo, después limpio Bit 7 del Byte 1. Me quedan los 3 bits del Byte Alto de temperatura y los 4 bits altos del Byte Bajo
- Aplico un SWAPF para despues limpiar los bits correspondientes al Byte alto.
- Aplico una and con el Byte 2 y la literal b'11110000' para quedarme solo con el nible alto del byte 2 que segun yo es en realidad el nible bajo del Byte bajo de temperatura.
- Despues de la operacion and vuelvo a realizar un SWAP para cambiar los nibles y poder sumarlos directamente.

Bueno segun yo deberia quedarme al final el Byte Low de temperatura. Me queda un numero muy distante al de la simulacion. Las preguntas son:

¿Es correcto mi planteamiento?
¿Existe una forma mas corta para obtener ese byte?

Se que sonara extraño pero solo deseo poder leer de 0 a 250°C maximo por ello no me preocupan los bits altos.

Espero su apoyo colegas.

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 07 de Abril de 2016, 06:59:35

No se donde esta el problema, personalmente lo haria de otra forma al envio/recepcion, con direccionamiento indirecto, con postincremento seria lo idea para tener un buffer, aunque bueno veo que estas borrando 2 veces sin sentido el flag, asi que quedaria algo asi:

Código: ASM

BANKSEL SSP1BUF
        CLRF    SSP1BUF
        BANKSEL PIR1
        BTFSS   PIR1,SSP1IF
        GOTO    $-1
        BCF     PIR1,SSP1IF          ; Aca borro el flag, no hace falta hacerlo 2 veces
        BANKSEL SSP1BUF
        MOVF    SSP1BUF,W
        BANKSEL BYTE2
        MOVWF   BYTE2

Lo recibido es:

- 1 bit de signo de Temperatura del sensor
- 13 bits de temperatura los cuales 2 son decimales, es decir 0000 0000 000,0 0
- 1 bit que es siempre 0
- 1 bit que deberia si o si ser 0, sino indica falla, es lo primero a ver.
- 1 bit de signo de temperatura interna del MAX
- 11 bits de temperatura interna del MAX, 4 son decimales. 0000 000,0 0000
- 1 bit que siempre es 0
- 3 bits mas que indican cuales fueron las fallas.

Entonces comenzando con el tratamiento lo primero es ver si existe una falla (bit 16 - Bit0 del 2do byte ). Luego tratarlo.

Código: ASM

ANALIZAR_BYTES
        BTFSC   BYTE2,0
        GOTO    CON_FALLA
SIN_FALLA
 
        ;Aca codigo para sacar ambas temperaturas.
 
        ; Primero temperatura interna que es la mas simple
        ; En el segundo byte se encuentra el signo y el entero de esta misma
        MOVLW   '+'
        BTFSC   BYTE3,7
        MOVLW   '-'
        MOVWF   SIGNO_TEMP_INT          ; Signo en ASCII '+' o '-'
        MOVLW   0x7F
        ANDWF   BYTE3, W
        MOVWF   ENTERO_TEMP_INT         ; Valor Entero de esa temperatura
        SWAPF   BYTE4, W
        ANDLW   0x0F
        MOVWF   FRACCION_TEMP_INT       ; Fraccionario ( 4 bits )
 
        ; Segundo temperatura termopar
        ; siii iiii | iiii, ff        - s = signo, i = entero, ff = Fraccion , en Byte1 y 2
 
        MOVLW   '+'
        BTFSC   BYTE1,1
        MOVLW   '-'
        MOVWF   SIGNO_TEMP_TERMOPAR
        RRF     BYTE2, W
        MOVWF   FRACCION_TEMP_TERMOPAR          ; Registro = xiii iffx
        RRF     FRACCION_TEMP_TERMOPAR, F       ; Registro = xxii iiff
        MOVLW   0x03
        ANDWF   FRACCION_TEMP_TERMOPAR, F       ; Registro = 0000 00ff
        SWAPF   BYTE2, W                        ; W = xxff iiii
        ANDLW   0x0F
        MOVWF   ENTERO_LOW_TEMP_TERMOPAR        ; Registro_low = 0000 iiii
        SWAPF   BYTE1, W                        ; W = iiii siii
        MOVWF   ENTERO_HIGH_TEMP_TERMOPAR, F    ; Registro_high = iiii siii
        ANDLW   0xF0                            ; W = iiii 0000
        IORWF   ENTERO_LOW_TEMP_TERMOPAR, F     ; Registro_low = iiii iiii
        MOVLW   0x07
        ANDWF   ENTERO_HIGH_TEMP_TERMOPAR, F    ; Registro_high = 0000 0iii
        
        RETLW   0
 
 
CON_FALLA
        BTFSC   BYTE4,0
        GOTO    FALLA_OC
        BTFSC   BYTE4,1
        GOTO    FALLA_SCG
FALLA_SVC
        ;Aca entra si hay una falla de corto a VCC
        RETLW -1
FALLA_SCG
        ;Aca entra si hay una falla de corto a GND
        RETLW -1
FALLA_OC
        ;Aca entra si no hay nada conectado
        RETLW -1

No tuve en cuenta ningun banco, asi que ojo con eso, y seguro que debe haber un error por ahi, tambien jamas modifico los valores de BYTE1/2/3/4 quedan con sus valores originales por si queres debugearlo.
Pero tu codigo al menos saca el valor entero ( los 8 bits mas bajos obviamente ), Asi que no veo cual seria el problema.
Estas respetando los tiempos de transmision, es decir con una frecuencia de menos de 5Mhz y tambien por ahora mejor tener el CS del MAX en 0, ya que creo que este es el CS:

Código: ASM

BCF     MAX1

Si lo estas haciendo asi, observa que ya enviaste 0x00 para que el SPI comienze a transmitir y luego pones el CS en 0. Esto tal ves te introduzca uno o 2 ceros mas sin querer. El tiempo entre el CS en bajo y el comienzo de envio es de 100ns minimo, asi que si estas a 20Mhz solo pone el BCF del CS antes del los CLRF y vas sobrado. El BSF esta bien, ya que se termino la comunicacion.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 12 de Abril de 2016, 03:22:42

Siguiendo en el desarrollo de la practica me encontre con esto :oops: KillerJC que debo hacer?

Código: ASM

Error - section '.org_1' can not fit the absolute section. Section '.org_1' start=0x00000004, length=0x0000107c

Lei varios post donde recomiendan partir el programa. Como lo hago? Si es que se puede, que mas puedo hacer.

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 12 de Abril de 2016, 05:01:41

Pregunta... que micro estas usando? Si es el PIC16F1707 entonces te quedaste sin memoria..

Pero estamos hablando que te pasaste por MUCHO en la memoria. Por mas que lo dividas es imposible
El PIC16F1707 puede almacenar un maximo de 2048 palabras de flash, desde 0x000 a 0x7FF , por eso mismo ves en el archivo del linker :

16f1707_g.lkr

Citar

CODEPAGE NAME=page0 START=0x0 END=0x7FF
CODEPAGE NAME=.idlocs START=0x8000 END=0x8003 PROTECTED
CODEPAGE NAME=.devid START=0x8006 END=0x8006 PROTECTED
CODEPAGE NAME=.config START=0x8007 END=0x8008 PROTECTED

Normalmente uno lo que hace es poner un ORG (0x00) en el reset, y luego un ORG en el vector de interrupcion, entonces comienza de 0x04 todo lo que esta debajo de esa ORG (por eso dice start 0x04), El problema comienza cuando el ~~compilador~~ linker intenta meter ese pedazo de instrucciones/datos de un largo de 0x107C palabras en la memoria ( 4220 palabras! ) en el unico lugar que posee en flash que es de 0x0 a 0x7FF. Y por lo cual es evidente que no va a entrar ni queriendo en 2044 lugares (4 menos por los vectores). Entonces te dice "la org_1 (por que no le diste nombre) que comienza en 0x04 no entra en el espacio asignado(can not fit) y el largo que intentas meter es de 0x107C"

Si queres ver que es eso, trata de comentar 1 sola instruccion cualquiera (que no sea un MOVIW/MOVWI que ocupan 2 lugares)y fijate que el length deberia cambiar a 0x107B

----------------------------------------------------------------------------------------------------

Otra forma de probarlo. El 16F1708 tiene hasta 4096 palabras y el 16F1709 tiene hasta 8192

Archivo linker del 16F1709:

16f1709_g.lkr

Citar

CODEPAGE NAME=page0 START=0x0 END=0x7FF
CODEPAGE NAME=page1 START=0x800 END=0xFFF
CODEPAGE NAME=page2 START=0x1000 END=0x17FF
CODEPAGE NAME=page3 START=0x1800 END=0x1FFF
CODEPAGE NAME=.idlocs START=0x8000 END=0x8003 PROTECTED
CODEPAGE NAME=.devid START=0x8006 END=0x8006 PROTECTED
CODEPAGE NAME=.config START=0x8007 END=0x8008 PROTECTED

Como ves en este ultimo esta separado en paginas, cada pagina con 2048 palabras, abarcando desde 0x0 a 0x1FFF. Si lo "compilas" con este PIC (ya que es de la misma familia y no tendiras problemas) deberias tener aproximadamente el 51.5% ocupado del micro. Y que nuevamente te va a dar una idea de que el problema es la falta de espacio en flash.

----------------------------------------------------------------------------------------------------

Tambien otra forma simple de que aparezca este error en el PIC16F1707 sin necesidad de escribir demasiado codigo ( solo 3 lineas ) es asi:

Código: ASM

test ORG 0x7FF
        MOVLW   0x10            ; <- Correcto ya que ocupa la direccion 0x7FF
        MOVLW   0x15            ; <- Problema no hay mas lugar, no existe 0x800

El cual el error deberia ser:

Código: ASM

Error - section '.test' can not fit the absolute section. Section '.test' start=0x000007FF, length=0x00000002

Podes probar si gustas :P, no estoy muy seguro que ocurra asi, pero no le voy a errar tanto.

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 25 de Abril de 2016, 03:01:36

Gracias nuevamente KillerJC por esa explicacion. Efectivamente di con el error que era la memoria, migre el codigo para esa aplicacion a un 18F13K22. Sin problemas, bueno para darle seguimiento a lo de la MicroSD me puse a buscar informacion y hay bastante. En particular os dejo este link para que lo revisen:

https://prezi.com/pudfdp-ploth/micro-sd-bajo-comunicacion-spi/
http://elm-chan.org/docs/mmc/mmc_e.html

Me parecio muy intuitivo. Respecto a la informacion presentada en este link comprendo lo siguiente:

- La velocidad Máxima de transmisión es de 400khz antes de la incialización, despues puede ser mayor?
- Se envian comandos de 6 Bytes y se reciben de 1 u 2 bytes.
- Seguido del bloque de datos que deseamos leer/escribir respectivamente.

Despues seguimos con la rutina de incializcion:
- Delay para estabilizacion de alimentacion
- Configurar SPI en baja velocidad
- Mandar 74 pulsos de reloj
- Mandar Comando 00 que pone la tarjeta en SPI y recibe como respuesta tipo R1 con el IDLE STATE. (Se requiere un CRC 00x95) Esto ultimo no me quedo tan claro.
- Si funciono el Comando 00 mandamos ahora el comando 08 con argumento 0x1AA y CRC 0x87
- Si no fue aceptado el comando 08 mandamos ahora el comando 37 seguido del comando 29 no se precisan argumentos pero se recomienda manda 4 bytes en 0 despues de los comandos?
- Si lo acepto mandamos de nuevo el comando 01 con argumento 0 y CRC cualquiera
- Despues de esto se puede utilizar el comando BLOCKLEN para especificar el tamaño del bloque. Pero para escritura siempre son 512 Bytes y para lectura puede ser desde 1
- Por ultimo se puede utilizar una velocidad mas alta.

Bueno pues parece algo sencillo aunque me quedan un par de preguntas, los CRC son bytes especificos que se tienen que mandar con los comandos?

Bueno y dado que hay que mandar muchos bytes u leer que metodo de escritura lectura me recomiendan?

Saludos

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 25 de Abril de 2016, 09:14:40

Citar

- Se envian comandos de 6 Bytes y se reciben de 1 u 2 bytes.

Supuestamente la mayoria de las respuestas son R1, 8 bits y que con que lleguen con 0x00 significa correcto, las R1b poseen un bit extra que es un flag de busy, las R3/R7 ya son 5 bytes, en la cual es una R1 + 4 bytes. Lo que no dice nada es de R2, pero no lo veo como respuesta a ningun comando.

Supuestamente el CRC del comando que vos envias, no es verificado. Asi que no te molestarias en ponerlo. ESTO EN SPI!

Citar

- Mandar Comando 00 que pone la tarjeta en SPI y recibe como respuesta tipo R1 con el IDLE STATE. (Se requiere un CRC 00x95) Esto ultimo no me quedo tan claro.

Ahi lo explica, como todavia NO esta en modo SPI (sino en el nativo de SD ), el CRC debe ser correcto. Entonces el comando que tenes que enviar que es : 01 + Index + Argumento + CRC

Deberia ser

Index: 0x00
Argumento: 0x00000000
CRC = 0x95

De ahi deberias obtener una respuesta, y deberias obtener un 0x01, diciendo que la tarjeta esta en Idle Mode.
No se por que existe que el comando CMD08 sea enviado tambien con CRC, pero no es necesario que lo calcules, simplemente tener el CRC ya precalculado para esos 2 casos, incluso podes ver los archivos .c para guiarte un poco.

Citar

Bueno pues parece algo sencillo aunque me quedan un par de preguntas, los CRC son bytes especificos que se tienen que mandar con los comandos?

Creo que lo respondi arriba, pero solo se necesitan 2 CRC con los valores precalculados, asi que no tenes que crear ninguna rutina para calcular eso.
Y si se envian con los comandos, fijate los bits a enviar en lso comandos

Citar

Bueno y dado que hay que mandar muchos bytes u leer que metodo de escritura lectura me recomiendan?

Depende de tamaño de buffer que poseas, si tenes 2 buffer de 128 en el cual 1 se va llenando y el otro se transmite a la SD, entonces que sean paquetes de 128bytes. O tal ves tenes 2 buffer de lectura de 128bytes tambien y vas llenando uno mientras el otro lees, depende exclusivamente de tu uso.

Y tenes en cuenta que solo estas escribiendo la SD en RAW, no vas a poder abrirlo con la PC y encontrar un archivo, ya que no estas usando ningun formato ( FAT es el mas comun )

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: Pinolillo16 en 25 de Abril de 2016, 23:44:21

Entendido, entonces CRC sólo cuando es nativo, a simple vista no parece sencillo. Pero bien el objetivo si es implementar un FAT para poder abrirlos en la PC. Que debo investigar para poder lograrlo? Es decir cual es el más común que existe y que con este micro pueda implementar?

Gracias

Título: Re:PIC16F1707 Ejemplos básicos
Publicado por: KILLERJC en 26 de Abril de 2016, 06:58:00

Para FAT, esta pequeñes:

https://en.wikipedia.org/wiki/File_Allocation_Table
https://en.wikipedia.org/wiki/Design_of_the_FAT_file_system
https://staff.washington.edu/dittrich/misc/fatgen103.pdf

:P

Lo mejor es que una ves visto eso puedas comprenderlo usando un visor hexadecimal de la SD para comprobar los campos. Y ver que ocurre exactamente como dice.
Pero como comienzo haria lo del SPI con la SD, es decir grabar los datos en RAW sin ningun formato, luego si probaria implementar el FAT.

TODOPIC

Microcontroladores PIC => Almacén del Assembler => Mensaje iniciado por: Pinolillo16 en 29 de Octubre de 2015, 17:51:23