# Programar un servo con un 16F84



## tjdor (Nov 12, 2008)

Pues es eso, mi pregunta, quiero hacer un preograma para controlar un servo con un 16F84.

Quiero que mi programa gire un grado, espere un momento, gire otro, espere...
Pero no se como hacer el programa, mi idea es crear un retardo fijo de 300us que me hace mantener en servo en cero grados junto con un retardo de 19,7ms.

Pues eso mi idea para hacer el programa es tener una variable que me haga tener un numero de ciclos en cada grado, otra que se vaya incrementando que me llame a otra subrutina de 10us, y otra que se vaya decrementando y me vaya restando los 10us correspondientes a cada grado.

como veis el programa?, algun fallo de concepto o algo que tener en cuenta?


----------



## DMag00 (Nov 13, 2008)

Revisa este link

Es un proyecto con sun Servo Futaba S3003

https://www.forosdeelectronica.com/f24/llave-electronica-pic-16f877-16637/

Tu idea es buena; es algo similar a lo que realice.

El programa funciona fisicamente, pero me falta afinar el aumento y disminucion de grados cada 10us.


----------



## tjdor (Nov 16, 2008)

Muchas gracias DMag00, pero veo un problema mas, veo que esta programado en C, yo demomento solo se programar PIC's en MPLab


----------



## Moyano Jonathan (Nov 16, 2008)

emplab con un plugin , es compatible con ccs para editar , simular y debugear programas en c. Ahora si a lo que te referís es a que solamente sabés assembler , te dejo este ejemplo de control sacado del libro pic16f84a desarrollo de proyectos:


----------



## gemetzelgott (Nov 24, 2008)

Mira este es un pequeño programa que realize con el pic 16f84a que controla un servomotor mediante el timer0, el codigo esta en C, aunque el C Compiler tine la herramienta de pasar Assembler, de todos modos te mando el codigo en los 2 lenguajes.

Primero en C:


```
#include <16f84a.h>
#use  delay(clock=4000000)
#byte portb= 0x06
#bit  rb0= 0x06.0

int cont, var; 
 
 #int_timer0
 interr()
 {
  cont++;
  if(cont>var)
  {
   rb0=0;
  }
  else
  rb0=1;
  if(cont>200)
  {
  cont=0;
  }
 } 
 void main()
 {
  set_tris_b(0);
  portb=0;
  cont=0;
  setup_timer_0(rtcc_internal);
  enable_interrupts(int_rtcc);
  enable_interrupts(GLOBAL);
  set_timer0(100);
  while(1)
  {
   for(var=0;var<22;var++)
   {
    delay_ms(300);
   }
  }
 }
```

Ahora en Assembler:



