desktop

Curso de programación de PIC en PICBasic Pro

Exacto, si no se ponen los fuses, PBP opta por configurar esos registros con unos valores por defecto.
Ahora tenemos todo un tema aquí, ya que si compilas con PBP o MPASM desde microcode studio, no se configuran los fuses de la misma manera, ya que te marca error.


Cuando compilaba el código que estaba realizando en pbp y como no estaba colocando los fuses correspondiente del pic que estaba usando, el pbp lo tomaba por defecto y asignaba el cristal de 4 MHz, cuando grababa el pic usando el mikroprog de mikroelectronic me daba cuenta que los fuses estaban por defecto y el watchdog estaba en on y tuve que leer manual de pbp para ver como se configuraba los fuses de cada pic y definir el oscilador a usar.
En mi caso no marcaba error con respecto a la configuración de fuses, me marcaba error por sintaxis de instrucción equivocadas
 
Última edición por un moderador:
Esto lo compartí hace algún tiempo atrás y quizás resuelva tu duda...
Te cito un ejemplo como punto de partida...

main:
if input0 = 1 then encendido (si la entrada 0 es igual a 1, ir al sub programa…)
if input0 = 0 then apagado (si la entrada 0 es igual a 0, ir al sub programa ….)
goto main (volver a la 1er línea del programa, osea, main)

encendido: (sub programa encendido)
high 7 (activar salida 7)
wait 1 (esperar 1 segundo)
goto main (volver a la etiqueta “main”)

apagado: (sub programa “apagado”)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
wait 1 (esperar 1 segundo)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
goto main (volver a la etiqueta “main”)

Como verán, en la rutina anterior, lo único que hice, fue programar el microcontrolador con un dialogo sencillo, en ingles, pero muy deducible para aquellos que estén flojos con este idioma…
Prácticamente, lo único que le ordene al microcontrolador, es que monitoree la entrada numero cero (input cero), y en caso de tener algún estado definido (un alto o un bajo, osea, un 1 o un 0 lógico), este actúe dando como resultado una acción dada….
Internamente, estas líneas de programación, funcionan de la siguiente manera dentro del microcontrolador:

1_ Siempre, la rutina se lee y se ejecuta desde la 1er línea para abajo, salvo que halla un salto en el camino (ver imagen)

