C Programa Enconder con control de velocidad y el interruptor DIP

Cómo escribir un programa en C Enconder con control de velocidad y el interruptor DIP en el lenguaje de programación C ?

Solution:

1.         PRÁCTICA "ENCODER CON VARIACION DE VELOCIDAD y DIPSWITCH ”
2.  
3. //Constantes que no cambiaran
4. const int botonPin = 11;        // Numero del pin donde se encuentra el botón para iniciar el proceso
5. int sensorPin = 12;             // Numero del pin donde se encuentra el sensor de barrera
6. int motor= 13;                  // Numero del pin donde se encuentra conectado el motor
7. int potenciometro=A0;           // Numero del pin donde se encuentra el potenciometro
8.  
9. //Declaracion de variables que cambiaran
10. int botonState=LOW;            //El estado actual del botón es bajo
11. int motorstate=LOW;            //El estado actual del motor es bajo
12. int estadoanterior=HIGH;       //Estado anterior del sensor    
13. int estado=HIGH;               //Estado actual del sensor
14. int cuenta=0;                  //Cuenta el numero de veces que el sensor cambia de estado
15. int contando=0;                //Variable contando inicia en cero
16. int dipswitch;                 //Declaramos la variable  "dipswitch"
17. int valor;                     //Inicializamos la variable "valor"
18.  
19. void setup() {
20.  
21.   DDRD=B11111100;               //Configuramos el puerto D para declarar las entradas y salidas en binario
22.   pinMode(botonPin, INPUT);     //Declaramos el pin 11 como entrada
23.   pinMode(motor, OUTPUT);       //Declaramos el pin 13 como salida
24.   pinMode(sensorPin, INPUT);    //Declaramos el pin 12 como entrada
25.   analogRead (potenciometro);   //Lectura de potenciómetro
26.   digitalWrite(motor,motorstate);   //Escribimos el valor de motorstate en el pin motor
27.   Serial.begin (9600);          /* Establecemos la velocidad de datos en bits por
28.                                  segundo para la transmisión de datos en serie */
29.  
30. }
31.  
32. void loop() {
33.  
34.  
35.  
36.   int leer= digitalRead(botonPin);    //A la variable leer asignamos la lectura del botonPin
37.   dipswitch= PIND & 0b11111100;       //A la variable dipswitch asignamos la lectura del puerto D y le asignamos valores binarios
38.  
39.   if(leer==HIGH)                      //Si leer esta en alto o 5v
40.  
41.   { do                                //Creamos un ciclo do while
42.   {
43.  
44.  
45.       valor=analogRead(potenciometro);    //A la variable valor le asignamos la lectura de potenciometro
46.       valor=map(valor, 0,1023,0,255);     //A la variable valor le asignamos un pwm
47.       analogWrite(motor, valor);          //En la variable motor escribimos el dato "valor"
48.      
49.      
50.    
51.     contando=digitalRead(sensorPin);   // A la variable contando le asignamos la lectura del pin del sensor
52.     if (contando != estadoanterior)    //Hacemos la condicion de cuando contando sea diferente a estado anterior....
53.     {
54.      estado=contando;                  //A estado le asignamos el valor de estado
55.      estadoanterior=estado;            // Al estado anterior se le asigna el valor de estado
56.     if (contando==HIGH)                // Si el valor del pin del sensor se encuentra en un valor alto....
57.     { Serial.print ("pot: ");          //Imprime "pot"
58.       Serial.println (valor);          //Imprime la velocidad del motor
59.       Serial.print ("dipswitch: ");    //Imprime "dipswitch"
60.       Serial.println (dipswitch);      //Imprime el número que elijamos con el dipswitch
61.       Serial.print ("Ranura: ");       //Imprime "Ranura"
62.       Serial.println (cuenta);         //Imprime los datos de cuenta, es decir el numero de ranuras que han pasado por el sensor
63.       cuenta=cuenta+1;}                //La cuenta irá aumentando de uno en uno
64.     }
65.      
66.   } while(cuenta<dipswitch);           // El ciclo terminara hasta que cuenta sea igual al número de ranuras
67.  
68.   digitalWrite(motor, LOW);            // Apagamos el motor
69.     cuenta=0;                          // El valor de cuenta regresa a cero
70.    
71.   }
72.  
73. }

Programa C para eliminar un elemento de la pila i

Cómo escribir un programa C para eliminar un elemento de la pila i en el lenguaje de programación C ?

Solución:

1. /*  Eliminar un elemento de la pila i */
2. void pop(stack *pila, int cantPilas, int i)
3. {
4.         int ele;
5.         printf("\nIngrese el elemento entero a eliminar: ");
6.         scanf("%d", &ele);
8.         if(!isempty(pila, i))
9.         {
10.                 int pos = pila->base[i], valor_actual; 
11.                
12.                 // Encontrar la POS donde esta el elemento, si es que existe
13.                 while(pos != pila->tope[i]+1)
14.                 {
15.                         valor_actual = pila->R[pos];
16.                         if(valor_actual == ele)
17.                         {
18.                                 printf("Se econtro elemento en la pos: %d\n", pos);
19.                                 system("pause");
20.                                 break;
21.                         }
22.                         pos++;
23.                 }
24.                
25.                 // Vaciar la pila[i] hasta la posicion para ser eliminado a un aux
26.                 int k, aux[MAX];
27.                 for(k=0; k< pos; k++)
28.                 {
29.                        
30.                 }
31.                
32.                 // Pasar de el aux a la pila[i], sobreescribirlo de alguna forma la wea culia
33.         }
34.        
35.         else
36.                 printf("\nPILA VACIA\n");
37.        
38.         system("pause");
39. }

Motor de control C Velocidad Programa DC

Cómo escribir un motor de control C Velocidad Programa DC en lenguaje de programación C ?

Solution:

1. const int buttonPin=8;     // El boton pulsador se declara como la entrada 8 del pin del Arduino
2. const int sensorPin=3;     // El pin numero 3 hace referencia al sensor de barrera
3.  
4. int motorPin=5;      // Utilizamos el pin 5 para declarar al motor
5. const int pot=0; //entrada analogica del arduino  A0
6. int buttonState = LOW; // Estado del boton pulsador
7. const int A=2;  //  Entradas del dip Swicht
8. const int B=6;
9. const int C=7;
10. const int D=9;
11. const int E=10;
12. const int F=11;
13. const int G=12;
14. const int H=13;
15. int i=0;
16. int suma=0;
17. int velocidad=0;
18. int contador=0;
19. int aux=0;
20. int Vueltas=0;
21.  
22. void setup()
23. {
24.   pinMode(motorPin, OUTPUT);// Pin de salida del motoreductor
25.   pinMode(buttonPin, INPUT);// Pin de entrada del boton pulsador
26.   digitalWrite(buttonPin,HIGH);//Se energiza el boton pulsador
27.   pinMode(sensorPin, INPUT);
28.   Serial.begin(9600);
29.  
30. }
31.  
32. void loop()
33. {
34.   buttonState = digitalRead(buttonPin);
35.    //Serial.println(buttonState);
36.  
37.   if(buttonState==HIGH)
38.   {
39.     buttonState = HIGH;
40.      entrada_binaria();
41.    
42.        
43.       do
44.       {
45.      
46.           pwm();//Se activa la funcion PWM
47.           contador=digitalRead(sensorPin);
48.           if(contador==HIGH)
49.              {
50.                 if (aux==0)
51.                 {
52.                   Serial.println(suma);
53.                   suma=suma+1;
54.                 }
55.                 aux=1;
56.              }
57.              if(contador==LOW)
58.              {
59.                aux=0;
60.              }
61.              if(suma==Vueltas)
62.              {
63.               Serial.println(suma);
64.               analogWrite(motorPin,0);
65.               digitalWrite(motorPin,LOW);
66.               suma=0;
67.               buttonState=LOW;
68.              }
69.    
70.          
71.            
72.       }
73.       while(buttonState==HIGH);
74.    
75.   }    
76. }
77. void pwm()//Para controlar la velocidad del motor se realiza la division entre 4 del valor de 1023
78. {
79.   int velocidad=0;
80.   velocidad=analogRead(pot);//toma valores de 0 a 1023
81.   velocidad=velocidad/4;//ajustamos el valor del por para poder usar el PWM
82.   analogWrite(motorPin,velocidad);//valores entre 0 y 255 mando el valor a el motor
83.    //Serial.println ("Valor del PWM:");
84.   //Serial.println(velocidad);
85. }
86. void entrada_binaria() // En esta parte del void se le asignan valores para cada boton del dip
87. {
88.   Vueltas=0;
89.          if(digitalRead(A)==HIGH)
90.        {
91.         Vueltas=Vueltas+10;
92.        }
93.         if(digitalRead(B)==HIGH)
94.        {
95.         Vueltas=Vueltas+20;
96.        }
97.          if(digitalRead(C)==HIGH)
98.        {
99.         Vueltas=Vueltas+40;
100.        }
101.         if(digitalRead(D)==HIGH)
102.        {
103.         Vueltas=Vueltas+80;
104.        }
105.         if(digitalRead(E)==HIGH)
106.        {
107.         Vueltas=Vueltas+160;
108.        }
109.         if(digitalRead(F)==HIGH)
110.        {
111.         Vueltas=Vueltas+320;
112.        }
113.        if(digitalRead(G)==HIGH)
114.        {
115.         Vueltas=Vueltas+640;
116.        }
117.           if(digitalRead(H)==HIGH)
118.        {
119.         Vueltas=Vueltas+1280;
120.        }
121.        //Serial.println ("No. Vueltas :");
122.        //Serial.println(Vueltas);
123. }