martes, 5 de diciembre de 2017

Práctica 16

En esta práctica conoceremos el funcionamiento del servomotor y los usos de este mismo. Este sensor solo se mueve por grados así que conoceremos cuales son estos. 

Materiales:

-Arduino
-Protoboard
-Motor reductor 
-Potenciometro 50k ohm
-Cable Dupont 

Código:

#include<Servo.h>
Servo myServo;
int const PotPin=A5;
int PotVal;
int angle;
void setup(){
myServo.attach(9);
Serial.begin(9600);
}
void loop(){
PotVal=analogRead(PotPin);
Serial.print("PotVal:");
Serial.print(PotVal);
angle=map(PotVal,0,1023,0,179);
Serial.print ("angle= ");
Serial.println (angle);
myServo.write(angle);
delay (15);
}

                                           



                                                   



Práctica 15

Vamos a realizar una práctica en la cual utilizaremos el LED RGB  que es el que tiene la capacidad de cambiar su color de iluminación. Aprenderemos a como programarlo y poder obtener su amplia variedad de colores. 

Materiales: 

-Arduino
-Protoboard
-LED RGB
-Cable Dupont
- 3 resistencias de 220 ohm

Código: 

#define pinLed1 11 // Pin 11 a R
#define pinLed2 10 // Pin 10 a G
#define pinLed3 9 // Pin 10 a B
void setup()
{
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
}
void loop() {
// Verde
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
delay(500);
// Azul
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, HIGH);
delay(500);

digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
delay(500);
//Violeta
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, HIGH);
delay(500);
//Amarillo
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
delay(500);
//Azul Marino
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
delay(500);
//Blanco
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
delay(500);
// Negro 
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
delay(500);
}

                                         


                                       











Práctica 14

para esta práctica veremos el funcionamiento de un motor a pasos y sus principales usos, de igual manera lo compararemos con el motor DC.

Materiales: 

-Arduino
-Protoboard
-Motor a pasos
-Cables Dupont
-1 UNL2003.

Codigo:

int retardo=5;          // Tiempo de retardo en milisegundos (Velocidad del Motor)
int dato_rx;            // valor recibido en grados
int numero_pasos = 0;   // Valor en grados donde se encuentra el motor
String leeCadena;       // Almacena la cadena de datos recibida

void setup() {               
Serial.begin(9600);     // inicializamos el Monitor serial
pinMode(11, OUTPUT);    // Pin 11 conectar a IN4
pinMode(10, OUTPUT);    // Pin 10 conectar a IN3
pinMode(9, OUTPUT);     // Pin 9 conectar a IN2
pinMode(8, OUTPUT);     // Pin 8 conectar a IN1
}

void loop() {
  while (Serial.available()) {    // Leer el valor enviado por el Monitor serial
    delay(retardo);
    char c  = Serial.read();     // Lee los caracteres
    leeCadena += c;              // Convierte Caracteres a cadena de caracteres
  } 
  if (leeCadena.length()>0){      
        dato_rx = leeCadena.toInt();   // Convierte Cadena de caracteres a Enteros
         Serial.print(dato_rx);         // Envia valor en Grados
         Serial.println(" Grados");
        delay(retardo);
        dato_rx = (dato_rx * 1.4222222222); // Ajuste de 512 vueltas a los 360 grados
  } 

   while (dato_rx>numero_pasos){   // Girohacia la izquierda en grados
       paso_izq();
       numero_pasos = numero_pasos + 1;
   }
   while (dato_rx<numero_pasos){   // Giro hacia la derecha en grados
        paso_der();
        numero_pasos = numero_pasos -1;
   }
  leeCadena = "";   // Inicializamos la cadena de caracteres recibidos
  apagado();         // Apagado del Motor para que no se caliente
}

void paso_der(){         // Pasos a la derecha
 digitalWrite(11, LOW);
 digitalWrite(10, LOW); 
 digitalWrite(9, HIGH); 
 digitalWrite(8, HIGH); 
   delay(retardo);
 digitalWrite(11, LOW);
 digitalWrite(10, HIGH); 
 digitalWrite(9, HIGH); 
 digitalWrite(8, LOW); 
   delay(retardo);
 digitalWrite(11, HIGH);
 digitalWrite(10, HIGH); 
 digitalWrite(9, LOW); 
 digitalWrite(8, LOW); 
  delay(retardo);
 digitalWrite(11, HIGH);
 digitalWrite(10, LOW); 
 digitalWrite(9, LOW); 
 digitalWrite(8, HIGH); 
  delay(retardo); 
}

