Esta placa incluye un sensor de presión atmosférica de alta precisión -BMP180- con un rango de medida de 300 y 1100hPa (Hecto Pascal) con un margen de error de 0,03hPa. Basado en tecnología piezorresistiva de alta eficiencia y larga duración. El sensor tiene un rango de alimentación de 1,8 V y 3,6 V CC. Diseñado para conectarse directamente a un microcontrolador a través de una interfaz I2C. Tiene 2 resistencias pull-up de 4.7Kohm. Este tipo de sensores se pueden utilizar para calcular la altitud, por lo que son muy útiles en los UAV. Especificaciones: - Dimensiones: 21 x 18 mm - Potencia: 1.8V a 6V -Velocidad máxima I2C: 3,5 MHz - Bajo consumo de energía - 0.5uA a 1 Hz - Interfaz I2C - Bajo nivel de ruido - hasta 0,02 hPa (17 cm) - Rango de Presión: 300hpa a 1100hPa (+ -500m a 9000m) #incluir #define BMP085_ADDRESS 0x77 // Dirección I2C de BMP085 const char sin signo OSS = 0; // Configuración de sobremuestreo // valores de calibración intac1; intac2; intac3; int sin firmar ac4; int sin firmar ac5; int sin firmar ac6; intb1; intb2; int mb; intmc; int md; // b5 se calcula en bmp085GetTemperature(...), esta variable también se usa en bmp085GetPressure(...) // entonces ...Temperature(...) debe llamarse antes que ...Pressure(...). largo b5; configuración vacía(){ Serial.begin(9600); Alambre.begin(); bmp085Calibración(); } bucle vacío () { temperatura flotante = bmp085GetTemperature(bmp085ReadUT()); //DEBE ser llamado primero presión de flotación = bmp085GetPressure(bmp085ReadUP()); flotador atm = presión / 101325; // "atmósfera estándar" altitud de flotación = calcAltitude(presión); //Cálculo no compensado - en Metros Serial.print("Temperatura: "); Serial.print(temperatura, 2); //muestra 2 decimales Serial.println("grados C"); Serial.print("Presión: "); Serial.print(presión, 0); //solo numero entero. Serial.println("Pa"); Serial.print("Atmósfera estándar: "); Serial.println(atm, 4); //mostrar 4 decimales Serial.print("Altitud: "); Serial.print(altitud, 2); //muestra 2 decimales Serial.println("M"); Serial.println();//salto de línea retraso (1000); //espera un segundo y vuelve a obtener valores. } // Almacena todos los valores de calibración del bmp085 en variables globales // Se requieren valores de calibración para calcular la temperatura y la presión // Esta función debe llamarse al principio del programa void bmp085Calibración() { ac1 = bmp085ReadInt(0xAA); ac2 = bmp085ReadInt(0xAC); ac3 = bmp085ReadInt(0xAE); ac4 = bmp085ReadInt(0xB0); ac5 = bmp085ReadInt(0xB2); ac6 = bmp085ReadInt(0xB4); b1 = bmp085ReadInt(0xB6); b2 = bmp085ReadInt(0xB8); mb = bmp085ReadInt(0xBA); mc = bmp085ReadInt(0xBC); md = bmp085ReadInt(0xBE); } // Calcular la temperatura en grados C float bmp085GetTemperature(sin firmar int ut){ largo x1, x2; x1 = (((largo)ut - (largo)ac6)*(largo)ac5) >> 15; x2 = ((largo)mc b5 = x1 + x2; temperatura flotante = ((b5 + 8)>>4); temperatura = temperatura /10; temperatura de retorno; } // Calcular la presión cedida // los valores de calibración deben ser conocidos // También se requiere b5, por lo que se debe llamar primero a bmp085GetTemperature(...). // El valor devuelto será la presión en unidades de Pa. bmp085GetPressure largo (largo sin firmar){ largo x1, x2, x3, b3, b6, p; sin signo largo b4, b7; b6 = b5 - 4000; // Calcular B3 x1 = (b2 * (b6 * b6)>>12)>>11; x2 = (ac2 * b6)>>11; x3 = x1 + x2; b3 = (((((largo)ac1)*4 + x3)>2; // Calcular B4 x1 = (ac3 * b6)>>13; x2 = (b1 * ((b6 * b6)>>12))>>16; x3 = ((x1 + x2) + 2)>>2; b4 = (ac4 * (largo sin signo)(x3 + 32768))>>15; b7 = ((largo sin signo)(arriba - b3) * (50000>>OSS)); si (b7 p = (b7 si no p = (b7/b4) x1 = (p>>8) * (p>>8); x1 = (x1 * 3038)>>16; x2 = (-7357 * p)>>16; p += (x1 + x2 + 3791)>>4; temperatura larga = p; temperatura de retorno; } // Leer 1 byte del BMP085 en 'dirección' char bmp085Read (dirección de caracteres sin firmar) { datos de caracteres sin firmar; Wire.beginTransmission(BMP085_ADDRESS); Wire.write(dirección); Cable.endTransmission(); Wire.requestFrom(BMP085_ADDRESS, 1); while(!Cable.disponible()) ; volver Alambre.read(); } // Leer 2 bytes del BMP085 // El primer byte será de 'dirección' // El segundo byte será de 'dirección'+1 int bmp085ReadInt (dirección de caracteres sin firmar) { char sin firmar msb, lsb; Wire.beginTransmission(BMP085_ADDRESS); Wire.write(dirección); Cable.endTransmission(); Wire.requestFrom(BMP085_ADDRESS, 2); while(Cable.disponible() ; msb = Cable.read(); lsb = Cable.read(); devolver (int) msb} // Leer el valor de temperatura no compensado int sin firmar bmp085ReadUT(){ sin firmar int ut; // Escribe 0x2E en el Registro 0xF4 // Esto solicita una lectura de temperatura Wire.beginTransmission(BMP085_ADDRESS); Alambre.escribir(0xF4); Alambre.escribir(0x2E); Cable.endTransmission(); // Espere al menos 4,5 ms retraso (5); // Lee dos bytes de los registros 0xF6 y 0xF7 ut = bmp085ReadInt(0xF6); volver a salir; } // Leer el valor de presión no compensado largo sin firmar bmp085ReadUP(){ caracteres sin firmar msb, lsb, xlsb; unsigned long up = 0; // Escriba 0x34+(OSS // Solicite una lectura de presión con configuración de sobremuestreo Wire.beginTransmission(BMP085_ADDRESS); Alambre.escribir(0xF4); Wire.write(0x34 + (OSS Wire.endTransmission(); // Espere la conversión, el tiempo de demora depende del OSS delay(2 + (3 // Leer registro 0xF6 (MSB), 0xF7 (LSB) y 0xF8 (XLSB) msb = bmp085Read(0xF6); lsb = bmp085Read(0xF7); xlsb = bmp085Read(0xF8); arriba = (((largo sin firmar) msb > (8-OSS); volver arriba; } void writeRegister(int deviceAddress, byte address, byte val) { Wire.beginTransmission(dirección del dispositivo); // inicia la transmisión al dispositivo Wire.write(dirección); // enviar dirección de registro Alambre.escribir(val); //enviar valor a escribir Cable.endTransmission(); // finaliza la transmisión } int readRegister(int deviceAddress, byte address){ En televisión; Wire.beginTransmission(dirección del dispositivo); Wire.write(dirección); // registrarse para leer Cable.endTransmission(); Wire.requestFrom(dirección del dispositivo, 1); // lee un byte while(!Cable.disponible()) { // espera } v = Alambre.read(); volver v; } float calcAltitude(presión de flotación){ flotador A = presión/101325; flotador B = 1/5,25588; float C = pow(A,B); C = 1 - C; C = C /0,0000225577; devolver C; }
Módulo lector de tarjetas SD para controladores, Arduino, ARM, MCU, etc... leer y escribir. Aumenta la cantidad de memoria en tus proyectos, de forma sencilla. Normalmente se utiliza para robótica, creación de modelos, arduino, etc. , o cualquier proyecto de electrónica Características El módulo de tarjeta SD puede hacer que su aplicación sea más simple y fácil Se conecta fácilmente como periférico a su módulo Arduino A través de la programación, puede leer y escribir en la tarjeta SD a través de su Arduino La tarjeta SD se puede usar más fácilmente controlando el sistema ARM, reproductor de MP3, MCU Todos los pines de salida SD SPI, MOSI, SCK, MISO y CS. Admite varios voltajes de entrada de 5 V/3,3 V
Características Tensión de alimentación: 1,9 V a 3,6 V Banda ISM: 2,4 GHz Velocidad de datos: 2Mbps Operación de muy baja potencia. Potencia de salida: 11,3 mA TX a 0 dBm Potencia a una velocidad de datos de 2 Mbps: 12,3 mA RX Apagado: 900nA En espera 22 µA en espera-I ShockBurst™ avanzado Compatible con nRF2401A, 02, E1 y E2 Alcance de hasta 100 metros sin obstáculos
Módulo sensor de vibraciones, formado por un muelle y una pequeña varilla en su interior, de manera que cada vez que el sensor sea sometido a una vibración, se disparará su salida. Es muy útil en proyectos como alarmas sísmicas, alarmas para autos y motos, sistemas activados por vibración, análisis de vibraciones en máquinas. Puede ser utilizado en ambientes industriales, su forma encapsulada tiene cierta resistencia al polvo y al agua. Potencia: 3.3V a 5V Dimensiones: 40,7x16,7 mm Peso: 5g Tipo de E/S: Digital Voltaje de suministro: 3.3V a 5V Tamaño: 40,7*16,7mm Peso: 5g Código de muestra #define SensorLED 13 #define SensorINPUT 3 //Conecte el sensor al Pin digital 3 que es Interrupciones 1. estado de caracteres sin firmar = 0; configuración vacía () { pinMode(SensorLED, SALIDA); pinMode(SensorENTRADA, ENTRADA); adjuntar Interrupción (1, parpadeo, FALLING);// Activar la función de parpadeo cuando se detecta el borde descendente } bucle vacío () { si (estado! = 0) { estado = 0; escritura digital (LED del sensor, ALTO); retraso (500); } demás escritura digital (LED del sensor, BAJO); } void blink()//Interrumpe la función { estado++; }
No disponible en stock,
pergunte-nos o prazo de entrega
- Potencia: 3.3V a 5V - Detección: intensidad del sonido - Interfaz: Analógico - Dimensiones: 30x20mm - Peso: 4g Código de muestra configuración vacía () { Serial.begin(9600); // abrir el puerto serie, establecer la velocidad de transmisión en 9600 bps } bucle vacío () { valor int; val=analogRead(0); // conecta el sensor del micrófono a Analógico 0 Serial.println(val,DEC);//imprime el valor del sonido en el monitor serie retraso (100); }
No disponible en stock,
pergunte-nos o prazo de entrega
Este sensor táctil es un tipo de interruptor táctil capacitivo basado en la detección táctil IC TTP223B. Normalmente, la salida es de nivel bajo (en modo de bajo consumo). Cuando el dedo toque la ubicación correspondiente, la salida será alta (modo de velocidad rápida). Cuando el módulo no se toca durante 12 segundos, el módulo cambia al modo de bajo consumo. Se puede instalar en el módulo, como plástico, vidrio, superficie de material no metálico. Solo tienes que tocar la posición correcta. Puedes ocultarlo en paredes, oficinas y otras partes con botones. Permite eliminar los problemas de los pulsadores convencionales Especificaciones: Voltaje de suministro: 3.3V a 5V Interfaz: Digital Tamaño: 30x20mm Peso: 3g Código de muestra pin led int = 13; // Conecte el LED en el pin 13, o use el integrado int CLAVE = 2; // Conecte el sensor táctil en el pin digital 2 configuración vacía(){ pinMode(ledPin, SALIDA); // Establecer ledPin en modo de salida pinMode(CLAVE, ENTRADA); //Establece el pin del sensor táctil en modo de entrada } bucle vacío(){ if(digitalRead(KEY)==HIGH) { //Leer la señal del sensor táctil escritura digital (pin led, ALTO); // si el sensor táctil es ALTO, entonces enciéndalo } demás{ digitalWrite(ledPin, BAJO); // si el sensor táctil es BAJO, entonces apague el led } }
El detector de inclinación es equivalente a un interruptor y se utiliza como entrada digital. Cuando este nivel es el contacto está abierto. Cuando se dobla, se cierra. Especificaciones: Tensión de alimentación: 3,3 V a 5 V Interfaz: Digital Tamaño: 30*20mm Peso: 3g Código de muestra pin led int = 13; // Conectar el LED al pin 13 conmutador int = 3; // Conectar el sensor de inclinación al Pin3 configuración vacía () { pinMode(ledPin, SALIDA); // Establece el pin digital 13 en modo de salida pinMode(conmutador, ENTRADA); // Establece el pin digital 3 en modo de entrada } bucle vacío () { if(digitalRead(switcher)==HIGH) //Leer valor del sensor { escritura digital (pin led, ALTO); // Enciende el LED cuando el sensor está inclinado } demás { digitalWrite(ledPin, BAJO); // Apaga el LED cuando el sensor no se activa } }
El DHT-22 es un dispositivo de bajo costo para medir la humedad y la temperatura. Los sensores DHT tienen dos partes. Un sensor de humedad capacitivo y un termómetro. El dispositivo necesita una fuente de alimentación de 3 a 5 V. Utiliza una sola línea de datos para comunicarse con el Arduino. Características: - Potencia: 3-5V CC - Consumo: 2,5mA máximo - Humedad de trabajo: 0-100% - Temperatura de trabajo: -40º a 80ºC (resolución 0,5ºC) - Dimensiones: 27x59x13,5mm - Conexiones: Pines Código de muestra: // Esquema de ejemplo para humedad DHT22 - sensor de temperatura 2 // Escrito por cactus.io, con agradecimiento a Adafruit por fragmentos de su biblioteca. dominio publico 3 4 #incluye "cactus_io_DHT22.h" 5 6 #define DHT22_PIN 2 // a qué pin del arduino está conectada la línea de datos DHT22 7 8 // Para obtener detalles sobre cómo conectar el sensor DHT22 al Arduino, consulte esta página 9 // http://cactus.io/hookups/sensors/temperature-humidity/dht22/hookup-arduino-to-dht22-temp-humidity-sensor 10 11 // Inicializa el sensor DHT para Arduino normal de 16 MHz. 12 DHT22 DHT (DHT22_PIN); 13 // Nota: si está utilizando una placa con un procesador más rápido que 16 MHz, entonces necesita 14 // para declarar una instancia de DHT22 usando 15 // DHT22 DHT(DHT22_DATA_PIN, 30); 16 // El parámetro adicional, en este caso aquí es 30 se usa para aumentar el número de 17 // ciclos de transición entre bits en las líneas de datos y de reloj. Para el 18 // Las placas Arduino que funcionan a 84 MHz, el valor de 30 debería ser correcto. 18 19 configuración vacía(){ 20 Serie.begin(9600); 21 Serial.println("DHT22 Humedad - Sensor de temperatura"); 22 Serial.println("RHtTemp (C)tTemp (F)tHeat Index (C)tHeat Index (F)"); 23 24 dht.begin(); 25 } 26 27 bucle vacío(){ 28 // ¡Leer la temperatura o la humedad toma alrededor de 250 milisegundos! 29 // Las lecturas del sensor también pueden tener hasta 2 segundos de antigüedad (es un sensor muy lento) 30 dht.readHumedad(); 31 dht.leerTemperatura(); 32 33 // Comprobar si alguna lectura falló y salir antes (para volver a intentarlo). 34 if (isnan(dht.humedad) || isnan(dht.temperature_C)) { 35 Serial.println("¡Error de lectura del sensor DHT!"); 36 devoluciones; 37 } 38 39 Serial.print(dht.humedad); Serial.imprimir(" %tt"); 40 Serial.print(dht.temperature_C); Serial.imprimir(" *Ct"); 41 Serial.print(dht.temperature_F); Serial.imprimir(" *Ft"); 42 Serial.print(dht.computeHeatIndex_C()); Serial.imprimir(" *Ct"); 43 Serial.print(dht.computeHeatIndex_F()); Serial.println(" *F"); 44 45 // Espere unos segundos entre mediciones. El DHT22 no debe leerse a una frecuencia mayor de 46 // aproximadamente una vez cada 2 segundos. Así que agregamos un retraso de 3 segundos para cubrir esto. 47 retraso (3000); 48 }
Admite 12 entradas analógicas y, dado que se emula el puerto de comunicación USB, ¡deja libre el puerto serie del hardware para la programación! De esta forma, ya no se producen conflictos de programación mientras tengamos periféricos serie conectados a la placa. Características: - Microcontrolador: ATmega32u4 - Voltaje de funcionamiento: 5V - Voltaje de entrada (recomendado): 7-12V - Voltaje de entrada (límites): 6-20V - Pines de E/S digitales: 20 - Canales PWM: 7 - Canales de entrada analógica: 12 - Corriente CC por pin de E/S: 40 mA - Corriente CC a pin de 3,3 V: 50 mA - Memoria flash: 32 KB (ATmega32u4) de los cuales 4 KB son utilizados por el gestor de arranque -SRAM: 2,5 KB (ATmega32u4) - EEPROM: 1KB (ATmega32u4) - Velocidad: 16MHz
