Facebook Twitter RSS Reset

Codigo Atmega 328 para blocker ya no funciona

Aclaraciones este code es para un atmega 328

este code reactivava el ird tomando todas las lens de carga que encontrara al momento de ahcer una carga

tomaba un maximo de 7 lens con respuesta 90 A1

y las almacenaba para tal motivo es nesesario sacar el jumper en la carga y ponerlo una vez que el led esta titileando que avisa que ya esta listo para colocar el jumper

Pero Aclaro esto ya no sirve ya que los tiers de DTV tiene fecha de duracion con relacion a la carga este code es para quien me pidio si podia postear un code viejo

y la intecion de postear este code es solo para estudio de como trabajaban los codes de las plaquetas que se usaban en su momento el uso de este code con otro fin que no sea educativo corre bajo la responsabilidad de quien lo use

.device atmega328p

.include “m328pdef.inc”

.def Registro_Temporal =r16

.def ENVIAR_LENS_X_68=r19

.def cargar_timer = r25

.def LENS = r17

.def INS = r17

.def CLASS = r17

/************************************************************/

;ATMEGA328

/****************************************/

.equ direccion = ddrd

.equ puerto = PORTd

.equ pin = pind

.equ jumper = pind

.equ i_o_card = 4

.equ block_card = 3

.equ i_o_ird = 0

.equ IRD = 1

.equ PinJumper = 5

.equ PinLed = 7

/************************************************************************************************/

.equ Card_contesto_A1 =$A1

.equ Card_contesto_A0 =$A0 ;Cambiar por A0 Para que compares lens con terminacion 90 A0 Solo para control

/*************************************************************************************************/

; ;NO MODIFICAR ESTA PARTE DEL CODE

/*************************************************************************************************/

.equ Enviar = $55;

.equ No_Enviar =$01

/**************************************************************************************************/

ldi r22,$00

ldi r21,$00

ldi r20,$00

ldi r19,$00

;dividir la ram en 8 cuperpos

.equ Espacio_de_blockes = $7d

.EQU INTEGER = $02

.DSEG

.org $100

blocke1: .BYTE Espacio_de_blockes

blocke2: .BYTE Espacio_de_blockes

blocke3: .BYTE Espacio_de_blockes

blocke4: .BYTE Espacio_de_blockes

blocke5: .BYTE Espacio_de_blockes

blocke6: .BYTE Espacio_de_blockes

blocke7: .BYTE Espacio_de_blockes

.CSEG

RJMP inicio

Inicio: BCLR 7

LDI R17,$DF

OUT SPL,R17

CBI direccion,i_o_ird

CBI direccion,i_o_card

CBI direccion,block_card

sbi ddrc,6

LDI R17,$00

LDI YH,$00

LDI YL,$60

CLEAR_RAM:

ST Y+,R17

CPI YL,$E0

BRCS CLEAR_RAM

CPI YH,$00

BRCS CLEAR_RAM

/************************************************************

RAM

*************************************************************/

ldi r17,$00

ldi r18,$02

LDI R16,$00

limpiar_ram:

LDI R26,LOW(blocke1)

LDI R27,HIGH(blocke1)

RCALL LIMPIEZA

LDI R26,LOW(blocke2)

LDI R27,HIGH(blocke2)

RCALL LIMPIEZA

LDI R26,LOW(blocke3)

LDI R27,HIGH(blocke3)

RCALL LIMPIEZA

LDI R26,LOW(blocke4)

LDI R27,HIGH(blocke4)

RCALL LIMPIEZA

LDI R26,LOW(blocke5)

LDI R27,HIGH(blocke5)

RCALL LIMPIEZA

LDI R26,LOW(blocke6)

LDI R27,HIGH(blocke6)

RCALL LIMPIEZA

LDI R26,LOW(blocke7)

LDI R27,HIGH(blocke7)

RCALL LIMPIEZA

/************************************************************

*************************************************************/

;inicio2:

arranca:

SBIC JUMPER,PinJumper ;si jumper no eta puesto salta el envio si esta puesto sigue a con

rjmp con

RJMP READCLASS

con:

LDI ZL,$03

LDI ZH,$FF

RCALL EEPROM_read ;leo cantidad de lens a mandar

CPI R16,$05 ;si menor a 8 continuo mandando si no es FF y salgo del envio

breq COMPROBAR

rjmp TERMINADO_EL_ENVIO

COMPROBAR:

Ldi ENVIAR_LENS_X_68,Enviar

rjmp readclass

TERMINADO_EL_ENVIO:

ldi ENVIAR_LENS_X_68,no_Enviar

rjmp readclass

/************************************************************

FUNCION PARA LIMPIAR RAM

************************************************************/

LIMPIEZA:

LIMP:

st X+,R17

DEC R18

BRNE LIMP

;ST X+,R16

;INC R16

ldi r18,$02

RET

;***************************************************************************