void paso_izq() {        // Pasos a la izquierda
 digitalWrite(11, HIGH);
 digitalWrite(10, HIGH); 
 digitalWrite(9, LOW); 
 digitalWrite(8, LOW); 
  delay(retardo);
 digitalWrite(11, LOW);
 digitalWrite(10, HIGH); 
 digitalWrite(9, HIGH); 
 digitalWrite(8, LOW); 
  delay(retardo);
 digitalWrite(11, LOW);
 digitalWrite(10, LOW); 
 digitalWrite(9, HIGH); 
 digitalWrite(8, HIGH); 
  delay(retardo);
 digitalWrite(11, HIGH);
 digitalWrite(10, LOW); 
 digitalWrite(9, LOW); 
 digitalWrite(8, HIGH); 
  delay(retardo);
}
       
void apagado() {         // Apagado del Motor
 digitalWrite(11, LOW);
 digitalWrite(10, LOW); 
 digitalWrite(9, LOW); 
 digitalWrite(8, LOW); 
 }














Práctica 13

Para esta práctica seguiremos utilizando el sensor ultrasonico para medir la distancia solo que en este caso vamos a utilizar tambien la pantalla LCD para ver los resutados en ella. 

Materiales:
- Arduino
-Protoboard
-Sensor ultrasonico
-Pantalla LCD
-Cable Dupont
-Potenciometro 

codigo: 

#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
const int EchoPin = 3;
const int TriggerPin = 5;
const int LedPin = 13;
void setup() {
  Serial.begin(9600);
  lcd.begin(16,2);
  pinMode(LedPin, OUTPUT);
  pinMode(TriggerPin, OUTPUT);
  pinMode(EchoPin, INPUT);
}

void loop() {
  int cm = ping(TriggerPin, EchoPin);
  Serial.print("Distancia: ");
  Serial.println(cm);
  delay(1000);
  lcd.write("Distancia");
lcd.setCursor(0,1);
lcd.write("d= ");
lcd.print(cm);
lcd.write(" cm");
}
int ping(int TriggerPin, int EchoPin) {
  long duration, distanceCm;
  digitalWrite(TriggerPin, LOW); //para generar un pulso limpio  ponemos a LOW 4us
  delayMicroseconds(4);
  digitalWrite(TriggerPin, HIGH); //generamos Trigger (disparo)  de 10us
  delayMicroseconds(10);
  digitalWrite(TriggerPin, LOW);
  duration = pulseIn(EchoPin, HIGH); //medimos el tiempo ent  re pulsos, en microsegundos
  distanceCm = duration * 10 / 292 / 2; //convertimos a dist  ancia, en cm
  return distanceCm;
}
















Práctica 12

Para esta práctica vamos a utilizar el sensor de temperatura LM35 y utilizaremos el monitor serial para ver los datos que se obtuvieron, nuevamente utilizaremos la pantalla LCD para observar los datos en ella. 

Material:

-Arduino 
-Protoboard
-Sensor LM35
-Pantalla LCD
-Cables Dupont 

Codigo: 

float tempC; // Variable para almacenar el valor obtenido del sensor (0 a 1023)
int pinLM35 = A0; // Variable del pin de entrada del sensor (A0)
void setup() {
// Configuramos el puerto serial a 9600 bps
Serial.begin(9600);
}
void loop() {
// Con analogRead leemos el sensor, recuerda que es un valor de 0 a 1023
tempC = analogRead(pinLM35);
// Calculamos la temperatura con la fórmula
tempC = (5.0 * tempC * 100.0)/1024.0;
// Envia el dato al puerto serial
Serial.print(tempC);
// Salto de línea
Serial.print("\n");
// Esperamos un tiempo para repetir el loop
delay(1000);
}



                                          










lunes, 4 de diciembre de 2017

Práctica10

para esta practica utilizaremos el sensor PIR, el cual es un  sensor de movimiento y observaremos como es su funcionamiento.


Materiales:

- ArduinoUno
-Protoboard
-Cables Dupont 
-Sensor PIR
-LED

Codigo: 

const int led = 13 ;
const int sensor = 2 ;
void setup() {
pinMode( led , OUTPUT) ; pinMode (sensor , INPUT);
}
void loop() {
if (digitalRead( sensor)) digitalWrite( led , HIGH);
else
digitalWrite( led , LOW);
}