```
ROM used: 128 words (12%)
                         Largest free fragment is 896
               RAM used: 17 (25%) at main() level
                         18 (26%) worst case
               Stack:    2 worst case (1 in main + 1 for interrupts)

*
0000:  MOVLW  00
0001:  MOVWF  0A
0002:  GOTO   05F
0003:  NOP
0004:  BTFSC  03.5
0005:  GOTO   00A
0006:  MOVWF  11
0007:  SWAPF  03,W
0008:  MOVWF  12
0009:  GOTO   00F
000A:  BCF    03.5
000B:  MOVWF  11
000C:  SWAPF  03,W
000D:  MOVWF  12
000E:  BSF    12.1
000F:  MOVF   0A,W
0010:  MOVWF  19
0011:  CLRF   0A
0012:  BCF    03.7
0013:  SWAPF  11,F
0014:  MOVF   04,W
0015:  MOVWF  13
0016:  MOVF   0C,W
0017:  MOVWF  14
0018:  MOVF   0D,W
0019:  MOVWF  15
001A:  MOVF   0E,W
001B:  MOVWF  16
001C:  MOVF   0F,W
001D:  MOVWF  17
001E:  MOVF   10,W
001F:  MOVWF  18
0020:  BCF    03.5
0021:  BTFSS  0B.5
0022:  GOTO   025
0023:  BTFSC  0B.2
0024:  GOTO   03A
0025:  MOVF   13,W
0026:  MOVWF  04
0027:  MOVF   14,W
0028:  MOVWF  0C
0029:  MOVF   15,W
002A:  MOVWF  0D
002B:  MOVF   16,W
002C:  MOVWF  0E
002D:  MOVF   17,W
002E:  MOVWF  0F
002F:  MOVF   18,W
0030:  MOVWF  10
0031:  MOVF   19,W
0032:  MOVWF  0A
0033:  SWAPF  12,W
0034:  MOVWF  03
0035:  BCF    03.5
0036:  SWAPF  11,W
0037:  BTFSC  12.1
0038:  BSF    03.5
0039:  RETFIE
.................... #include <16f84a.h> 
.................... //////// Standard Header file for the PIC16F84A device //////////////// 
.................... #device PIC16F84A 
.................... #list 
....................  
.................... #use  delay(clock=4000000) 
*
004A:  MOVLW  1D
004B:  MOVWF  04
004C:  BCF    03.7
004D:  MOVF   00,W
004E:  BTFSC  03.2
004F:  GOTO   05E
0050:  MOVLW  01
0051:  MOVWF  0D
0052:  CLRF   0C
0053:  DECFSZ 0C,F
0054:  GOTO   053
0055:  DECFSZ 0D,F
0056:  GOTO   052
0057:  MOVLW  4A
0058:  MOVWF  0C
0059:  DECFSZ 0C,F
005A:  GOTO   059
005B:  GOTO   05C
005C:  DECFSZ 00,F
005D:  GOTO   050
005E:  GOTO   07A (RETURN)
.................... #byte portb= 0x06 
.................... #bit  rb0= 0x06.0 
....................  
.................... int cont, var;  
....................   
....................  #int_timer0 
....................  interr() 
....................  { 
....................   cont++; 
*
003A:  INCF   1A,F
....................   if(cont>var) 
003B:  MOVF   1A,W
003C:  SUBWF  1B,W
003D:  BTFSC  03.0
003E:  GOTO   041
....................   { 
....................    rb0=0; 
003F:  BCF    06.0
....................   } 
....................   else 
0040:  GOTO   042
....................   rb0=1; 
0041:  BSF    06.0
....................   if(cont>200) 
0042:  MOVF   1A,W
0043:  SUBLW  C8
0044:  BTFSC  03.0
0045:  GOTO   047
....................   { 
....................   cont=0; 
0046:  CLRF   1A
....................   } 
....................  }  
0047:  BCF    0B.2
0048:  BCF    0A.3
0049:  GOTO   025
....................  void main() 
....................  { 
*
005F:  CLRF   04
0060:  BCF    03.7
0061:  MOVLW  1F
0062:  ANDWF  03,F
....................   set_tris_b(0); 
0063:  MOVLW  00
0064:  TRIS   6
....................   portb=0; 
0065:  CLRF   06
....................   cont=0; 
0066:  CLRF   1A
....................   setup_timer_0(rtcc_internal); 
0067:  BSF    03.5
0068:  MOVF   01,W
0069:  ANDLW  C0
006A:  MOVWF  01
....................   enable_interrupts(int_rtcc); 
006B:  BCF    03.5
006C:  BSF    0B.5
....................   enable_interrupts(GLOBAL); 
006D:  BSF    0B.7
....................   set_timer0(100); 
006E:  MOVLW  64
006F:  MOVWF  01
....................   while(1) 
....................   { 
....................    for(var=0;var<22;var++) 
0070:  CLRF   1B
0071:  MOVF   1B,W
0072:  SUBLW  15
0073:  BTFSS  03.0
0074:  GOTO   07E
....................    { 
....................     delay_ms(300); 
0075:  MOVLW  02
0076:  MOVWF  1C
0077:  MOVLW  96
0078:  MOVWF  1D
0079:  GOTO   04A
007A:  DECFSZ 1C,F
007B:  GOTO   077
....................    } 
007C:  INCF   1B,F
007D:  GOTO   071
....................   } 
007E:  GOTO   070
....................  } 
007F:  SLEEP

Configuration Fuses:
   Word  1: 3FF3   RC NOWDT PUT NOPROTECT
```

por ultimo te mando la simulacion en proteus.


----------



## Micky95 (Dic 3, 2012)

gemetzelgott dijo:


> Mira este es un pequeño programa que realize con el pic 16f84a que controla un servomotor mediante el timer0, el codigo esta en C, aunque el C Compiler tine la herramienta de pasar Assembler, de todos modos te mando el codigo en los 2 lenguajes.
> 
> Primero en C:
> 
> ...



oye disculpa y si quisiera mover 3 servos?? lo que pasa es que quiero mover un brazo y soy nuevo en esto de la programacion en c, en que cambiaria la programacion?


----------

