PIC BASIC del PIC Simulator IDE Oshonsoft (Índice en página 1)

[21CURIOSOS]

Entonces esto significa que al tener que hacer la lectura de los tres ADC sera mejor utilizar el programa con los ADCIN, pues si interactuan los define con adcon0 y adcon1 siempre tendre los problemas que te indicaba.

Por otro lado la seleccion de la frecuencia del PWMon1,12, segun el manual a 4 mhz de reloj es de 31250 hz, el calculo si trabajo a 8 mhz ¿es proporcional? osea, ¿es el doble? o hay alguna forma de calcularlo.

[dogflu66]

Los cálculos a 4Mhz de la tabla del manual son proporcionales para 8Mhz.
No se como hacer los calculo utilizando la función ya que pasa como con ADCIN, configura el modulo de una manera no transparente. Y vuleve a pasar lo mismo que con ADCIN si quieres un mejor control del modulo CCP1 tienes que programarlo de forma directa, de esta forma si puedes hacer todos los cálculos necesarios, en el índice del hilo se indica como hacerlo para el modulo CCP1 trabajando en modo PWM.

Y volviendo a lo anterior tan solo tienes que indicar antes de activar una lectura del ADC que pin es el de entrada. La función ADCIN parece que va más rápida en la simulación porque el  simulador la reconoce y la truca, pero al hacer la lectura directamente con el modulo ADC con nuestro programita el PSI se ve obligado a realizar todos los paso y esperar los tiempos programados pero en la realidad es mucho más rápida que la función.

En fin, no veo el problema de sustituir todos los ADCIN por la rutina anterior de lectura, pero si te es más cómodo y te funciona bien para lo que estas usando, pues sigue can ADCIN. De todas formas cuando tenga tiempo acoplare la rutina a tu programa con su correspondiente selección de pin es tan solo añadir una linea más antes de acitvar la lectura.

[dogflu66]

Lo he probado en el simulador y me da todo correcto:

Código: vb.net