fotos: 





Pr'actica 10.1

En esta practica se va a realizar lo mismo que en la anterior pero la unica diferencia sera que se le integrara un buzzer para cuando el sensor PIR detecte un movimiento se escuche una alarma.  

materiales: 

- ArduinoUno
-Protoboard
-Cables Dupont 
-Sensor PIR
-LED
- Sensor PIR 

Codigo: 

int ledPin = 4;
int piezoBuzzerPin = 3;
int pirSensorPin = 2;
int mociondetectado = LOW; 
void setup() {
pinMode(ledPin, OUTPUT); 
pinMode(pirSensorPin, INPUT); 
pinMode(piezoBuzzerPin, OUTPUT); 
Serial.begin(9600); 
delay(5000); 
}
void loop(){
mociondetectado = digitalRead(pirSensorPin);
if(mociondetectado == HIGH)
{
digitalWrite(ledPin, HIGH);
analogWrite(piezoBuzzerPin, 200);
delay(100);
analogWrite(ledPin, LOW);
analogWrite(piezoBuzzerPin, 25);
delay(100);
}
digitalWrite(ledPin, LOW);
digitalWrite(piezoBuzzerPin,LOW);





    
                                    
                               







      








martes, 21 de noviembre de 2017

Práctica 11

Para esta práctica se utilizara un servo motor y se conocera sus funcionamientos y sus tipos de usos
Materiales:
- ArduinoUno
-motor de corriente directa
-Transistor PN2222
-LED
-Resistencia de 300 ohm
Código:
Voidsetup()
{
pinMode(9,OUTPUT);
}
Void loop () {
digitalWrite(9,HIGH);
delay(1000);
digitalWrite(9,LOW);
delay(1000);
}




Práctica 11.1

Para esta práctica utilizaremos una pantalla LCD  en la cual conoceremos su funcionamiento y sus pines. le vamos a integrar un potenciometro con el cual vamos a podificar la intesidad de a luz de la pantalla.

Materiales: 
-Arduino
-protoboard
-Pantalla LCD
-Potenciometro
-Resistencia 200 ohm

Codigo: 

#include <LiquidCrystal.h>;
LiquidCrystal lcd( 12 , 11 , 5 , 4 , 3 , 2 ) ;
void setup ( )
{
  lcd.begin ( 16 , 2 );
  lcd.print ( "Informática Aeroespacial" );
 }
void loop ( )
{
 lcd.setCursor ( 0 , 1 );
 lcd.print ( millis ( ) / 1000 );
 }





                                         




domingo, 22 de octubre de 2017

Práctica 9

En esta práctica vamos a seguir utilizando la variable map pero ahora lo que realizara mediante un potenciometro sera regular la luz de un LED. Lo que hace el potenciometro es limitar el paso de la corriente eléctrica

Materiales:

- ArduinoUno
-Protoboard
-Cable USB
-Potenciometro
-Cables Dupont
-LED
-Resistencia de 220 ohm

Código:

// Declaramos las constantes que vamos a usar
const int pinSensor = 0; // pin del sensor analogico, con
un potenciometro
const int pinLed = 9; // pin con el led, tiene pwm
// Declaramos las variables que vamos a usar
int brilloLed = 0; // variable para guardar el valor
con el que se iluminara el led
int valorPotenciometro = 0; // variable para guardar el
valor leido del sensor
void setup() {
// Incializa el pin del boton como entrada
pinMode(pinSensor, INPUT);
// Incializa el pin del led como salida, aunque no es
necesario
pinMode(pinLed, OUTPUT);


void loop() {
// Lee el valor del sensor
valorPotenciometro = analogRead(pinSensor);
// Transforma este valor en el valor que
usaremos para el led
// Para ello usaremos la funcion map()
brilloLed = map(valorPotenciometro, 0, 1023,
0, 255);
// Utilizamos este valor para iluminar el led
analogWrite(pinLed, brilloLed);
// manda los valores por el serial
Serial.print("Valor del Potenciometro = ");
Serial.print(valorPotenciometro);
Serial.print(" Brillo del Led = ");
Serial.println(brilloLed);
delay(100);
}

Foto:




Vídeo:

Práctica 9.1

para esta práctica vamos a crear un piano utilizando pulsadores y un altavoz piezoelectrico que es el que generara las notas musicales ( Do,Re,Mi,Fa,Sol,La,Si).

Materiales:

-AruduinoUno
-Cable USB
-Protobord
-Botones
-Altavoz piezoelectrico
-7 resistencias de 10 k ohm
- 1 resistencia de 100 ohm

Código:
// se declaran las frecuencia de las notas básicas
const int NOTA_DO = 262;
const int NOTA_RE = 294;
const int NOTA_MI = 330;
const int NOTA_FA = 349;
const int NOTA_SOL = 392;
const int NOTA_LA = 440;
const int NOTA_SI = 494;
// se declaran los pines asociados a las notas básicas
const int pulsador_DO = 8;
const int pulsador_RE = 7;
const int pulsador_MI = 6;
const int pulsador_FA = 5;
const int pulsador_SOL = 4;
const int pulsador_LA = 3;
const int pulsador_SI = 2;
// se define las notas que se reproducirán
int notas_basicas[ ] = {NOTA_DO, NOTA_RE, NOTA_MI,
NOTA_FA, NOTA_SOL, NOTA_LA, NOTA_SI};
int pulsadores [ ] = {pulsador_DO, pulsador_RE, pulsa
dor_MI, pulsador_FA,
pulsador_SOL, pulsador_LA, pulsad
or_SI};
int pulsador_activado = 0;

void setup() {
// se define los pines de entrada y salida
for(int pin=6; pin>0; pin--) {
pinMode(pulsadores[pin] , INPUT);
}
}
void loop() {
int pulsador_actual; // se declara como variable local
// el bucle analiza el estado de los 7 pulsadores
for (int pulsador=0; pulsador<7; pulsador++) {
pulsador_actual = digitalRead(pulsadores[pulsador]);
// se lee el estado del pulsador
// si se presiono, se procede a reproducir la nota
asociada
if (pulsador_actual == HIGH) {
tone(13, notas_basicas[pulsador]); // reproduce
la nota
// grabamos el pulsador que ha sido apretado
pulsador_activado = pulsadores[pulsador];
break;
}
}
// su soltamos el pulsador activo apagamos cortamos
el sonido
if (digitalRead(pulsador_activado) == LOW) {
noTone(13);
}
}

Foto:


Vídeo:






Práctica 8

En esta parte del blog aprenderemos a como programar un altavoz piezoeléctrico y un sensor LDR que pueda encender y apagar un LED. para este ejercicio utilizaremos la variable #define.

Materiales:

-ArduinoUno
-Protoboard
-Cable USB
- Altavoz piezoeléctrico
-Resistencia 10 k ohm
- Resistencia de 220 ohm
-Cable Dupont
- LED
-LDR

Código:

#define PIEZO 7
 int del=10;
 void setup() {
 // put your setup code here, to run once:
 pinMode(PIEZO,OUTPUT);
 }
 void loop() {
 // put your main code here, to run repeatedly:
analogWrite(PIEZO,255);
 delay(del);
 analogWrite(PIEZO,0);
delay(10);
 }

Foto:


Vídeo:
https://www.youtube.com/watch?v=trCBFowJLiw



Práctica 8.1
en esta práctica utilizaremos los pines analogicos

int led = 10;
int analog = 0;
int valor;
void setup(){}
void loop() {
valor = analogRead(analog);
valor /= 4;
analogWrite(led, valor);

Vídeo:

https://www.youtube.com/watch?v=W_pp2hgu6fA

Práctica 8.2
Para esta práctica vamos a observar como los pines análogos aumentan y disminuyen su intensidad y para poder observar esto utilizaremos un LED.
int led = 13;
int boton = 7;
int valor = 0;
void setup() {
pinMode(led, OUTPUT);
pinMode(boton, INPUT);
void loop() {
valor = digitalRead(boton);
digitalWrite(led, valor);

Vídeo:

https://www.youtube.com/watch?v=-cY3xJ3fGn4

Práctica 8.3

para esta parte de la práctica utilizaremos un sensor LDR. un LDR es una resistencia que varia su valor en función de la luz recibida.usaremos la variable map.

Código:

int lightPin = 2; // Pin para la fotoresistencia
int ledPin=11; // Pin al que se conecta el LED
void setup()
{
Serial.begin(9600); // Inicia la comunicacion serie
pinMode( ledPin, OUTPUT ); // Establece el pin del LED
// como salida
}
void loop()
{
Serial.println(analogRead(lightPin));
analogWrite(ledPin, analogRead(lightPin)/4);
delay(100);
}

Vídeo:

https://www.youtube.com/watch?v=gXiWVG4mT7s









Práctica 7

En esta práctica veremos una nueva forma de programar mas sencilla, utilizaremos las matrices y las arrays.

Materiales:

-ArduinoUno
-Cable USB
-Protoboard
-6 LEDS
-Cables Dupont
-6 resistencias 220 ohm

Código:

int pinArray[] = {2, 3, 4, 5, 6, 7};
int count = 0;
int timer = 100;
void setup(){
for (count=0;count<6;count++)
{
pinMode(pinArray[count], OUTPUT);
}
}
void loop() {
for (count=0;count<6;count++)
{
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer);
}
for (count=5;count>=0;count--)
{
digitalWrite(pinArray[count], HIGH);
delay(timer);
digitalWrite(pinArray[count], LOW);
delay(timer);
}

Foto:

















Práctica 6

Lo que veremos en esta práctica sera el como manipular la intensidad de un LED con un algoritmo.

Materiales:

-Protoboard
-ArduinoUno
-cable USB
-LED
-Resistencia 220 ohm
-Cable Dupont

Código:

Int led=9;
Int brillo =0;
Int aumento = 9;
void setup(){
pinMode (Led, OUTPUT);
}
void loop(){
analogWrite(Led, brillo);
brillo= brillo+aumento;
if (brillo ==0 || brillo == 255)
{
aumento = -aumento;
}
delay(30)
}

Foto:




Video:

https://www.youtube.com/watch?v=PpuRonQ7t0A











Práctica 5

Para esta práctica se realizaron 2 ejercicios mas. En esta ocación realizaremos un algoritmo que nos permita encender un LED con un botón 

Materiales:
- 3 LED ( uno por cada ejercicio)
-protoboard
-ArduinoUno
-cables Dupont
-resistencias de 220 ohm y 10 K ohm
- boton (pulsador)
- cable USB

Código:

int LED =13;intBOTON = 7;
 void setup() {
 pinMode(LED,OUTPUT); // establecer que el pin digital es una señal de salida pinMode(BOTON,INPUT); // y BOTON como señal de entrada
 }
 void loop(){
 if (digitalRead (BOTON) == HIGH)
 { digitalWrite(LED,HIGH); delay(2500);
digitalWrite(LED,LOW);
 }
 }

Foto:






Video:



Práctica 5.1

En esta parte de la práctica se realizara lo mismo pero con la diferencia de que ahora se tiene que apagar por 2 segundos al presionar el pulsador y se vuelva a encender. 

Código:

int LED =13;intBOTON = 7;
 void setup() {
 pinMode(LED,OUTPUT); // establecer que el pin digital es una señal de salida pinMode(BOTON,INPUT); // y BOTON como señal de entrada
 }
 void loop(){
 if (digitalRead (BOTON) == HIGH)
 { digitalWrite(LED,HIGH);
 delay(2000); 
digitalWrite(LED,LOW);
 }
 }

Práctica 5.2

para la ultima práctica se va  a realizar lo mismo que en la numero 5 solo que en esta ocación vamos a utilizar mas LEDS.

Código:

int LED = 13;
int BOTON = 7;
int LED1 = 12;
int BOTON1 = 8;
void setup() {
  // put your setup code here, to run once:
  pinMode(LED, OUTPUT); // establecer que el pin digital es una señal de salida
  pinMode(BOTON, INPUT); // y BOTON como señal de entrada
  pinMode(LED1, OUTPUT); // establecer que el pin digital es una señal de salida
  pinMode(BOTON1, INPUT); // y BOTON como señal de entrada
}
void loop() {
  // put your main code here, to run repeatedly:
  if (digitalRead (BOTON) == HIGH)
  {
    digitalWrite(LED, LOW);
    delay(2000);
    digitalWrite(LED, HIGH);
  }
  if (digitalRead (BOTON1) == HIGH)
  {
    digitalWrite(LED1, LOW);
    delay(2000);
    digitalWrite(LED1, HIGH);
  }
}

Foto:























práctica 4

El día de hoy presentare una practica con las bases de la número 3, pero para esta utilizaremos 6 LEDS y utilizaremos un nuevo código que es el "código For"

Materiales:

- protoboard
-cable USB
-AruinoUno
-6 LEDS
-cables Dupont
-6 resistecnias de 1K ohm

Código:

void setup(){
pinMode(13 ,OUTPUT);
pinMode( 12,OUTPUT);
pinMode( 11,OUTPUT);
pinMode( 10,OUTPUT);
pinMode( 9,OUTPUT);
pinMode( 8,OUTPUT);
}
VOID LOOP(){
digitalWrite(13,HIGH);
delay(1500);
digitalWrite(13,LOW);
delay(1500);
digitalWrite(12,HIGH);
delay(1500);
digitalWrite(12,LOW);
delay(1500);
digitalWrite(11,HIGH);
delay(1500);
digitalWrite(11,LOW);
delay(1500);
digitalWrite(10,HIGH);
delay(1500);
digitalWrite(10,LOW);
delay(1500);
digitalWrite(9,HIGH);
delay(1500);
digitalWrite(9,LOW);
delay(1500);
digitalWrite(8,HIGH);
delay(1500);
digitalWrite(8,LOW);
delay(1500);
}

codigo con For:

void setup(){
pinMode(13 ,OUTPUT);
pinMode( 12,OUTPUT);
pinMode( 11,OUTPUT);
pinMode( 10,OUTPUT);
pinMode( 9,OUTPUT);
pinMode( 8,OUTPUT);
}
void loop(){
For(int pin=8;pin<14;pin + )
{digitalWrite(pin,HIGH);
delay(2500);
digitalWrite(pin,LOW);
delay(2500);
}
}

Foto:




















miércoles, 18 de octubre de 2017

Glosario

Arduino:
Arduino es una plataforma de prototipos electrónica de código abierto basada en un hardware y un software fáciles de usar.

Setup ():
contiene la primer declaración de las variables al inicio del programa. es la primera función que se ejecuta en el programa.

loop () : la función loop incluye el código que se va a ejecutar. esta función es el núcleo de todo el programa Arduino y realiza la mayor parte del trabajo. puede leer entradas, activar salidas y mucho mas.
Funciones: las funciones son un bloque de código que tiene un nombre y un grupo de declaraciones que se ejecutan cuando se llama  la función.
se escriben para ejecutar tareas repetitivas y reducir la desorganización  que hay en un programa.

Llaves {}: las llaves van al comienzo y al final de bloques de función y bloques de declaración. las llaves deben de estar balanceadas porque si no provocan errores de compilación.

Punto y coma ";": se deben de usar al final de las declaraciones, separan los elementos del programa. si se olvida colocarlos generan un error de compilación.

Bloques de comentarios " /*....*/": sirven para ayudar a otras personas a entender partes del programa

Comentarios de linea //:  los comentarios de linea se utilizan para proporcionar mas información sobre lo que lleva la declaración y también para proporcionar un recordatorio  futuro. van después de declaraciones validas .

Tipos de datos simples:

Void: indica "nada". es una variable sin tipo definido

- numéricos:

Entero:  int
Real:  float
Real con doble precisión:  double

Modificadores:

Signed: reserva un bit para el signo
Unsigned: define solo valores positivos
 Long: utiliza el mayor tamaño disponible
 Short: utiliza el menor tamaño disponible

Matrices: es una colección de variables  a las que se puede acceder con un numero de indice.

Potenciometro: limitan el paso de la corriente eléctrica

LDR:   es una resistencia que varia su valor en función de la luz recibida, cuanta mas luz recibe, menor es su resistencia

Map: a permite convertir un rango de variación en otro con toda sencillez.

digitalWrite: Envía al pin definido previamente como OUTPUT el valor HIGH o LOW (poniendo a 1 ó 0 la salida).


lunes, 16 de octubre de 2017

Práctica 3





En esta practica veremos lo mismo que en la anterior solo que ahora utilizando 3 focos LED para generar una serie luminosa en la que tendrá tiempo de apagado del LED y el tiempo de encendido. Por primera vez utilizaremos lo que es un protoboard.

Materiales:

- 3 LED
- cable USB
-un protoboard
-ArduinoUno
-cables Dupont
-3 resistencias de 1K ohm

Código:

Void setup () {
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
pinMode(11,OUTPUT);
}
voidloop(){
digitalwrite(13,HIGH);
delay(2500);
digitalwrite(13,LOW);
delay(2500);
digitalwrite(12,HIGH);
delay(2500);
digitalwrite(12,LOW);
delay(2500);
digitalwrite(11,HIGH);
delay(2500);
digitalwrite(11,LOW);
delay(2500);
}

fotos:





Video: