|
|
The ky-38 sound sensor is a very basic sound level detector module which features an electric condenser microphone. It is part of a sensor kit that can be purchased and the main part of the module is an LM393 comparator. There are 2 LEDs on board, one is for power and the other indicates when the sensor reaches a certain value
The board has 2 outputs
- AO, analog output, real-time output voltage signal of the microphone
- DO, when the sound intensity reaches a certain value, the output goes high
The sensitivity can be adjusted via the potentiometer on the module
Here is a schematic of the module
Connection
This is the basic connection of the Ky-038 module to an Arduino Uno
Basic Example
int soundPin = A0;
int sensorValue = 0;
void setup ()
{
Serial.begin (9600);
}
void loop ()
{
sensorValue = analogRead (soundPin);
Serial.println (sensorValue, DEC);
delay (1000);
}Output
Open the serial monitor and make noise near the microphone, you should values – the higher the value the louder the noise
165
28
27
29
27
16
228
Another Example
This example will switch on the on board Arduino LED if the analog value exceeds 200.
int soundPin = A0;
int ledPin = 13;
int sensorValue = 0;
void setup ()
{
Serial.begin (9600);
pinMode (ledPin, OUTPUT);
}
void loop ()
{
sensorValue = analogRead (soundPin);
Serial.println (sensorValue, DEC);
//if sensor goes above max light led (could be buzzer)
if(sensorValue > 200)
{
digitalWrite (ledPin, HIGH);
delay (1000);
}
//switch off LED
digitalWrite (ledPin, LOW);
delay (1000);
}
Links
A very low cost module, comes in under $0.50
KY-038 4pin Mini Voice Sound Detection Sensor Module Microphone Transmitter
The set of sensors cost about $10
37 IN 1 sensor kit for Arduino starter kit high-quality (Works with Arduino Boards) landzo
On this page we look at Scratch for Arduino – s4a. We will be using a Keyestudio board which contains a variety of LEDs and analog inputs for testing.
Scratch is a basic environment for learning development, you drag and drop blocks onto the interface to create your ‘program’, if coding is not your thing then this is ideal for simple projects. Its also a nice way to introduce the Arduino to kids without again delving into the more complex programming side of things
First s4a
You need to install the Arduino IDE and upload the firmware – http://s4a.cat/downloads/S4AFirmware16.ino. You then need to download the s4a from http://s4a.cat/ – http://s4a.cat/downloads/S4A16.zip. Extarct the zip file and install s4A
Hardware
We used a Ks0189 keyestudio Scratch for Arduino Starter Kit which is a neat development board that you can fit an Arduino Nano to. Here is a picture of the board
Here is some blurb regarding the board
keyestudio Robotale Scratch is used with an Arduino Nano. Using the Scratch programming language, you can easily create simple interactive programs with Arduino or create programs based on the input of Arduino from sensors. keyestudio Robotale Scratch incorporates a light sensor, sound sensor, a button and a slider, as well as 4 additional inputs that can sense electrical resistance via cables. Designed for educators and beginners, the keyestudio Robotale Scratch is a good way to get into the very basics of programming and reading sensors.
Examples
You will need to start s4a and then drag the blocks like the image below to flash the LED connected to D13 on and off
This example will blink all 3 LEDs on and off
Summary
A nice and easy starting block for learning, the board comes in at $12 (you can get a kit for about $20 with the board, Arduino Nano clone, USB cable, mounting board and some analog connectors). This in my opinion is a low cost setup for the young kids to learn about the Arduino and a gentle intro to electronics
One cool thing about s4a is there a feedback area in the IDE which shows analog pin values and 2 digital values, you can see this here
If you toggle the slider, press the buttons, vary the light and make some noise on the Keyestudio board you will see the values change
Links
Keyestudio Scratch kit for Arduino Starter with Scratch board + PDF datasheet
In this post we take a look at cayenne – https://cayenne.mydevices.com/cayenne/signup
This is the blurb from the website
Easy IoT with myDevices Cayenne
Features Include:
- Remote access your Pi from your mobile phone or computer
- Remote commands (reboot, shutdown, remote access)
- Add sensors, actuators, and extensions and create a custom dashboard with drag and drop widgets
- Monitor data and remote control your devices and projects
- Remote control sensors/actuators with the dashboard GPIO
- Easily set up triggers and actions for your automation projects
I like this site as there are many clear examples for Arduino boards and various ways of connecting, my setup was a an Arduino Uno with an Ethernet Shield fitted to it. I decided to add a BMP180 sensor to the ethernet shield as a test example – there is actually an example for this in the github repo – https://github.com/myDevicesIoT/Cayenne-MQTT-Arduino
Connection
 ethernet and bmp180 Code