2_En este caso en particular, arranca el ciclo en la etiqueta “main”, pasa por la primera instrucción de que visualice y compare el estado de la entrada cero con el valor pre establecido y en caso de ser positivo el resultado saltar e ir al sub programa encendido…. (Ver imagen

Viendolo de otra manera...
En el caso de que la comparación de nula, el microcontrolador sigue líneas abajo leyendo las instrucciones.
Como verán, la siguiente instrucción, es similar, osea, compara el estado de la señal en la entrada cero, y si la comparación da positiva, salta al subprograma apagado; En caso de ser nula la comparación, sigue leyendo las siguientes líneas hasta llegar al fin del programa, o bien, hasta llegar a una bifurcación… En este caso, llega hasta la instrucción “goto”, lo cual, hace repetir el programa una y otra ves sin tener fin… En tu caso particular, al presionar el pulsador, corta la tarea u acción que hacía para atender la línea donde hace referencia de hacer algo si el pulsador está presionado; El tema está en como escribimos el programa, ya que puede quedar en ese punto sin hacer nada, cómo así también, puede que salte a una acción pero nuevamente se genere la misma acción por qué mantuvimos retenido el pulsador un tiempo largo y carecíamos de antirebotes....
Te recomiendo que arranques mirando "todos" los ejemplos de programación que tenés en este tópico para que vayas viendo y aprendiendo a programar en PBP. Saludos

PD: estoy escribiendo desde el teléfono y no puedo editarlo para insertar las imágenes y poner bien el código.perdon


main:
if input0 = 1 then encendido (si la entrada 0 es igual a 1, ir al sub programa…)
if input0 = 0 then apagado (si la entrada 0 es igual a 0, ir al sub programa ….)
goto main (volver a la 1er línea del programa, osea, main)

encendido: (sub programa encendido)
high 7 (activar salida 7)
wait 1 (esperar 1 segundo)
goto main (volver a la etiqueta “main”)

apagado: (sub programa “apagado”)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
wait 1 (esperar 1 segundo)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
goto main (volver a la etiqueta “main”)

Como verán, en la rutina anterior, lo único que hice, fue programar el microcontrolador con un dialogo sencillo, en ingles, pero muy deducible para aquellos que estén flojos con este idioma…

Prácticamente, lo único que le ordene al microcontrolador, es que monitoree la entrada numero cero (input cero), y en caso de tener algún estado definido (un alto o un bajo, osea, un 1 o un 0 lógico), este actúe dando como resultado una acción dada….
Internamente, estas líneas de programación, funcionan de la siguiente manera dentro del microcontrolador:

1_ Siempre, la rutina se lee y se ejecuta desde la 1er línea para abajo, salvo que halla un salto en el camino

En este caso en particular, arranca el ciclo en la etiqueta “main”, pasa por la primera instrucción de que visualice y compare el estado de la entrada cero con el valor pre establecido y en caso de ser positivo el resultado saltar e ir al sub programa encendido….

Viendolo de otra manera...
En el caso de que la comparación de nula, el microcontrolador sigue líneas abajo leyendo las instrucciones.
Como verán, la siguiente instrucción, es similar, osea, compara el estado de la señal en la entrada cero, y si la comparación da positiva, salta al subprograma apagado; En caso de ser nula la comparación, sigue leyendo las siguientes líneas hasta llegar al fin del programa, o bien, hasta llegar a una bifurcación… En este caso, llega hasta la instrucción “goto”, lo cual, hace repetir el programa una y otra ves sin tener fin…

Esto lo compartí hace algún tiempo atrás y quizás resuelva tu duda...
Te cito un ejemplo como punto de partida...

main:
if input0 = 1 then encendido (si la entrada 0 es igual a 1, ir al sub programa…)
if input0 = 0 then apagado (si la entrada 0 es igual a 0, ir al sub programa ….)
goto main (volver a la 1er línea del programa, osea, main)

encendido: (sub programa encendido)
high 7 (activar salida 7)
wait 1 (esperar 1 segundo)
goto main (volver a la etiqueta “main”)

apagado: (sub programa “apagado”)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
wait 1 (esperar 1 segundo)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
goto main (volver a la etiqueta “main”)

Como verán, en la rutina anterior, lo único que hice, fue programar el microcontrolador con un dialogo sencillo, en ingles, pero muy deducible para aquellos que estén flojos con este idioma…
Prácticamente, lo único que le ordene al microcontrolador, es que monitoree la entrada numero cero (input cero), y en caso de tener algún estado definido (un alto o un bajo, osea, un 1 o un 0 lógico), este actúe dando como resultado una acción dada….
Internamente, estas líneas de programación, funcionan de la siguiente manera dentro del microcontrolador:

1_ Siempre, la rutina se lee y se ejecuta desde la 1er línea para abajo, salvo que halla un salto en el camino (ver imagen)

2_En este caso en particular, arranca el ciclo en la etiqueta “main”, pasa por la primera instrucción de que visualice y compare el estado de la entrada cero con el valor pre establecido y en caso de ser positivo el resultado saltar e ir al sub programa encendido…. (Ver imagen

Viendolo de otra manera...
En el caso de que la comparación de nula, el microcontrolador sigue líneas abajo leyendo las instrucciones.
Como verán, la siguiente instrucción, es similar, osea, compara el estado de la señal en la entrada cero, y si la comparación da positiva, salta al subprograma apagado; En caso de ser nula la comparación, sigue leyendo las siguientes líneas hasta llegar al fin del programa, o bien, hasta llegar a una bifurcación… En este caso, llega hasta la instrucción “goto”, lo cual, hace repetir el programa una y otra ves sin tener fin… En tu caso particular, al presionar el pulsador, corta la tarea u acción que hacía para atender la línea donde hace referencia de hacer algo si el pulsador está presionado; El tema está en como escribimos el programa, ya que puede quedar en ese punto sin hacer nada, cómo así también, puede que salte a una acción pero nuevamente se genere la misma acción por qué mantuvimos retenido el pulsador un tiempo largo y carecíamos de antirebotes....
Te recomiendo que arranques mirando "todos" los ejemplos de programación que tenés en este tópico para que vayas viendo y aprendiendo a programar en PBP. Saludos

PD: estoy escribiendo desde el teléfono y no puedo editarlo para insertar las imágenes y poner bien el código.perdon


main:
if input0 = 1 then encendido (si la entrada 0 es igual a 1, ir al sub programa…)
if input0 = 0 then apagado (si la entrada 0 es igual a 0, ir al sub programa ….)
goto main (volver a la 1er línea del programa, osea, main)

encendido: (sub programa encendido)
high 7 (activar salida 7)
wait 1 (esperar 1 segundo)
goto main (volver a la etiqueta “main”)

apagado: (sub programa “apagado”)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
wait 1 (esperar 1 segundo)
high 6 (activar la salida 6)
wait 1 (esperar 1 segundo)
low 6 (desactivar la salida 6)
goto main (volver a la etiqueta “main”)

Como verán, en la rutina anterior, lo único que hice, fue programar el microcontrolador con un dialogo sencillo, en ingles, pero muy deducible para aquellos que estén flojos con este idioma…

Prácticamente, lo único que le ordene al microcontrolador, es que monitoree la entrada numero cero (input cero), y en caso de tener algún estado definido (un alto o un bajo, osea, un 1 o un 0 lógico), este actúe dando como resultado una acción dada….
Internamente, estas líneas de programación, funcionan de la siguiente manera dentro del microcontrolador:

1_ Siempre, la rutina se lee y se ejecuta desde la 1er línea para abajo, salvo que halla un salto en el camino

En este caso en particular, arranca el ciclo en la etiqueta “main”, pasa por la primera instrucción de que visualice y compare el estado de la entrada cero con el valor pre establecido y en caso de ser positivo el resultado saltar e ir al sub programa encendido….

Viendolo de otra manera...
En el caso de que la comparación de nula, el microcontrolador sigue líneas abajo leyendo las instrucciones.
Como verán, la siguiente instrucción, es similar, osea, compara el estado de la señal en la entrada cero, y si la comparación da positiva, salta al subprograma apagado; En caso de ser nula la comparación, sigue leyendo las siguientes líneas hasta llegar al fin del programa, o bien, hasta llegar a una bifurcación… En este caso, llega hasta la instrucción “goto”, lo cual, hace repetir el programa una y otra ves sin tener fin…
Torres.electrónico.
Gracias por tu amable y pronta respuesta.
Voy a probar el código que recomiendas, para de esa manera entender mejor lo que tú con gran paciencia explicas.
Valoro mucho tu ayuda.
Gran saludo!
 
Torres.electrónico.
Gracias por tu amable y pronta respuesta.
Voy a probar el código que recomiendas, para de esa manera entender mejor lo que tú con gran paciencia explicas.
Valoro mucho tu ayuda.
Gran saludo!
En realidad, es un ejemplo poco práctico. Te recomiendo que les y busques ejemplos sobre interrupción por hardware, Lee lo practico que es la función while para los antirebotes, etc etc. Saludos
 
Buenas noches.
Acabo de implementar el código que tan amablemente me sugirió torres.electrónico, pero al parecer no es lo que yo buscaba.
Al no subir esquema y programa, era difícil entender lo que yo estaba planteando.
Bien, ahora si subo el diagrama, el programa y además una nota explicativa en archivo de texto txt.
Espero su valiosa ayuda con este asunto.
Gracias nuevamente.
 

Adjuntos

  • Foros_Electr.rar
    21.4 KB · Visitas: 14
Acabo de implementar el código que tan amablemente me sugirió torres.electrónico, pero al parecer no es lo que yo buscaba.

Tu programa tiene un grave error (Quizás más, solo revise lo que dices). Cuando vas a la subrutina "AR" te quedas en un loop infinito que no saldrá jamas mientras que el fin de carrera este cerrado.

La idea de un antirrebote es para un pulsador en donde se espera que el usuario en algún momento lo suelte. Una vez llegado el ascensor y accionado el fin de carrera ¿ Como esperas que se suelte ?... Jamas pasara a menos que implementes una forma de que el ascensor se mueva nuevamente.

Ademas no necesitas antirrebote en un fin de carrera. Apenas lo detecta, tiene que activar alguna bandera para que un contador "congele" el ascensor por al menos 20 segundos (según lo que has escrito) y que mientras tanto vaya guardando las llamadas de los demás pisos para que, al terminar la temporización, siga camino.

Como bien te ha dicho @torres.electronico, lee sobre interrupciones y trabaja con banderas que te ahorraran mucho trabajo y dolor de cabezas.

¿ Ejemplo de código ? No programo en PBP pero tienes mas de 3000 post de los que leer y aprender.
 
Tu programa tiene un grave error (Quizás más, solo revise lo que dices). Cuando vas a la subrutina "AR" te quedas en un loop infinito que no saldrá jamas mientras que el fin de carrera este cerrado.

La idea de un antirrebote es para un pulsador en donde se espera que el usuario en algún momento lo suelte. Una vez llegado el ascensor y accionado el fin de carrera ¿ Como esperas que se suelte ?... Jamas pasara a menos que implementes una forma de que el ascensor se mueva nuevamente.

Ademas no necesitas antirrebote en un fin de carrera. Apenas lo detecta, tiene que activar alguna bandera para que un contador "congele" el ascensor por al menos 20 segundos (según lo que has escrito) y que mientras tanto vaya guardando las llamadas de los demás pisos para que, al terminar la temporización, siga camino.

Como bien te ha dicho @torres.electronico, lee sobre interrupciones y trabaja con banderas que te ahorraran mucho trabajo y dolor de cabezas.

¿ Ejemplo de código ? No programo en PBP pero tienes mas de 3000 post de los que leer y aprender.
Gracias por tu respuesta.
En el mundo real no es un fin de carrera, es un sensor óptico, pero por razones de simulación he usado un switch.
Este sensor atraviesa una lámina metálica de aproximadamente 10 Cm de largo .
Lo que yo busco es un código que incremente el contador cada vez que el sensor XSR cambia a “0” e inmediatamente siga con la ejecución del programa, aun cuando el sensor este en “0”, es decir aunque no termine de atravesar la lámina.
El problema que tengo es que mientras el sensor está recorriendo la lámina, el resto del programa no se ejecuta, porque está metido en la subrutina de incrementar el contador y permanece ahí hasta que el sensor sale de la lámina, todo ese tiempo desatiende otros eventos importantes como recibir llamadas de los pisos, etc., etc.
 
Gracias por tu respuesta.
En el mundo real no es un fin de carrera, es un sensor óptico, pero por razones de simulación he usado un switch.
Este sensor atraviesa una lámina metálica de aproximadamente 10 Cm de largo .
Lo que yo busco es un código que incremente el contador cada vez que el sensor XSR cambia a “0” e inmediatamente siga con la ejecución del programa, aun cuando el sensor este en “0”, es decir aunque no termine de atravesar la lámina.
El problema que tengo es que mientras el sensor está recorriendo la lámina, el resto del programa no se ejecuta, porque está metido en la subrutina de incrementar el contador y permanece ahí hasta que el sensor sale de la lámina, todo ese tiempo desatiende otros eventos importantes como recibir llamadas de los pisos, etc., etc.
Aunque sea óptico el sensor , se le llama "fin de carrera" por la función que cumple, no a la naturaleza del sensor.
Lo que SI debe incluir el "fin de carrera" es que funcione como PARADA en ausencia de señal, es decir que, cuando esté accionado, sea por FALTA de SEÑAL, ergo, si el sensor deja de funcionar o el haz de luz se interrumpe, se para todo por seguridad.
Por ejemplo, si el ascensor está en el piso 4 y se deteriora el sensor del piso 2 todo debe detenerse por incertidumbre del sistema.
En analogía los senseres mecanicos Interrumpen la electricidad cuando estan accionados para PARAR la maniobra de movimiento.
 
Aunque sea óptico el sensor , se le llama "fin de carrera" por la función que cumple, no a la naturaleza del sensor.
Lo que SI debe incluir el "fin de carrera" es que funcione como PARADA en ausencia de señal, es decir que, cuando esté accionado, sea por FALTA de SEÑAL, ergo, si el sensor deja de funcionar o el haz de luz se interrumpe, se para todo por seguridad.
Por ejemplo, si el ascensor está en el piso 4 y se deteriora el sensor del piso 2 todo debe detenerse por incertidumbre del sistema.
En analogía los senseres mecanicos Interrumpen la electricidad cuando estan accionados para PARAR la maniobra de movimiento.
Buenos días, gracias por tus comentarios, lo que mencionas lo tengo muy claro.
 
Torres.electrónico, muchas gracias por tu ayuda.
Estuve re-leyendo nuevamente lo que mencionabas y parece que esta vez lo entendí mejor y estoy elaborando un código que podría solucionar mi problema, pero no encuentro la manera de implementar un antirrebotes que no se quede eternamente en un loop, hasta soltar el botón XSR. Intenté con el buscador del foro con las palabras While y antirrebotes en Pic basic pero, pero no me arroja nada sobre esos temas, en su lugar salen otros temas.
Seguiré buscando.
Gracias nuevamente.
 
Última edición:
Torres.electrónico, muchas gracias por tu ayuda.
Estuve re-leyendo nuevamente lo que mencionabas y parece que esta vez lo entendí mejor y estoy elaborando un código que podría solucionar mi problema, pero no encuentro la manera de implementar un antirrebotes que no se quede eternamente en un loop, hasta soltar el botón XSR. Intenté con el buscador del foro con las palabras While y antirrebotes en Pic basic pero, pero no me arroja nada sobre esos temas, en su lugar salen otros temas.
Seguiré buscando.
Gracias nuevamente.
Podrás copiar y pegar solo el programa?
 
Podrás copiar y pegar solo el programa?
De acuerdo.
Muchas gracias por tu interés.
Aquí está el código, pero cada que se actúa en el switch XSR se producen rebotes y no cuenta correctamente.
Saludos.
Perdón, dijiste copiar y pegar el programa y yo envié adjunto.
Aquí esta:
Código:
main:
if XSR = 1 then encendido '(si la entrada 0 es igual a 1, ir al sub programa…)
if XSR = 0 then contar '(si la entrada 0 es igual a 0, ir al sub programa ….)
goto main '(volver a la 1er línea del programa, osea, main)

encendido:
'***************Los bits del SELECTOR, anulan la memorización del piso solicitado********************
IF SELECTOR = 0 THEN
S0=1
ELSE
S0=0
ENDIF

IF SELECTOR = 1 THEN
S1=1         
ELSE
S1=0
ENDIF

IF SELECTOR = 2 THEN
S2=1       
ELSE
S2=0
ENDIF

llamadas:
'*************************LLAMADAS Y MEMORIZACIION DE PISO***********************************
if S0=0 and RP0=1 or XP0=1  then
RP0=1
led0=1
else
RP0=0
led0=0
endif

if S1=0 and RP1=1 or XP1=1  then
RP1=1
led1=1
else
RP1=0
led1=0
endif

if S2=0 and RP2=1 or XP2=1  then
RP2=1
led2=1
else
RP2=0
led2=0
endif

'GOTO INICIO
goto main '(volver a la etiqueta “main”)
'END

'**********************CONTADOR/SELECTOR*************************
'Conforme va subiendo de pisos el selector se va incrementando
contar:
'incrementar:
CONTA=CONTA+1 ; INCREMENTAMOS EL contador

IF CONTA=1 THEN
SELECTOR= SELECTOR+1
CONTA=0
ENDIF

If SELECTOR >= 3 Then SELECTOR = 0
goto llamadas
goto main '(volver a la etiqueta “main”)

END
 
Última edición por un moderador:
Pues ese no es el programa que has subido anteriormente. A mi me aparece esto: (No subo todo el código).

C:
IF XSR = 0  THEN    ; si XSR es accionado entonces
gosub ar            ; ir a antirebote             
gosub contar        ; ir a subrutina contar
endif

Que llama a este subrutina para quedarse a vivir en ella:

C:
'*****************************ANTIREBOTES*****************************
AR:                     
if XSR =0 then goto ar
return

'***********************************************************************


Alguien dijo algo así como que hay tantas formas de programar como programadores existen. Pero te repito, como te han repetido ya varias veces: Aprende a usar interrupciones y usa temporizadores.


Un ejemplo rápido (Que no lo mejor):

-> Interrupción por fin de carrera (Pulsador).
- Chequeo si terminó la temporalización. (Temporización activa).
Si no está activa:
- Activo bandera de que se detecto el fin de carrera.
- Marco para temporizar 1 Segundo (puede ser más, puede ser menos) (Temporizador echo también con interrupciones).
- Salgo de la interrupción.

Programa:

-Si la bandera de fin de carrera esta activa -> aumento el contador y borro la bandera.
- Goto programa :LOL:.
 
Viendo el código que se produce con ese engendro de BASIC...está por darme algo...
Mejor voy a vomitar...:sick::sick::sick::sick::sick::sick:

PD: hace mas de 40 años que no uso goto + etiquetas
🤮🤮🤮🤮🤮🤮🤮🤮🤮
 
Pues ese no es el programa que has subido anteriormente. A mi me aparece esto: (No subo todo el código).

C:
IF XSR = 0  THEN    ; si XSR es accionado entonces
gosub ar            ; ir a antirebote          
gosub contar        ; ir a subrutina contar
endif

Que llama a este subrutina para quedarse a vivir en ella:

C:
'*****************************ANTIREBOTES*****************************
AR:                  
if XSR =0 then goto ar
return

'***********************************************************************


Alguien dijo algo así como que hay tantas formas de programar como programadores existen. Pero te repito, como te han repetido ya varias veces: Aprende a usar interrupciones y usa temporizadores.


Un ejemplo rápido (Que no lo mejor):

-> Interrupción por fin de carrera (Pulsador).
- Chequeo si terminó la temporalización. (Temporización activa).
Si no está activa:
- Activo bandera de que se detecto el fin de carrera.
- Marco para temporizar 1 Segundo (puede ser más, puede ser menos) (Temporizador echo también con interrupciones).
- Salgo de la interrupción.

Programa:

-Si la bandera de fin de carrera esta activa -> aumento el contador y borro la bandera.
- Goto programa :LOL:.
Buenas noches.
Gracias, todas las sugerencias las tomaré en cuenta.
Con respecto al antirebotes, si te fijas en el código actual, no lo estoy utilizando.
Es el mismo programa, pero con las modificaciones realizadas en base a los amables consejos de torres.electrónico.
únicamente no puse la parte superior donde está la declaración de variables, etc. porque creí que no era importante al estar ya en el archivo anterior.

Aquí lo pongo completo:
Saludos.
Código:
'//directivas

INCLUDE "modedefs.bas"

ADCON1=6                ;Apaga los comparadores de voltaje y digitaliza el puerto A (PIC16F876A)

@ ERRORLEVEL -306       ; anular el mensaje de limite de página rebasado

'@ device XT_osc        ; Utiliza un cristal externo de 4 MHz

'@ device BOD_OFF       ; APAGAMOS EL BODEN DE CONSUMO

'************************************************************

'//dimensionamiento

'VARIABLES     

B5          VAR BYTE    ;SELECTOR PISOS 0~3

C0          VAR BYTE    ;MEMORIA

n1          VAR BYTE    ;variable para intermitnte

n0          VAR byte    ;variable para retardo cerrar puerta

CNT         VAR BYTE    ;variable para conteo interrupción

CONTA       VAR BYTE    ;variable para incrementar o decrementar conteo         

SELECTOR    VAR BYTE    ;variable para almacenar conteo

'************************************************************

'//ALIAS


XP0         VAR  PORTA.0   ;llamada piso 0

XP1         VAR  PORTC.5   ;llamada piso 1

XP2         VAR  PORTA.2   ;llamada piso 2

XSR         VAR  PORTA.1   ;final de carrera selector (contador)         

'***************************SALIDAS************************

led0        VAR PORTB.0    ;Memoria PISO 0

led1        VAR PORTB.1    ;Memoria PISO 1

led2        VAR PORTB.2    ;Memoria PISO 2

    

'*********Variables dependiente del SELECTOR DE PISOS*********

S0          var B5.0       ;borra memoria Piso 0

S1          var B5.1       ;borra memoria Piso 1

S2          var B5.2       ;borra memoria Piso 2

'***********************MEMORIZACION DE PISOS*****************

RP0         VAR  C0.0       ;memoria Piso 0

RP1         VAR  C0.1       ;memoria Piso 1

RP2         VAR  C0.2       ;memoria Piso 2

'*************************************************************

'//configuraciones

TRISA=%11111111          ;Configuara el puerto A como ENTRADAS

TRISB=%10000000          ;Configuara el puerto B.7 como entrada, el resto como salidas

TRISC=%00101000          ;Configuara el puerto _C.3 y C.5 como entrada, el resto como salidas

PORTB=0

'SELECTOR=0


'inicio:



'\\Cuando el final de carrera XSR = 0, es decir, cuando es accionado, esto en la realidad dura

'unos 20 segundos o más, el programa se estanca y no se puede hacer las llamadas

'desde otros pisos y ninguna otra acción.



'IF XSR = 0  THEN    ; si XSR es accionado entonces

'gosub ar            ; ir a antirebote           

'gosub contar        ; ir a subrutina contar

'endif


main:

if XSR = 1 then encendido '(si la entrada 0 es igual a 1, ir al sub programa…)

if XSR = 0 then contar '(si la entrada 0 es igual a 0, ir al sub programa ….)

goto main '(volver a la 1er línea del programa, osea, main)


encendido:

'***************Los bits del SELECTOR, anulan la memorización del piso solicitado********************

IF SELECTOR = 0 THEN

S0=1

ELSE

S0=0

ENDIF


IF SELECTOR = 1 THEN

S1=1         

ELSE

S1=0

ENDIF

 

IF SELECTOR = 2 THEN

S2=1       

ELSE

S2=0

ENDIF


llamadas:

'*************************LLAMADAS Y MEMORIZACIION DE PISO***********************************

if S0=0 and RP0=1 or XP0=1  then

RP0=1

led0=1

else

RP0=0

led0=0

endif


if S1=0 and RP1=1 or XP1=1  then

RP1=1

led1=1

else

RP1=0

led1=0

endif


if S2=0 and RP2=1 or XP2=1  then

RP2=1

led2=1

else

RP2=0

led2=0

endif


'GOTO INICIO

goto main '(volver a la etiqueta “main”)

'END

'**********************CONTADOR/SELECTOR*************************

'Conforme va subiendo de pisos el selector se va incrementando

contar:

'incrementar:

CONTA=CONTA+1 ; INCREMENTAMOS EL contador

IF CONTA=1 THEN

SELECTOR= SELECTOR+1

CONTA=0

ENDIF

If SELECTOR >= 3 Then SELECTOR = 0

goto llamadas


goto main '(volver a la etiqueta “main”)

END

'*****************************ANTIREBOTES*****************************

AR:                   

if XSR =0 then goto ar

return


'***********************************************************************
Viendo el código que se produce con ese engendro de BASIC...está por darme algo...
Mejor voy a vomitar...:sick::sick::sick::sick::sick::sick:

PD: hace mas de 40 años que no uso goto + etiquetas
🤮🤮🤮🤮🤮🤮🤮🤮🤮
No sé por qué lo dices.
Nadie nace sabiendo, y si como novato que soy me sirve el Basic para iniciarme en esto de la programación de los microcontroladores, pues bien venido sea.
A propósito, cuál es el lenguaje que tu utilizas?
Me refiero al de programación.
Saludos!
 
Nadie nace sabiendo, y si como novato que soy me sirve el Basic para iniciarme en esto de la programación de los microcontroladores, pues bien venido sea.
A propósito, cuál es el lenguaje que tu utilizas?
Me refiero al de programación
La crítica no es hacia vos sino hacia el lenguaje, que es una bestia prehistórica que debió morir en los 80's pero aún sigue viva destrozando la forma de pensar de los programadores...y en especial de los novatos.
Yo uso C y C++ hace muchos años para programar microntroladores, pero también los he programado en PLM y en assembler. También programo en Java y en Python, pero no microcontroladores...y a Python lo odio...
 
La crítica no es hacia vos sino hacia el lenguaje, que es una bestia prehistórica que debió morir en los 80's pero aún sigue viva destrozando la forma de pensar de los programadores...y en especial de los novatos.
Yo uso C y C++ hace muchos años para programar microntroladores, pero también los he programado en PLM y en assembler. También programo en Java y en Python, pero no microcontroladores...y a Python lo odio...
No hay problema!
Tomaré en cuenta tus observaciones.
Saludos!
 
Tranqui Oswald, es como el helado, te gustan unos y otros menos,.
Yo por ejemplo, siempre amé a Basic,(compilable o no) porque me permitía resolver pavadas en 10 minutos, que era mi necesidad inmediata, para resolver asuntos de reparar COSAS.
Al C en todas sus versiones, no le tuve paciencia y no me gustaba su sintaxis en general. Tampoco ahora. :giggle:
 
Tranqui Oswald, es como el helado, te gustan unos y otros menos,.
Yo por ejemplo, siempre amé a Basic,(compilable o no) porque me permitía resolver pavadas en 10 minutos, que era mi necesidad inmediata, para resolver asuntos de reparar COSAS.
Al C en todas sus versiones, no le tuve paciencia y no me gustaba su sintaxis en general. Tampoco ahora. :giggle:
Estimado unmonje, gracias por tus comentarios.
Algo parecido me pasa, me siento más cómodo con el lenguaje Basic, pero si tengo oportunidad más adelante si me gustaría curiosear el lenguaje C aunque sea para desanimarme.
Cordial saludo!
 
Última edición:
Atrás
Arriba