; Lee EEPROM

;***************************************************************************

EEPROM_read:

sbic EECR,EEPE

rjmp EEPROM_read

out EEARH, zL

out EEARL, zH

sbi EECR,EERE

in r16,EEDR

ret

;***************************************************************************

; Escribe EEPROM

;***************************************************************************

EEPROM_write:

sbic EECR,EEPE

rjmp EEPROM_write

out EEARH, zL

out EEARL, zH

out EEDR,r16

sbi EECR,EEMPE

sbi EECR,EEPE

ret

/************************************************************

Macros

*************************************************************/

.macro SBIsES

L6112: SBIs pin,i_o_ird

RJMP L6112

.endmacro

//////////////////////////////

.macro SBIcES

L612: SBIc pin,i_o_ird

RJMP L612

.endmacro

/////////////////////////////

.macro Ligar_card

CBI direccion,block_card

cBI puerto,block_card

.endmacro

/////////////////////////////

.macro Desligar_card

SBI direccion,block_card

SBI puerto,block_card

.endmacro

/////////////////////////////

.macro Leer_SW1_SW2

RCALL RxIRD_Start

RCALL RxIRD_Start

.endmacro

/////////////////////////////

/////////////////////////////

.macro LLAMAR_LENS

ldi xh,$08

LDI xL,$64

LD R17,x+

.endmacro

/////////////////////////////

/////////////////////////////

.macro LLAMAR_INS

ldi xh,$08

LDI xL,$61

LD R17,x+

.endmacro

/////////////////////////////

/////////////////////////////

.macro LLAMAR_CLASS

ldi xh,$08

LDI xL,$60

LD R17,x+

.endmacro

/////////////////////////////

;*******************************************

;ARRANCA EL CODE CON LA COMPARACION

; DE CLSASES

; LECTURA DE CLASES

;*******************************************

ReadClass:

ldi xL,$60

ldi xh,$08

LDI R18,$04

Byte_4x: RCALL RxIRD_Start

CPI Registro_Temporal,$48

BREQ Byte_4x2

CPI Registro_Temporal,$49

BREQ Byte_4x2

CPI Registro_Temporal,$4A

BREQ Byte_4x2

CPI Registro_Temporal,$4B

BRNE Byte_4x

Byte_4x2: ST x+,Registro_Temporal

;**************************************

;RECEPCION DE ENCAVEZADO ;48 42 00 00

;**************************************

Rcv_Header:

RCALL RxIRD_Start

ST x+,Registro_Temporal

DEC R18

BRNE Rcv_Header

LLAMAR_INS

RCALL RxIRD_Start ;LEE Y COMPARA LAS INS

CP R17,Registro_Temporal

BRNE ReadClass ;SI NO SON IGUALES REGRESA AL INICIO A BUSCAR UN COMIENZO DE CLASE

;***************************************

;***************************************

cpi INS,$40

BREQ ENVIO_REMOTO

CPI INS,$5C

BREQ INS_5C

cpi ins,$42

brne Descargas_no_42

rjmp esins42

Descargas_no_42: rjmp Descargas_no_ins42

INS_5C:

CPI R21,$05

BRNE NADA

RJMP RESET

NADA: RJMP Descargas_no_ins42

enviar_alta: rjmp enviar_alta_

; *********************************************************

; /// ENVIO DE CARGA REMOTO ///

;********************************************************

envio_remoto: ;comprueba si existe

cpi ENVIAR_LENS_X_68,Enviar ;la configuracion de enviar la lens de alta si existe salta a enviar la alta ya que esta se envia despues de la ins 40 ya que la proxima isn

breq enviar_alta ;despues de la ins 40 siempre es la ins 54 donde enviaremos la lens de alta en caso de que asi lo requiera el codigo

LLAMAR_LENS ;si no teniamos que enviar la Lens de alta comprobamos en que canal nos encontramos en este momento ya que la ins 40

;es la ins donde nos trae la informacion de el canal en que nos encontramos (ademas de canal nos informa la hora dia mes año dentro de otras informaciones que nos probee)

ldi Registro_Temporal,$0c ;Cargamos el registro temporal con $0C para hacer el bucle de lectura del canal sin tener en cuenta la lens si no donde se encuentra el canal

;es decir $0C bytes antes del final es decir antes del 90 20 (o sea SW1 y SW2) es donde nos encontramos con el canal, en el logueo podemos ver que

;siempre antes del canal tenemos en la ins 40 un byte que es el FF y despues de ese esta el canal compuesto por 2 bytes en el caso del canal 599

;estos 2 bytes son $02 y $57

SUB LENS,Registro_Temporal ;Aca lo que hace es restarle al largo de la lens el $0C para que al hacer el boocle nos posicione justo donde se encuentra el primer byte de canal

;aca hacemos un bucle leyendo los bytes que no nos interesan

VERIF: RCALL RxIRD_Start ;leemos un byte