1. '************* ADAPTADO PARA TRABAJAR CON EL MODULO ADC SIN INTERRUPCIONES**************
2. '***************************************************************************************
3. 'NOMBRE: 16F88_MandoJEVO_01
4. 'MICRO: PIC16f88
5. 'Version: 1.0
6. ''**************************************************************************************
7.  
8. Define CONF_WORD = 0x2f50
9. Define CONF_WORD_2 = 0x3ffc
10. Define CLOCK_FREQUENCY = 8
11. 'Define ADC_SAMPLEUS = 10
12. 'Define ADC_CLOCK = 5
13.  
14. Dim duty(16) As Byte  'Duty Cicle
15. Dim curva(15) As Byte  'Curva grabada
16. Dim vg As Word  'Valor gatillo
17. Dim ca As Byte  'Curva actual
18. Dim cn As Byte  'Curva nueva
19. Dim mca As Byte  'Modificacion curva actual P5
20. Dim mcn As Byte  'Modificacion curva nueva  P5
21. Dim asa As Byte  'Antispin Actual P4
22. Dim asn As Byte  'Antispin nuevo P4
23. Dim ai As Byte  'Contador inicio
24. Dim af As Byte  'Contador fin
25. Dim a As Byte  'contador
26. Dim b As Byte
27. Dim va(4) As Byte
28. Dim mc(3) As Byte
29. Dim i As Byte
30.  
31. ANSEL = %00100011  'Los pin digitales y NA5, NA1 y NA0 como analogicos
32. TRISB = %11110111  'Configuración input/output
33. TRISA = %11111111  'Configuración input/output
34. CMCON = 0x07  'Comparador a off
35. OSCCON = 0x7e  'Set intrc To 8mhz, se usara reloj interno a 8Mhz
36. ADCON0 = %01100001  'Fosc/16 a 8Mhz (ADCON1.ADCS2=1) =2uSeg (minimo 1.6uSeg), channel RA4
37. ADCON1 = %11000000  'Volt. ref.(AVdd/AVss), selec. de escala division clock/16 ADCON1.ADCS2=1, ADC a ON
38. 'ADCON1.ADFM = 0  'Activa lectura 8bit del ADC
39. '___________________
40.  
41. 'Ver curva actual
42. Gosub vercurva
43. Gosub leermemoria
44. Gosub modificarcurva
45. Gosub modificararranque
46.  
47. PWMon 1, 12
48. PWMduty 1, 0
49.  
50. '****************************************************************************
51. 'Rutina principal
52. loop:
53.         For i = 1 To 13
54.                 Gosub vercurva  'Comprueba que no se haya cambiado la curva
55.                 If cn <> ca Then Gosub leermemoria
56. '* Leer gatillo
57.                 Gosub salidapwm
58.        
59. 'Adcin 0, mcn  'lee el valor de p5
60.                 ADCON0.CHS0 = 0  'Selecciono canal AN0 para el modulo ADC
61.                 ADCON0.CHS1 = 0
62.                 ADCON0.CHS2 = 0
63.                 ADCON1.ADFM = 0  'Activa lectura 8bit del ADC
64.                 ADCON0.GO = 1  'Activo una lectura
65.                 While ADCON0.GO = 1  'Espera hasta terminar la conversion ADC
66.                 Wend
67.                 mcn = ADRESH  'ADC a 8bit
68.        
69.                 If mcn <> mca Then Gosub modificarcurva
70.                        
71. '* Leer gatillo
72.                 Gosub salidapwm
73.  
74. 'Adcin 5, asn  'lee el valor de p4
75.                 ADCON0.CHS0 = 1  'Selecciono canal AN5 para el modulo ADC
76.                 ADCON0.CHS1 = 0
77.                 ADCON0.CHS2 = 1
78.                 ADCON1.ADFM = 0  'Activa lectura 8bit del ADC
79.                 ADCON0.GO = 1  'Activo una lectura
80.                 While ADCON0.GO = 1  'Espera hasta terminar la conversion ADC
81.                 Wend
82.                 asn = ADRESH  'ADC a 8bit
83.  
84.                 If asn <> asa Then Gosub modificararranque
85.                
86. '* Leer gatillo
87.                         Gosub salidapwm
88. Next i
89.  
90. Goto loop
91. End                                              
92.  
93.  
94. '********************************************************
95. 'Deteccion de la curva a leer
96. vercurva:
97. 'Ver curva nueva
98.  
99. cn = 0
100. If PORTA.2 = 1 Then cn = cn + 4
101. If PORTA.3 = 1 Then cn = cn + 2
102. If PORTA.4 = 1 Then cn = cn + 1
103. If PORTA.5 = 1 Then cn = cn + 8
104.  
105. ai = cn * 16  'Posicion inicial de memoria donde leer
106. af = ai + 14  'Posicion final de memoria donde leer
107.  
108. Return                                            
109. leermemoria:
110.  
111. 'Leer valores Guardados segun la curva a leer
112. For a = ai To af
113.         b = a - ai
114.         Read a, duty(b)
115.         curva(b) = duty(b)
116. Next a
117.  
118. 'Genera los valores para las modificaciones de curvas
119.  
120. va(0) = (curva(10) - curva(4)) / 5  'Calculo maxima modificacion
121. va(1) = va(0) * 2  '(va(0) * 10) / 5 es el valor de correccion del 100 % multiplicado por 10
122. va(2) = va(0)  '(va(0) * 10) / (2 * 5)  es el valor de correccion del 50 % multiplicado por 10
123. va(3) = (va(0) * 10) / 15  '(va(0) * 10) / (3 * 5) es el valor de correccion del 30 % multiplicado por 10
124. ca = cn
125.  
126.  
127. Return                                            
128.  
129. '********************************************************************************************
130. 'Rutina deteccion posicion del gatillo y entrega de potencia
131. salidapwm:
132.         For a = 1 To 8
133.  
134. 'Adcin 1, vg  'lee el valor del gatillo
135.                 ADCON0.CHS0 = 1  'Selecciono canal NA1 para el modulo ADC
136.                 ADCON0.CHS1 = 0
137.                 ADCON0.CHS2 = 0
138.                 ADCON1.ADFM = 1  'Activa lectura 10bit del ADC
139.                 ADCON0.GO = 1  'Activo una lectura
140.                 While ADCON0.GO = 1  'Espera hasta terminar la conversion ADC
141.                 Wend
142.                 vg.HB = ADRESH  'ADC a 10bit
143.                 vg.LB = ADRESL  'ADC a 10bit
144.  
145.                 Select Case vg
146.                         Case < 64
147.                                 PWMduty 1, 0  'Freno
148.                         Case < 128
149.                                 PWMduty 1, duty(0)
150.                         Case < 192
151.                                 PWMduty 1, duty(1)
152.                         Case < 256
153.                                 PWMduty 1, duty(2)
154.                         Case < 320
155.                                 PWMduty 1, duty(3)
156.                         Case < 384
157.                                 PWMduty 1, duty(4)
158.                         Case < 448
159.                                 PWMduty 1, duty(5)
160.                         Case < 512
161.                                 PWMduty 1, duty(6)
162.                         Case < 576
163.                                 PWMduty 1, duty(7)
164.                         Case < 640
165.                                 PWMduty 1, duty(8)
166.                         Case < 704
167.                                 PWMduty 1, duty(9)
168.                         Case < 768
169.                                 PWMduty 1, duty(10)
170.                         Case < 832
171.                                 PWMduty 1, duty(11)
172.                         Case < 896
173.                                 PWMduty 1, duty(12)
174.                         Case < 960
175.                                 PWMduty 1, duty(13)
176.                         Case <= 1023
177.                                 PWMduty 1, duty(14)
178.                 EndSelect
179.  
180.         Next a
181. Return                                            
182.  
183. '*************************************************************
184. 'Ajuste fino de la curva grabada
185. 'Rutina para modificar el centro de la curva
186. modificarcurva:
187.  
188.         Select Case mcn
189.                 Case < 22  'P -5
190.                         mc(0) = ((va(3) * 5) / 10)
191.                         mc(1) = ((va(1) * 5) / 10)
192.  
193.                         duty(5) = curva(5) - mc(0)
194.                         duty(6) = curva(6) - mc(1)
195.                         duty(7) = curva(7) - mc(1)
196.                         duty(8) = curva(8) - mc(1)
197.                         duty(9) = curva(9) - mc(0)
198.  
199.                         mca = mcn
200.                         Return
201.  
202.                 Case < 44  'P -4
203.                         mc(0) = ((va(3) * 4) / 10)
204.                         mc(1) = ((va(1) * 4) / 10)
205.  
206.                         duty(5) = curva(5) - mc(0)
207.                         duty(6) = curva(6) - mc(1)
208.                         duty(7) = curva(7) - mc(1)
209.                         duty(8) = curva(8) - mc(1)
210.                         duty(9) = curva(9) - mc(0)
211.                        
212.                         mca = mcn
213.                         Return
214.                 Case < 66  'P -3
215.                         mc(0) = ((va(3) * 3) / 10)
216.                         mc(1) = ((va(1) * 3) / 10)
217.  
218.                         duty(5) = curva(5) - mc(0)
219.                         duty(6) = curva(6) - mc(1)
220.                         duty(7) = curva(7) - mc(1)
221.                         duty(8) = curva(8) - mc(1)
222.                         duty(9) = curva(9) - mc(0)
223.  
224.                         mca = mcn
225.                         Return
226.  
227.                 Case < 88  'P -2
228.                         mc(0) = ((va(3) * 2) / 10)
229.                         mc(1) = ((va(1) * 2) / 10)
230.  
231.                         duty(5) = curva(5) - mc(0)
232.                         duty(6) = curva(6) - mc(1)
233.                         duty(7) = curva(7) - mc(1)
234.                         duty(8) = curva(8) - mc(1)
235.                         duty(9) = curva(9) - mc(0)
236.  
237.                         mca = mcn
238.                         Return
239.  
240.                 Case < 110  'P -1
241.                         mc(0) = va(3) / 10
242.                         mc(1) = va(1) / 10
243.  
244.                         duty(5) = curva(5) - mc(0)
245.                         duty(6) = curva(6) - mc(1)
246.                         duty(7) = curva(7) - mc(1)
247.                         duty(8) = curva(8) - mc(1)
248.                         duty(9) = curva(9) - mc(0)
249.                        
250.                         mca = mcn
251.                         Return
252.                 Case < 145  'P 0
253.                         duty(5) = curva(5)
254.                         duty(6) = curva(6)
255.                         duty(7) = curva(7)
256.                         duty(8) = curva(8)
257.                         duty(9) = curva(9)
258.  
259.                         mca = mcn
260.                         Return
261.  
262.                 Case < 165  'P +1
263.  
264.                         mc(0) = va(3) / 10
265.                         mc(1) = va(2) / 10
266.                         mc(2) = va(1) / 10
267.  
268.                         duty(5) = curva(5) + mc(0)
269.                         duty(6) = curva(6) + mc(1)
270.                         duty(7) = curva(7) + mc(2)
271.                         duty(8) = curva(8) + mc(1)
272.                         duty(9) = curva(9) + mc(0)
273.  
274.                         mca = mcn
275.                         Return
276.                
277.                 Case < 185  'P +2
278.  
279.                         mc(0) = ((va(3) * 2) / 10)
280.                         mc(1) = ((va(2) * 2) / 10)
281.                         mc(2) = ((va(1) * 2) / 10)
282.  
283.                         duty(5) = curva(5) + mc(0)
284.                         duty(6) = curva(6) + mc(1)
285.                         duty(7) = curva(7) + mc(2)
286.                         duty(8) = curva(8) + mc(1)
287.                         duty(9) = curva(9) + mc(0)
288.  
289.                         mca = mcn
290.                         Return
291.  
292.                 Case < 205  'P +3
293.                         mc(0) = ((va(3) * 3) / 10)
294.                         mc(1) = ((va(2) * 3) / 10)
295.                         mc(2) = ((va(1) * 3) / 10)
296.  
297.                         duty(5) = curva(5) + mc(0)
298.                         duty(6) = curva(6) + mc(1)
299.                         duty(7) = curva(7) + mc(2)
300.                         duty(8) = curva(8) + mc(1)
301.                         duty(9) = curva(9) + mc(0)
302.  
303.                         mca = mcn
304.                         Return
305.  
306.                 Case < 230  'P +4
307.                         mc(0) = ((va(3) * 4) / 10)
308.                         mc(1) = ((va(2) * 4) / 10)
309.                         mc(2) = ((va(1) * 4) / 10)
310.  
311.                         duty(5) = curva(5) + mc(0)
312.                         duty(6) = curva(6) + mc(1)
313.                         duty(7) = curva(7) + mc(2)
314.                         duty(8) = curva(8) + mc(1)
315.                         duty(9) = curva(9) + mc(0)
316.  
317.                         mca = mcn
318.                         Return
319.  
320.                 Case <= 255  'P +5
321.                         mc(0) = ((va(3) * 5) / 10)
322.                         mc(1) = ((va(2) * 5) / 10)
323.                         mc(2) = ((va(1) * 5) / 10)
324.  
325.                         duty(5) = curva(5) + mc(0)
326.                         duty(6) = curva(6) + mc(1)
327.                         duty(7) = curva(7) + mc(2)
328.                         duty(8) = curva(8) + mc(1)
329.                         duty(9) = curva(9) + mc(0)
330.                        
331.                         mca = mcn
332.                         Return
333.  
334.         EndSelect
335. Return                                            
336.  
337. '*****************************************************************
338. 'Ajuste del control de arrancada
339. modificararranque:
340. Select Case asn
341.                 Case < 25  'P 1
342.                         duty(0) = curva(0)
343.                         duty(1) = curva(1)
344.                         duty(2) = curva(2)
345.                         duty(3) = curva(3)
346.                         duty(4) = curva(4)
347.                         asa = asn
348.                         Return
349.  
350.                 Case < 50  'P 2
351.                         duty(0) = curva(0) + (((curva(1) - curva(0)) * 50) / 100)
352.                         duty(1) = curva(1)
353.                         duty(2) = curva(2)
354.                         duty(3) = curva(3)
355.                         duty(4) = curva(4)
356.                         asa = asn
357.                         Return
358.  
359.                 Case < 75  'P 3
360.                         duty(0) = curva(1)
361.                         duty(1) = curva(1) + (((curva(2) - curva(1)) * 40) / 100)
362.                         duty(2) = curva(2)
363.                         duty(3) = curva(3)
364.                         duty(4) = curva(4)
365.                         asa = asn
366.                         Return
367.  
368.                 Case < 100  'P 4
369.                         duty(0) = curva(1) + (((curva(2) - curva(1)) * 40) / 100)
370.                         duty(1) = curva(1) + (((curva(2) - curva(1)) * 80) / 100)
371.                         duty(2) = curva(2)
372.                         duty(3) = curva(3)
373.                         duty(4) = curva(4)
374.                         asa = asn
375.                         Return
376.  
377.                 Case < 125  'P 5
378.                         duty(0) = curva(1) + (((curva(2) - curva(1)) * 80) / 100)
379.                         duty(1) = curva(2)
380.                         duty(2) = curva(2) + (((curva(3) - curva(2)) * 40) / 100)
381.                         duty(3) = curva(3)
382.                         duty(4) = curva(4)
383.                         asa = asn
384.                         Return
385.  
386.                 Case < 150  'P 6
387.                         duty(0) = curva(2)
388.                         duty(1) = curva(2) + (((curva(3) - curva(2)) * 40) / 100)
389.                         duty(2) = curva(2) + (((curva(3) - curva(2)) * 80) / 100)
390.                         duty(3) = curva(3)
391.                         duty(4) = curva(4)
392.                         asa = asn
393.                         Return
394.  
395.                 Case < 175  'P 7
396.                         duty(0) = curva(2) + (((curva(3) - curva(2)) * 40) / 100)
397.                         duty(1) = curva(2) + (((curva(3) - curva(2)) * 80) / 100)
398.                         duty(2) = curva(3)
399.                         duty(3) = curva(3) + (((curva(4) - curva(3)) * 40) / 100)
400.                         duty(4) = curva(4)
401.                         asa = asn
402.                         Return
403.                
404.                 Case < 200  'p 8
405.                         duty(0) = curva(2) + (((curva(3) - curva(2)) * 80) / 100)
406.                         duty(1) = curva(3)
407.                         duty(2) = curva(3) + (((curva(4) - curva(3)) * 40) / 100)
408.                         duty(3) = curva(3) + (((curva(4) - curva(3)) * 80) / 100)
409.                         duty(4) = curva(4)
410.                         asa = asn
411.                         Return
412.  
413.                 Case < 225  'P 9
414.                         duty(0) = curva(3)
415.                         duty(1) = curva(3) + (((curva(4) - curva(3)) * 40) / 100)
416.                         duty(2) = curva(3) + (((curva(4) - curva(3)) * 80) / 100)
417.                         duty(3) = curva(4)
418.                         duty(4) = curva(4) + (((curva(5) - curva(4)) * 40) / 100)
419.                         asa = asn
420.                         Return
421.        
422.                 Case <= 255  'P 10
423.                         duty(0) = curva(3) + (((curva(4) - curva(3)) * 40) / 100)
424.                         duty(1) = curva(3) + (((curva(4) - curva(3)) * 80) / 100)
425.                         duty(2) = curva(4)
426.                         duty(3) = curva(4) + (((curva(5) - curva(4)) * 40) / 100)
427.                         duty(4) = curva(4) + (((curva(5) - curva(4)) * 80) / 100)
428.                         asa = asn
429.                         Return
430.  
431.         EndSelect
432. Return