The default code for the bmp180 is shown, you need to fill in the appropriate details in the authentication section.
This example needs 3 libraries. The Cayenne library, Adafruit BMP085 Unified and Adafruit Sensor library. You can find all of these in the library manager
#define CAYENNE_PRINT Serial // Comment this out to disable prints and save space
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085_U.h>
#include <CayenneMQTTEthernet.h>
// Cayenne authentication info. This should be obtained from the Cayenne Dashboard.
char username[] = "MQTT_USERNAME";
char password[] = "MQTT_PASSWORD";
char clientID[] = "CLIENT_ID";
#define TEMPERATURE_VIRTUAL_CHANNEL 1
#define BAROMETER_VIRTUAL_CHANNEL 2
Adafruit_BMP085_Unified bmp = Adafruit_BMP085_Unified(10180);
bool bmpSensorDetected = true;
void setup()
{
Serial.begin(9600);
Cayenne.begin(username, password, clientID);
if (!bmp.begin())
{
CAYENNE_LOG("No BMP sensor detected");
bmpSensorDetected = false;
}
}
void loop()
{
Cayenne.loop();
}
// This function is called at intervals to send temperature sensor data to Cayenne.
CAYENNE_OUT(TEMPERATURE_VIRTUAL_CHANNEL)
{
if (bmpSensorDetected)
{
float temperature;
bmp.getTemperature(&temperature);
// Send the value to Cayenne in Celsius.
Cayenne.celsiusWrite(TEMPERATURE_VIRTUAL_CHANNEL, temperature);
}
else
{
CAYENNE_LOG("No BMP sensor detected");
}
}
// This function is called at intervals to send barometer sensor data to Cayenne.
CAYENNE_OUT(BAROMETER_VIRTUAL_CHANNEL)
{
if (bmpSensorDetected)
{
// Send the command to get data.
sensors_event_t event;
bmp.getEvent(&event);
if (event.pressure)
{
// Send the value to Cayenne in hectopascals.
Cayenne.hectoPascalWrite(BAROMETER_VIRTUAL_CHANNEL, event.pressure);
}
}
else
{
CAYENNE_LOG("No BMP sensor detected");
}
}
Output
Once connected your dashboard should show some data, I renamed them.
You can see a chart symbol, clicking on that will display a pop up chart of data, here is what my data looked like. You can also download chart data in csv format and as you can see you can show various date filters of data
In this example we will write to the EEPROM which is on the micro controller of the Arduino
The supported micro-controllers on the various Arduino and Genuino boards have different amounts of EEPROM: 1024 bytes on the ATmega328P, 512 bytes on the ATmega168 and ATmega8, 4 KB (4096 bytes) on the ATmega1280 and ATmega2560. The Arduino and Genuino 101 boards have an emulated EEPROM space of 1024 bytes.
This example illustrates how to store values read from analog input 0 into the EEPROM using the EEPROM.write() function. A little about EEPROM first
EEPROM (also E2PROM) stands for Electrically Erasable Programmable Read-Only Memory and is a type of non-volatile memory used in computers, integrated in microcontrollers for smart cards and remote keyless system, and other electronic devices to store relatively small amounts of data but allowing individual bytes to be erased and reprogrammed.
EEPROMs are organized as arrays of floating-gate transistors. EEPROMs can be programmed and erased in-circuit, by applying special programming signals. Originally, EEPROMs were limited to single byte operations which made them slower, but modern EEPROMs allow multi-byte page operations. It also has a limited life for erasing and reprogramming, now reaching a million operations in modern EEPROMs. In an EEPROM that is frequently reprogrammed while the computer is in use, the life of the EEPROM is an important design consideration.
Flash memory is a type of EEPROM designed for high speed and high density, at the expense of large erase blocks (typically 512 bytes or larger) and limited number of write cycles (often 10,000). There is no clear boundary dividing the two, but the term “EEPROM” is generally used to describe non-volatile memory with small erase blocks (as small as one byte) and a long lifetime (typically 1,000,000 cycles). Many microcontrollers include both: flash memory for the firmware, and a small EEPROM for parameters and history. – https://en.wikipedia.org/wiki/EEPROM
Codebender
Code
/*
* EEPROM Write
*/
#include <EEPROM.h>
/** the current address in the EEPROM **/
int addr = 0;
void setup()
{
}
void loop()
{
/*
Need to divide by 4 because analog inputs range from
0 to 1023 and each byte of the EEPROM can only hold a value from 0 to 255.
*/
int val = analogRead(0) / 4;
/*
Write the value to fthe EEPROM.
*/
EEPROM.write(addr, val);
/*
Advance to the next address, when at the end restart at the beginning.
*/
addr = addr + 1;
if (addr == EEPROM.length()) {
addr = 0;
}
delay(100);
}
|
Subscribe to Arduinolearning via Email
|