DEC R17 ;decrecemos el LENS o R17 que es la misma cosa teniendo en cuenta que no es la lens si no la lens menos el $0C

BRNE VERIF ;si no llegamos a 0 regresamos al bucle

;____________________________________________ terminado el bucle leemos el siguiente byte que es el de el canal

RCALL RxIRD_Start ;decrecemos el R17 ya que leimos otro byte y estariamos apuntado a otro byte

dec r17

cpi Registro_Temporal, $02 ;comparamos con $02 para ver si es o no parte del canal 599

BRNE basuras ;si no es satalmos a descargar el resto de los bytes hata el SW1 y SW2 para regresar a leer el proximo header ya que no es una ins 40 que nos interese en este caso

;____________________________________________

RCALL RxIRD_Start ;si fue $02 el anterior leemos el proximo byte

dec r17

cpi Registro_Temporal, $57 ;comparamos si es $57 si es 57 quiere decir que estabamos en el canal 599 tener en cuenta que en hex 0257 es justamente en decimal 599

BRNE basuras ;si no fue 57 descargamos como en el caso anterior el resto del stream hasta el sw1 y sw2 y regresamos a la lectura de clases

;____________________________________________

LDI ENVIAR_LENS_X_68,Enviar ;si era el canal 599 lo que hacemos es preconfigurar el registro que nos dice si hay que enviar o no la lens de alta

LDI r16,$05

LDI ZL,$03

LDI ZH,$FF

RCALL EEPROM_write

ldi r16,$07

LDI ZL,$03

LDI ZH,$Fe

RCALL EEPROM_write

;avisando que la proxima vez que ecuentre una ins 40 este salte al envio de la Lens de alta

RJMP basuras ;y descargamos lo que queda del stream

basuras:

rjmp DESCARGAS_REMOTO

;#################################################################################################################################################################################################################################

enviar_alta_:

;**********************************************************———————————————***************************************

llamar_lens ;llamamos a la lens de la ins 40 para hacer el bucle de descarga completo de la ins 40

camba40e: ;y Hacemos el Bucle ;hasta el SW1 y SW2

rcall RxIRD_Start ;es decir hasta el 90 20

dec r17 ;por ende elproximo byte seria la class de la ins 54

brne camba40e ;cosa que vamos a modificar en la proxima rutina

rcall RxIRD_Start ;lee SW1

rcall RxIRD_Start ;lee SW2

;********************************************************

;leemos la cantidad de lens que faltan mandar

;estas se encuentran en la pos de memoria 3fe

;esto empieza en 7 y va descontando a medida que

;va mandando

;el valor lo mantinene en el Registro 20

;para al terminar de enviar decrecer el valor del mismo

;y cargarlo de nuevo en la pos de memoria 3fe

;********************************************************

ldi zl,$03

ldi zh,$Fe

rcall EEPROM_read

mov r20,r16

;********************************************************

ldi r16,$49 ;cargamos en el r16 que es donde se cargan los valores para el envio de byte para la Funcion con el valor 49 que seria la class de la ins 42

rcall ENVIO_BYTE ;enviamos ese byte a la card con la fucnion para hacerlo

rcall delaystream ;de damos el delay cosa que no es del toda nesesaria ya que las rutinas que uso para envio en este caso no requieren delay

ligar_card ;Esto creo que ta de mas pero por bagancia no lo saque ni lo probe sin esto pero ahora escrviviendo los comentarios creo que ta de mas pero no afecta en nada Codigo Atmega 328 para blocker ya no funcionaCodigo Atmega 328 para blocker ya no funciona

ldi r16,$42 ;cargamos de nuevo el r16 con el valor de la ins que queremos mandar es decir 42…. Tendriamos mandado 49 42 ….

rcall ENVIO_BYTE ;enviamos el 42

rcall delaystream

ldi r16,$00

rcall ENVIO_BYTE ;aca tendriamos 49 42 00

rcall delaystream

ldi r16,$00 ;aca tendriamos 49 42 00 00

rcall ENVIO_BYTE ;Tengamos en cuenta que lo que el IRD esta mandando no es esto el ird esta mandando a la card 4B 54 XX XX por lo que esperara al momento del ACK el ACK correspondiente ya explicare eso mas adelante

;rcall delaystream3

;*******************************************************

;leemos cuantas faltan mandar

;*******************************************************

enviar_:

CPI R20,$07

BREQ BLOCKER_1_MEM

CPI R20,$06

BREQ BLOCKER_2_MEM

CPI R20,$05

BREQ BLOCKER_3_MEM

CPI R20,$04

BREQ BLOCKER_4_MEM

CPI R20,$03

BREQ BLOCKER_5_MEM

CPI R20,$02

BREQ BLOCKER_6_MEM

CPI R20,$01

BREQ BLOCKER_7_MEM

;********************************

rjmp TERMINADO_EL_ENVIO

;*******************************

;*******************************

