Pues antes que nada señor don can 
agradecerle que sé allá tomado la molestia de mirar este humilde hilo que asu altura asta le a de causar flojera.
Esta de mas felicitarle por el excelente desarrollo que nos a echa favor de aportar y si no le causa mucha molestia me aria un grandísimo favor si pudiera extendernos el consejo de su
Ultima línea.
De todas formas como consejo en los lenguajes de altonivel no se suelen utilizar los saltos absolutos ni tampoco los pauses, delays, waits, etc.
Ase mucho tiempo que sé que esto debe ser así pero no se como manejarlo ni encuentro
Información al respecto por lo cual mis desarrollos son deficientes
Un abraso
La instrucción goto cuando se utiliza en un programa produce un código que es muy difícil de entender ya que rompe la estructura enfocada a una rutina principal o main.
Ejemplo de programa Basic organizado alrededor de una rutina principal:
‘***** NUESTRO PROGRAMA *****
Cabecera
‘------------------------------
Definiciones
‘------------------------------
Declaraciones
‘------------------------------
Configuración módulos
‘------------------------------
Código Inicio, si hay
‘------------------------------
Subrutina principal (Main)
Main:
Código inicio, si hay
If timer1 then
Evento 1º -> Gosub Evento_1, Función Evento_1 (datos) o también Procedimiento Evento_1 (datos)
Endif
If timer2 then
Código intermedio, si hay
Endif
Evento 2º -> Gosub Evento_2, Función Evento_2 (datos) o también Procedimiento Evento_2 (datos)
Código intermedio, si hay
If timer3 then
Evento 3º -> Gosub Evento_3, Función Evento_3 (datos) o también Procedimiento Evento_3 (datos)
(Por ejemplo controla la intermitencia de un led, y timer3 establece la cadencia de parpadeo)
Endif
Llamada a subrutina de control de las base de tiempos (timer), se puede condicionar al Flag de
rebose de un modulo Timer, con Gosub, Función o Procedimiento
Código de cierre, si hay
Goto main ‘la única vez que se utiliza el Goto, para generar un bucle infinito
End
‘-------------------------------
Subrutina, función o procedimiento delays evento_1
Cuerpo
Retorno
‘-------------------------------
Subrutina, función o procedimiento delays evento_2
Cuerpo
Retorno
‘-------------------------------
Subrutina, función o procedimiento delays evento_3
Cuerpo
retorno
‘-------------------------------
Subrutina, función o procedimiento delays
Timer1
Timer2
Timer3
Timer4
Etc.
Retorno
End
‘************** FIN *******************
En este prototipo de programa no se pueden utilizar paradas absolutos ya que afectaríamos a los de mas
procesos del main, siempre contemplándolos como procesos diferentes incluso puede que no relacionados entre si.
Y al usar saltos absolutos con el Goto, ya permita el compilador omitirlo o no. Tenemos que indicar al procesador
en cada salto donde tiene que retornar en cada momento ocasionando programas muy complicados.
Mientras que al realizar los con Gosub o Funciones el ordenador sabe en todo momento donde tiene que retornar,
que es la línea siguiente a la que provocó el salto. Incluso nosotros a simple vista sabremos donde continuara nuestro
programa una vez terminada la subrutina.
Lo ideal es que la subrutina de control de los timer este incorporada en el vector de interrupciones ya que se consigue
un rendimiento mucho mayor. En el caso de ser así ya no habría que llamarla desde el Main, esto se haría de forma automática.
O en el peor de los casos comprobar el flag de rebose de un timer físico para provocar el salto para la actualización de los timer
o contadores de nuestra rutina para medir tiempo.
PD: Creo que esta estructura básica es la más aceptada y espero que exprese el contenido de la frase...