PD. La rutina de control del modulo ADC tarda 35uSeg. en la version de 10bit y 33uSeg. en la version de 8Bit.

[21CURIOSOS]

Bueno, pues genial, lo he probado y con los trece ciclos que lo pruebo, me ha reducido el tiempo en 6 ms,esto supone una fiabilidad mucho mayor en la respuesta del mando. (Edito) 10 ms con todos los ADC a 8 bits

Ahora ya solo te pido un favor mas, y tan solo te pido que me marques el camino para ir aprendiendo.

En la memoria grabo los mapas de la curva de potencia que son con los que consigo un funcionamiento u otro del coche

Actualmente y como no se como hacerlo de otra manera escribo los datos con el editor de la memoria del Pic simulator ide y luego lo grabo con el Pickit de microchip.

-Hay algun metodo mas rapido para editar los datos que el editor del Pic Simulator Ide

Aunque mi idea es hacerlo finalmente a traves del USB, veo que me queda muchisimo por aprender.Por cierto si tienes algun enlace que explique como hacer la conexion y como programar el pic (en basic) te lo agradeceria.

Y repito gracias por todo

[dogflu66]

He seguido haciendo pruebas y con esta configuracion me tarda la rutina de 10Bit 13uSeg. corrienso sobre la EBasic.