BLOCKER_1_MEM:

LDI ZL,$00

LDI ZH,$75

rjmp cargar_en_mem_io

BLOCKER_2_MEM:

LDI ZL,$00

LDI ZH,$EA

rjmp cargar_en_mem_io

BLOCKER_3_MEM:

LDI ZL,$01

LDI ZH,$5F

rjmp cargar_en_mem_io

BLOCKER_4_MEM:

LDI ZL,$01

LDI ZH,$D4

rjmp cargar_en_mem_io

BLOCKER_5_MEM:

LDI ZL,$02

LDI ZH,$49

rjmp cargar_en_mem_io

BLOCKER_6_MEM:

LDI ZL,$02

LDI ZH,$BE

rjmp cargar_en_mem_io

BLOCKER_7_MEM:

LDI ZL,$03

LDI ZH,$33

rjmp cargar_en_mem_io

/***********************************************/

////// ENVIO DE LEN GUARDADA A LA CARD /////

/***********************************************/

cargar_en_mem_io:

RCALL EEPROM_read

;________________________________________________________________

;Cambiamos las lens FF por A para no mandar una lens Tan larga

;esto en caso de que se hayan almacenado menos de 7 lens

;________________________________________________________________

cpi r16,$FF

brne no_tocar

ldi r16,$0A

ldi r20,$01

;_____________________________________________

no_tocar:

mov r21,r16 ;cargo la lens en el contador

;dec r21

rcall ENVIO_BYTE

INC ZH

/*******************************************************/

//// BLOQUEAMOS LA INS 42 PARA QUE NO PASE AL IRD ////

/*******************************************************/

SBI direccion,IRD

SBI puerto,IRD

RCALL rxsws

CBI direccion,IRD

CBI puerto,IRD

/***********************************************/

////// ENVIO DE INS 54 AL IRD ////////

/***********************************************/

SBI direccion,i_o_card

SBI puerto,i_o_card

LDI R16,$54

RCALL TxIRD_Start

CBI direccion,i_o_card

CBI puerto,i_o_card

/**************************************************/

;lectura de el resto del stream y mandado del mismo

;**************************************************

guardando_la_lens_en_ram_: ;Ligar_card

RCALL EEPROM_read

SBI direccion,block_card

SBI puerto,block_card

rcall TXCARD

rcall delaystream3

CBI direccion,block_card

CBI puerto,block_card

CPI ZH,$FF

BRNE seguir2

RJMP comprobar_prim2

seguir2:

INC ZH

DEC r21

BRNE guardando_la_lens_en_ram_

RJMP ofut_rango

comprobar_prim2:

DEC r21

BREQ ofut_rango

CPI ZL,$04

BREQ ofut_rango

LDI ZH,$00

INC ZL

RJMP guardando_la_lens_en_ram_

;************************************************

ofut_rango:

ldi r21,$05

;leer_Sw1_sw2

;***************************************************

;decrecemos el valor de r20 y lo almacenamos en 3fe

;***************************************************

DEC R20

cpi r20,$00

breq termianr_todo

mov r16,r20

ldi zl,$03

ldi zh,$FE

rcall EEPROM_write

rjmp readclass

termianr_todo:

ldi r16,$00

ldi zl,$03

ldi zh,$FF

rcall EEPROM_write

rjmp TERMINADO_EL_ENVIO

;___________________________________________________

rjmp readclass

;############################################################################################################################################################################################

;*********************************************************

; /// rutina para resetear cambiando la respuesta ///

;********************************************************

;esta rutina lo que hace es tomar el valor de la lens hacer un bucle hasta llegar a el SW1 y SW2

;al llegar al SW1 y SW2 lo que hace es cambiar la respuesta por AA A1 y de esta fomra el stream forza

;a que la proxima ins que llegue sea la 5C y es donde aremos el reset

Reset:

llamar_lens ;traemos la lens al registro r17

cambiandoreset:

rcall RxIRD_Start ;leemos el proximo byte

dec r17 ;decrecemos el r17

brne cambiandoreset ;si no es igual regresamos a el bucle

;Terminado el bucle hacemos el cambio de SW1 y SW2

cambios_resp:

SBIsES

SBIcES

desligar_card

LDI Registro_Temporal,$aa

RCALL TxIRD_Start

rcall delaystream

LDI Registro_Temporal,$a0

RCALL TxIRD_Start

ligar_card

ldi r21,$05

rjmp readclass

;###############################################################################################################################################################################################

;***************************************

;Almacenar Alta

;***************************************

no_almacenar_lens:rjmp DESCARGAS_REMOTO

;_________________________________________________________

Almacenar_Alta:

llamar_lens

cpi lens,$19

breq no_almacenar_lens

;cargo la lens en el r17

mov Registro_Temporal,LENS ;le cargo a el registro r16, el valor de la lens

;LDI xL,$64

;LDI xh,$08

; LD R16,x

LDI R26,LOW(BLOCKE1)

LDI R27,HIGH(BLOCKE1)

ldi r18,$01

LD R17,X

cpi r17,$00

breq usar_esste

LDI R26,LOW(BLOCKE2)

LDI R27,HIGH(BLOCKE2)

ldi r18,$02

LD R17,X

cpi r17,$00

breq usar_esste

LDI R26,LOW(BLOCKE3)

LDI R27,HIGH(BLOCKE3)

ldi r18,$03

LD R17,X

cpi r17,$00

breq usar_esste

LDI R26,LOW(BLOCKE4)

LDI R27,HIGH(BLOCKE4)

ldi r18,$04

LD R17,X

cpi r17,$00

breq usar_esste

LDI R26,LOW(BLOCKE5)

LDI R27,HIGH(BLOCKE5)

ldi r18,$05

LD R17,X

cpi r17,$00

breq usar_esste

LDI R26,LOW(BLOCKE6)

LDI R27,HIGH(BLOCKE6)

ldi r18,$06

LD R17,X

cpi r17,$00

breq usar_esste

LDI R26,LOW(BLOCKE7)

LDI R27,HIGH(BLOCKE7)

ldi r18,$07

LD R17,X

cpi r17,$00

breq usar_esste

;************************************************************************************************************************************************

RJMP TERMINAR_GUARDADO_FORZADAMENTE ;SE LLEGARON AL MAXIMO DE LESN QUE SE QUIREN ALMACENAR

;************************************************************************************************;************************************************

usar_esste:

ST X+,Registro_Temporal

mov r17,r16 ;CARGAMOS EN EL R17 EL VALOR DE LA LENS PARA HACER EL BUCLE DE REPTECION PARA ALMACENAR EL RESTO DEL STREAM

repeticion_por_largo_lens: ;EJEMPLO 52

rcall RxIRD_Start ;

ST X+,Registro_Temporal

dec r17

brne repeticion_por_largo_lens ;TERMINADO ESTE CILO TENESMO EN MEMORIA LENS Y LOS 52 BYTES QUE FALTAN

Leer_SW1_SW2

cpi Registro_Temporal,Card_contesto_A1

breq almacenar_lens

;cpi Registro_Temporal,Card_contesto_A0

;breq almacenar_lens

;************************************************************************************************************************************************

;BORRADO DE BLOCK DE MEMORIA YA QUE NO ES A1

;************************************************************************************************************************************************

rjmp SACANDODEMEM

;****************************************************

;SE DEJA LA RAM CARGADA CON LA LENS CON RESPUESTA A1

;****************************************************

almacenar_lens:

rjmp Readclass

SACANDODEMEM:

cpi r18,$01

breq limpieza_primer_bloker1

cpi r18,$02

breq limpieza_primer_bloker2

cpi r18,$03

breq limpieza_primer_bloker3

cpi r18,$04

breq limpieza_primer_bloker4

cpi r18,$05

breq limpieza_primer_bloker5

cpi r18,$06

breq limpieza_primer_bloker6

cpi r18,$07

breq limpieza_primer_bloker7

rjmp listo

limpieza_primer_bloker1:

LDI R26,LOW(blocke1)

LDI R27,HIGH(blocke1)

ldi r18,$02

ldi r17,$00

rcall LIMPIEZA

rjmp listo

limpieza_primer_bloker2:

SBI puerto,PinLed

LDI R26,LOW(blocke2)

LDI R27,HIGH(blocke2)

ldi r18,$02

ldi r17,$00

rcall LIMPIEZA

rjmp listo

limpieza_primer_bloker3:

LDI R26,LOW(blocke3)

LDI R27,HIGH(blocke3)

ldi r18,$02

ldi r17,$00

rcall LIMPIEZA

rjmp listo

limpieza_primer_bloker4:

LDI R26,LOW(blocke4)

LDI R27,HIGH(blocke4)

ldi r18,$02

ldi r17,$00

rcall LIMPIEZA

rjmp listo

limpieza_primer_bloker5:

LDI R26,LOW(blocke5)

LDI R27,HIGH(blocke5)

ldi r18,$02

ldi r17,$00

rcall LIMPIEZA

rjmp listo

limpieza_primer_bloker6:

LDI R26,LOW(blocke6)

LDI R27,HIGH(blocke6)

ldi r18,$02

ldi r17,$00

rcall LIMPIEZA

rjmp listo

limpieza_primer_bloker7:

LDI R26,LOW(blocke7)

LDI R27,HIGH(blocke7)

ldi r18,$02

ldi r17,$00

rcall LIMPIEZA

rjmp listo

listo:

rjmp Readclass

;****************************************************

;final de almacenamiento por desbordamiento

;****************************************************

TERMINAR_GUARDADO_FORZADAMENTE:

ldi r22,$05

rjmp Descargas_no_ins42

;################################################################################################################################################################################################

;***************************************

;Descarga fuera de INS 42

;***************************************

Descargas_no_ins42:

LLAMAR_LENS

;—————————————

DESCARGAS_REMOTO:

cpi LENS,$00

breq l99c

L99:

RCALL RxIRD_Start

DEC LENS

BRNE L99

l99c:

Leer_SW1_SW2

RJMP ReadClass

;***************************************

;Selecion de lens Automatica

;DE LENS A BLOQUEAR

;UN MAXIMO DE 10 LENS SE GUARDARAN

;***************************************

Almacenar:

LDI R22,$00

rjmp Almacenar_Alta

;################################################################################################################################################################################################

;*******************************************

;COMPARACION PARA SELECIONAR LENS DE ALTAS

;*******************************************

esins42:

cpi r22,$05

breq COMPOBAR_SI_HAY_ALGO_PARA_GRABAR_EN_EEPROM

PROBANDOTODO_:

sbis jumper, PinJumper

rjmp Almacenar ; almacena alta el jumper tiene que estar desconectado

LDI R22,$00

COMPOBAR_SI_HAY_ALGO_PARA_GRABAR_EN_EEPROM:

sbis jumper, PinJumper

rjmp OMITIR

LDI R22,$00

OMITIR:

;ACA tendriamos que borrar las posiciones de memoria principales de la eeprom

;para que no quee nada anterior y se comfunda con lens viejas

;################################################################################################################################################################################################

COMPROBACIONES:

;—————————————–

LDI R26,LOW(BLOCKE1)

LDI R27,HIGH(BLOCKE1)

ldi r17,$01

LD R18,X

cpi r18,$00

BRNE EEPROM1

;—————————————–

LDI R26,LOW(BLOCKE2)

LDI R27,HIGH(BLOCKE2)

ldi r17,$02

LD R18,X

cpi r18,$00

BRNE EEPROM2

;—————————————–

LDI R26,LOW(BLOCKE3)

LDI R27,HIGH(BLOCKE3)

ldi r17,$03

LD R18,X

cpi r18,$00

BRNE EEPROM3

;—————————————–

LDI R26,LOW(BLOCKE4)

LDI R27,HIGH(BLOCKE4)

ldi r17,$04

LD R18,X

cpi r18,$00

BRNE EEPROM4

;—————————————–

LDI R26,LOW(BLOCKE5)

LDI R27,HIGH(BLOCKE5)

ldi r17,$05

LD R18,X

cpi r18,$00

BRNE EEPROM5

;—————————————–

LDI R26,LOW(BLOCKE6)

LDI R27,HIGH(BLOCKE6)

ldi r17,$06

LD R18,X

cpi r18,$00

BRNE EEPROM6

;—————————————–

LDI R26,LOW(BLOCKE7)

LDI R27,HIGH(BLOCKE7)

ldi r17,$07

LD R18,X

cpi r18,$00

BRNE EEPROM7

;—————————————–

;—————————————–

CPI R22,$05

BREQ TERMINOAUTOMATICO

CBI puerto,PinLed

rjmp descargas

TERMINOAUTOMATICO:

MOV R22,R19

rcall prendiendoapagando

MOV R19,R22

LDI R22,$05

rjmp READCLASS

;*********************************************************************

;ACA GUARDA LAS POS DE MEMORIA DONDE SE ENCUENTRAN LAS LENS

;DE LAS QUE SE GUARDARON EN LA LECTURA

;*********************************************************************

EEPROM1:

ldi r16,$FF

LDI ZL,$00

LDI ZH,$EA

rcall EEPROM_write

LDI ZL,$01

LDI ZH,$5F

rcall EEPROM_write

LDI ZL,$01

LDI ZH,$D4

rcall EEPROM_write

LDI ZL,$02

LDI ZH,$49

rcall EEPROM_write

LDI ZL,$02

LDI ZH,$BE

rcall EEPROM_write

LDI ZL,$03

LDI ZH,$33

rcall EEPROM_write

rcall prendiendoapagando

LDI ENVIAR_LENS_X_68,no_Enviar

RJMP GUARDAR_EEPROM1

EEPROM2:

RJMP GUARDAR_EEPROM2

EEPROM3:

RJMP GUARDAR_EEPROM3

EEPROM4:

RJMP GUARDAR_EEPROM4

EEPROM5:

RJMP GUARDAR_EEPROM5

EEPROM6:

RJMP GUARDAR_EEPROM6

EEPROM7:

RJMP GUARDAR_EEPROM7

GUARDAR_EEPROM1:

LDI ZL,$00

LDI ZH,$75

RJMP GUARDAR_EEPROM

GUARDAR_EEPROM2:

LDI ZL,$00

LDI ZH,$EA

RJMP GUARDAR_EEPROM

GUARDAR_EEPROM3:

LDI ZL,$01

LDI ZH,$5F

RJMP GUARDAR_EEPROM

GUARDAR_EEPROM4:

LDI ZL,$01

LDI ZH,$D4

RJMP GUARDAR_EEPROM

GUARDAR_EEPROM5:

LDI ZL,$02

LDI ZH,$49

RJMP GUARDAR_EEPROM

GUARDAR_EEPROM6:

LDI ZL,$02

LDI ZH,$BE

RJMP GUARDAR_EEPROM

GUARDAR_EEPROM7:

LDI ZL,$03

LDI ZH,$33

RJMP GUARDAR_EEPROM

GUARDAR_EEPROM:

inc r18

guardando:

LD R16,X+

rcall EEPROM_write

;ST x+,R17

cpi ZH,$FF

brne seguir

rjmp comprobar_prim

seguir:

inc ZH

dec r18

Breq TERMINADO

rjmp guardando

comprobar_prim:

dec r18

breq TERMINADO

cpi ZL,$04

breq TERMINADO

ldi ZH,$00

inc ZL

rjmp guardando

rjmp readclass

TERMINADO:

CPI R17,$01

BREQ LIMPIA1

CPI R17,$02

BREQ LIMPIA2

CPI R17,$03

BREQ LIMPIA3

CPI R17,$04

BREQ LIMPIA4

CPI R17,$05

BREQ LIMPIA5

CPI R17,$06

BREQ LIMPIA6

CPI R17,$07

BREQ LIMPIA7

rjmp COMPROBACIONES

LIMPIA1:

LDI R26,LOW(blocke1)

LDI R27,HIGH(blocke1)

LDI R16,$00

ST X,R16

rjmp COMPROBACIONES

LIMPIA2:

LDI R26,LOW(blocke2)

LDI R27,HIGH(blocke2)

LDI R16,$00

ST X,R16

rjmp COMPROBACIONES

LIMPIA3:

LDI R26,LOW(blocke3)

LDI R27,HIGH(blocke3)

LDI R16,$00

ST X,R16

rjmp COMPROBACIONES

LIMPIA4:

LDI R26,LOW(blocke4)

LDI R27,HIGH(blocke4)

LDI R16,$00

ST X,R16

rjmp COMPROBACIONES

LIMPIA5:

LDI R26,LOW(blocke5)

LDI R27,HIGH(blocke5)

LDI R16,$00

ST X,R16

rjmp COMPROBACIONES

LIMPIA6:

LDI R26,LOW(blocke6)

LDI R27,HIGH(blocke6)

LDI R16,$00

ST X,R16

rjmp COMPROBACIONES

LIMPIA7:

LDI R26,LOW(blocke7)

LDI R27,HIGH(blocke7)

LDI R16,$00

ST X,R16

rjmp COMPROBACIONES

;###################################################################################################################################################################################################

;***************************************

;Descarga dentro de INS 42

;ESTA RUTINA ADEMAS DE DESCARGAR

;COMPRUEBA LA RESPUESTA DE LA CARD

;PARA DETERMINAR SI ES LENS DE BAJA O NO

;***************************************

Descargas: LLAMAR_LENS

cpi lens,$1E

breq sacar_cartel

restado:

L9: RCALL RxIRD_Start

DEC LENS

BRNE L9

Leer_SW1_SW2

cpi Registro_Temporal,Card_contesto_A1 ;COMPARA SI RESPUESTA ES A1

breq Resp_A1 ;SI ES A1 SALTA A GUARDAR LA LENS EN LA EEPROM

RJMP ReadClass

;*****************************************************

;DETECION DE BAJAS

;ACA REALIZA TODO EL PROCESO PARA DETERMINAR

;Y GUARDAR LA LENS DE BAJA

;*****************************************************

Resp_A1:

ldi ENVIAR_LENS_X_68,Enviar

LDI r16,$05

LDI ZL,$03

LDI ZH,$FF

RCALL EEPROM_write

ldi r16,$07

LDI ZL,$03

LDI ZH,$Fe

RCALL EEPROM_write

;_____________________________________________________

RJMP ReadClass

sacar_cartel:

camba1e:

rcall RxIRD_Start

dec r17

brne camba1e

rcall RxIRD_Start

SBI direccion,ird

SBI puerto,ird

RCALL rxsws

CBI direccion,ird

cBI puerto,ird

cpi r16,$20

brne matar

SBI direccion,i_o_card

SBI puerto,i_o_card

RCALL TxIRD_Start

CBI direccion,i_o_card

cBI puerto,i_o_card

RJMP ReadClass

matar:

ldi r21,$05

ldi r16,$20

SBI direccion,i_o_card

SBI puerto,i_o_card

RCALL TxIRD_Start

CBI direccion,i_o_card

cBI puerto,i_o_card

RJMP ReadClass

;##############################################################################################################################################################################################################

;***************************************

;RUTINA PARA LECTURA DE BYTES

;***************************************

RxSWS:

SBIS pin,block_card

RJMP RxSWS

Lsbi: SBIC pin,block_card

RJMP Lsbi

LDI R25,$04

RCALL timer

LDI R16,$01

rolSW: LDI R25,$1A

RCALL timer

NOP

NOP

BCLR 0

SBIS pin,block_card

BSET 0

ROL R16

BRCC rolSW

LDI R25,$59

RCALL timer

NOP

endsws: SBIS pin,block_card

RJMP endsws

RET

;***************************************

;RUTINA PARA ENVIO Sincronizado DE BYTES

;***************************************

ENVIO_BYTE:

SBI puerto,block_card

SBI direccion,block_card

SBIsES

;DESLIGAR_CARD

SBIcES

RCALL TXCARD

SBIsES

;LIGAR_CARD

RET

;***************************************

;RUTINA PARA LECTURA DE BYTES

;***************************************

RxIRD_Start:

SBIS pin,i_o_ird

RJMP RxIRD_Start

L14:SBIcES

LDI cargar_timer,$0F

L15: DEC cargar_timer

BRNE L15

NOP

LDI Registro_Temporal,$01

LDI cargar_timer,$1F

L16: DEC cargar_timer

BRNE L16

IN R24,pin

LSR R24

ROL Registro_Temporal

LDI cargar_timer,$1E

BRCC L16

COM Registro_Temporal

NOP

LDI cargar_timer,$2E

L17: DEC cargar_timer

BRNE L17

L18: SBIS pin,i_o_ird

RJMP L18

RET

;**************************************************************

;RUTINA PARA EL ENVIO DE BYTES AL IRD

;**************************************************************

TxIRD_Start:

SBIS PIND,0

RJMP TxIRD_Start

SBI DDRD,0

CBI PORTD,0

LDI R18,$08

CLR R24

LDI R25,$14

L33: RCALL Timer

NOP

ROL R16

BRCS L31

NOP

SBI PORTD,0

RJMP L32

L32: ADC R24,R25

ANDI R24,$01

DEC R18

LDI R25,$18

NOP

BRNE L33

RCALL Timer

RJMP L34

L34: ROR R24

BRCS L35

NOP

SBI PORTD,0

RJMP L36

L36: LDI R25,$1B

RCALL Timer

NOP

SBI PORTD,0

LDI R25,$25

RCALL Timer

NOP

RJMP L37

L37: CBI DDRD,0

CBI PORTD,0

RET

L35: CBI PORTD,0

RJMP L36

L31: CBI PORTD,0

RJMP L32

;***************************************

;RUTINA PARA EL ENVIO DE BYTES A LA CARD

;***************************************

TXcard:

L46:

LDI cargar_timer,$04

RCALL Timer

RJMP L47

L47:

CBI puerto,block_card

RJMP L48

L48:

RJMP L49

L49:

NOP

LDI R18,$08

CLR R24

L52:

LDI cargar_timer,$18

RCALL Timer

NOP

ROL Registro_Temporal

BRCS L50

NOP

SBI puerto,block_card

RJMP L51

L51:

ADC R24,cargar_timer

ANDI R24,$01

DEC R18

BRNE L52

LDI cargar_timer,$18

RCALL Timer

RJMP L53

L53:

ROR R24

BRCS L54

NOP

SBI puerto,block_card

RJMP L55

L55:

LDI cargar_timer,$32

RCALL Timer

NOP

RJMP L56

L56:

SBI puerto,block_card

CBI direccion,block_card

RET

L54:

CBI puerto,block_card

RJMP L55

L50:

CBI puerto,block_card

RJMP L51

;********************************************************

;********************************************************

DelayStream:

LDI cargar_timer,$3b

Timer:

DEC cargar_timer

BRNE Timer

RET

;********************************************************

;Delay mas corto para el envio de la alta por la ins 54

;********************************************************

DelayStream2:

LDI cargar_timer,$20

Timer2:

DEC cargar_timer

BRNE Timer2

RET

;********************************************************

;********************************************************

DelayStream3:

LDI cargar_timer,$14

Timer3:

DEC cargar_timer

BRNE Timer3

RET

;****************************************

prendiendoapagando:

ldi r19,$10

rjmp buclesprend

buclesprend:

SBI puerto,PinLed

rcall delay4

CBI puerto,PinLed

rcall delay4

dec r19

brne buclesprend

sBI puerto,PinLed

ldi r21,$00

ldi r16,$00

ldi r20,$00

RET

;***************************************

delay4:

ldi R16, $12

WGLOOP0: ldi R20, $BC

WGLOOP1: ldi R21, $C4

WGLOOP2: dec R21

brne WGLOOP2

dec R20

brne WGLOOP1

dec R16

brne WGLOOP0

ldi R16, $01

WGLOOP3: dec R16

brne WGLOOP3

nop

RET

;***************************************

FIN: RJMP FIN

.exit

No comments yet.

Leave a Comment