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:











practica 2

En esta práctica se utilizara el programa arduino como principio para poder iniciar nuestro curso de programacion. lo que se se va a hacer sera prender y apagar un foco LED.

Materiales:

- Arduino Uno
-LED
-Cable USB

codigo:

void setup (){
//put your setup code here,to run once:
pinMode(13,OUTPUT);//declaro el pin de salida
}
void loop(){
//put your main code here, to run repeatedly;
digitalWrite(13,HIGH);
delay(1500);//espere 1500 milisegundos  .5 segundos
digitalWrite(13,LOW);
delay(1500)