ADCON0 = %00100001  'Fosc/2, channel RA4
ADCON1 = %10000000  'volt. ref.AVdd/AVss, ADC a ON

[dogflu66]

Para transferir datos desde un dispositivo exterior al pic tienes ejemplos en el indice del foro.

Pero para asignar valores por ejemplo de una lista a un vector se utiliza lo siguiente:

Código: vb.net

1. Dim dato As Byte
2. Dim indice As Byte
3. Dim curva_1(10) As Byte
4. '...........
5. main:
6. '.
7. '.
8. '.
9.         For indice = 0 To 9
10.                 dato = LookUp(0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f), indice 'Valores a transferir
11.                 curva_1(indice) = dato
12.         Next indice
13. '.
14. '.
15. '.
16. Goto main
17. End

[_Lince_]

Gostei muito dos temas abordados neste forum, espero fazer grandes amigos aqui e
poder compartilhar informações!! 8)Sou brasileiro e utilizo a eletrônica com hobby.
At.
_Lince_

Minha contribuição inicial!!
Fontes!!
http://rapidshare.com/files/158984877/Automa__o.zip.html

Simulação no Proteus!!
http://rapidshare.com/files/158977020/Automa__o.DSN.html

[dogflu66]

Bienvenido Lince;
Interesante proyecto por lo que puedo ver son tres 16F84 conectados por un bus común, tipo RS485. Si puedes comentar un poco lo que deben de hacer los programas y su interacción estaría genial.

Lastima, no me funciona la simulación del proteus me da 4 errores.

Interesante el uso de la función Pointer “Pointer(index_buffer) = ponteiro”, esa función pertenece a la programación avanzada. Me agradaría mucho añadir algún ejemplo de su uso en el índice.

[21CURIOSOS]

dogflu, yo lo he probado y si que me funciona, pero he tenido que compilar los pdf para convertirlos a hex, y entonces cargar cada pic con su correspondiente hex ya de mi ordenador.

No obstante debido a mi inexperiencia con proteus, me quedo igual y sin una explicacion tal y como comentas, no entiendo lo que hace el esquema.

[_Lince_]

Ok dogflu66!!
Na realidade este projeto possui um master que dei o nome de polvo e outros dois periféricos que chamei de cobra e camaleão.Todos
estão em um barramento RS485.O master tem a função de verificar entradas de sensores e encaminhar o comando para um dos pe-
riféricos que acionará uma saída correspondente.O protocolo que criei foi baseado em redes de pc, porém simplificado,mas cada periférico
possui seu grupo e endereço podendo ser chamados também com broadcast de grupo (executa comando mas não responde ao master),
foi implementado também um checksum 16bits para checar a integridade de cada pacote.Todo o projeto foi concebido com o intuito de testar esta
brilhante IDE Oshon e demonstrar sua capacidade, pois se bem utilizada gera códigos extremamente rápidos e pequenos.Programo em assembly
a um bom tempo por isso posso afirmar que esta IDE possui o melhor compilador basic do mercado.Muitos poderão dizer...não há tantas funções
prontas como Proton ou Picbasic Pro ou até mesmo o Mikrobasic,mas eu mesmo testei seus códigos e verifiquei na prática as diferenças.
Todo programa bem elaborado faz uso de interrupções não é?,pois bem! No compilador basic Oshon o tempo de latência nas interrupção é o mesmo do
assembly 8)nos demais :?Picbasic pro e demais que digam...
Aqui esta os hex dos arquivos já compilados para utilizar no proteus!(A versão do proteus é a 7.2 sp2)
http://rapidshare.com/files/159284394/Automa__o.zip.html

'******************Carga de parametros na inícialização**************
index_eeprom = 0    'aponto para a posição zero da eeprom.
index_buffer = 0x032 'aponto para a posição 0x032 da ram.
le_meus_dados_eeprom:
       If index_eeprom < 8 Then
          Read index_eeprom, ponteiro
          Pointer(index_buffer) = ponteiro     'poneiro aqui é apenas uma variável que guardo os valores previamente gravados na eeprom e os transfiro para
          index_buffer = index_buffer + 1     'um buffer de ram que se inicia na posição 0x032 utilizando a função pronta pointer().Ao final desta rotina meus
          index_eeprom = index_eeprom + 1'parametros estaram guardados no buffer de ram chamado parametros().
          Goto le_meus_dados_eeprom
Endif

At.
_Lince_

[dogflu66]

Las interrupciones son imprescindibles para realizar cualquier programa y, este compilador genera un código bastante rápido y reducido. Incluso se pueden realizar muy buenas aplicaciones con micros “enanos” que tan solo tienen una memoria de 512Word. También es cierto que hay lenguajes que tienen un mayor numero de funciones, pero en realidad estas funciones suelen ser lentas y muy incompletas en general. En la realidad el programador suele construir sus propias funciones las que son más rápidas y suelen ocupar menos código.

[_Lince_]

Software feito por quem não tem oque fazer.
Descrição: Este software funciona como um mini hardlock, que pode ser ligado em qualquer aplicação que possua serial RS232.
A aplicação deve enviar a seguencia "1234" e o hardlock irá responder "34".Não disse que não tinha nada para fazer!!

'Este software servirá como base para um sistema de checagem de senha tipo (Hardlock) via se-
'rial .
'MCU utilizada (10F200) rodando a 4MHZ em operação normal(RC interno).
'Autor: _Lince_
'Data: 21/10/2008
'Nome do aplicativo (Checa senha r0.1)
'*********************************Configuração dos fusiveis**********************************
Define CONF_WORD = 0x000
Define SEROUT_REG = GPIO
Define SEROUT_BIT = 0
Define SERIN_BIT = 3
Define SEROUT_BAUD = 9600
'Define SIMULATION_WAITMS_VALUE = 1 'Retirar esta linha para gravação em hardware.
'*********************************Definição dos I/Os*****************************************
'GPIO.GP0 saída led de validação.
'GPIO.GP1 entrada RX RS232 a 9600 bps..
'*********************************Variaveis do sistema***************************************
Dim buffer_rx_0 As Byte @ 0x18
Dim buffer_rx_1 As Byte @ 0x19
Dim buffer_rx_2 As Byte @ 0x1a
Dim buffer_rx_3 As Byte @ 0x1b
Dim contador As Byte @ 0x1c
Dim dado As Byte @ 0x1d
Dim contra_senha_0 As Byte @ 0x1e
Dim contra_senha_1 As Byte @ 0x1f
'***********************************Constantes do systema************************************
'*************************************Atribuições de I/Os entre outros***********************
Symbol led_ok = GPIO.1
Symbol rx = GPIO.3
'************************************Direção dos I/Os****************************************
TRISGPIO.0 = 0 ' Saída.(tx).
TRISGPIO.1 = 0 ' Saída.(led_ok).
TRISGPIO.3 = 1 ' Entrada.(rx).
'***************************************Main*************************************************
contador = 0
ASM:   movlw  0x18 'Ponteiro do buffer de senha.
ASM:   movwf  fsr
led_ok = 0
buffer_rx_0 = 0
buffer_rx_1 = 0
buffer_rx_2 = 0
buffer_rx_3 = 0
contra_senha_0 = 0x33
contra_senha_1 = 0x34
main:
     If led_ok = 1 Then
        Serout contra_senha_0,contra_senha_1
        led_ok = 0
     Endif
     If contador = 4 Then Goto checa_senha     
     If rx = 0 Then
        If contador < 4 Then Goto le_rx
checa_senha:         
              contador = 0
              ASM:  movlw  0x18      'Aponto para início do buffer novamente.
              ASM:  movwf  fsr
              ASM:  movlw  0x31         'senha_0
              ASM:  xorwf  buffer_rx_0,w
              ASM:  btfss  status,z
              ASM:  goto   $+ 0x0e           
              ASM:  movlw  0x32         'senha_1
              ASM:  xorwf  buffer_rx_1,w
              ASM:  btfss  status,z
              ASM:  goto   $+ 0x0a             
              ASM:  movlw  0x33         'senha_2                       
              ASM:  xorwf  buffer_rx_2,w
              ASM:  btfss  status,z
              ASM:  goto   $+ 0x06
              ASM:  movlw  0x34         'senha_3
              ASM:  xorwf  buffer_rx_3,w
              ASM:  btfss  status,z
              ASM:  goto   $+ 0x02
              ASM:  bsf    led_ok       'uso uma saída como flag para poder verificar e                   
              ASM:  nop                 'transmitir a contra senha.
        Endif
Goto main
le_rx:
Serin dado
contador = contador + 1
ASM:   movf   dado,w
ASM:   movwf  indf
ASM:   incf   fsr,f
Goto main
'******************************************Fim************************************************   
End

Link simulação Proteus:http://rapidshare.com/files/172023453/Hardlook.zip.html

At.
_Lince_

[dogflu66]

Software feito por quem não tem oque fazer.

 , pues esta muy bien... un poco escueto en comentarios 

[MiCrOtRoNiC]

alguien ah probado la version 6.70...trae mejoras con respecto al compilador....?en la pagina oficial no aclaran muy bien

Código: [Seleccionar]

News in version 6.70
- Improved timing issues for LCD routines in basic compiler
- Improved timing issues for GLCD routines in basic compiler
- Software version, microcontroller model and clock frequency saved in ASM files generated by basic compiler
- Improved Alternative SFR Viewer
- Changed order of items in Tools and Options menus
- Several small and/or invisible improvements


[dogflu66]

Aparte que los programas son ahora 2 Bytes más largos, no observo ningún fallo, siguen funcionando igual de bien.

Según parece que a quitado algún tiempo muerto en las funciones de los lcd’s. Ahora en el editor del Basic se puede leer en la cabecera el PIC y frecuencia que estas utilizando. Algún problema a la hora de mostrar los SFR, problema que yo no  he visto jamás.
Y ha ordenado las herramientas y configuraciones en los menús de una forma más cómoda.