-
Notifications
You must be signed in to change notification settings - Fork 139
/
render.cpp
138 lines (113 loc) · 4.43 KB
/
render.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/*
____ _____ _ _
| __ )| ____| | / \
| _ \| _| | | / _ \
| |_) | |___| |___ / ___ \
|____/|_____|_____/_/ \_\
http://bela.io
*/
/**
\example Sensors/LDR/render.cpp
Using light as a controller
---------------------------
This example demonstrates how to hook up a Light Dependent Resistor
(LDR), also know as a photo-resistor, and use it to control the
volume of white noise. If you run this project straight away
after connecting up the LDR you will notice that the LDR reacts
to changes in the light condition but in a pretty unsatisfying way.
This is because we need to set the thresholds of the `map()` function
based on the ambient light condition.
To begin let's connect the LDR.
- connect one leg of the LDR to 3.3V
- connect the other leg of the LDR to analog input 1
- connect one leg of a 10KOhm resistor to this leg of the LDR as well
- connect the other leg of the resistor to ground
The resistance of the LDR changes depending on the amount of light
it receives (more light -> less resistance). To measure this change in
resistance we need a fixed value resistor (10kOhms in this example) to
compare the reading with. This is know as a voltage divider circuit.
The 3.3V will be shared between the two resistors: how much of a share
of voltage each of the resistors take is proportional to their
resistances. As the resistance of the LDR changes the amount of voltage
on each resistor changes and we can measure this change to tell how
much light the LDR is receiving.
In order to use the LDR as a volume control we need to set the thresholds
for ambient light and for when it has a bright light shone close to it.
To do this comment out this section of code in `render()`:
````
if(!n%2){
if(gSampleCount >= 44100) {
rt_printf("%f\n", analogRead(context, n, 1));
gSampleCount = 0;
}
}
gSampleCount++;
````
This prints the value of the LDR reading to the console once a second.
Now you can set the variables `gDark` and `gLight` with the reading
of ambient light in the room and with the reading when a torch is
shone directly at the LDR. Update the variables, re-comment out the code and
run the example. Now you should be able to bring the white noise from
silence to full volume depending on the amount light.
Note that when you cover the LDR you should also hear an increase in
volume of the white noise. This is because the `map()` function is not
constrained which means that it outputs negative number when it gets
darker than the threshold set in `gDark`. To stop this behaviour you
can use the `constrain()` function to force the LDR readings to remain
within a certain range (for example `gDark` to `gLight`).
*/
#include <Bela.h>
#include <stdlib.h>
float gLDR;
float gNoise;
// replace these values with thresholds for dark and light
float gDark = 0.0;
float gLight = 1.0;
// sample counter to print current LDR reading
int gSampleCount = 0;
int gAudioFramesPerAnalogFrame = 0;
bool setup(BelaContext *context, void *userData)
{
if(!context->analogInChannels)
{
fprintf(stderr, "Error: This example requires analog inputs to be enabled");
return false;
}
if(context->analogSampleRate > context->audioSampleRate)
{
fprintf(stderr, "Error: for this project the sampling rate of the analog inputs has to be <= the audio sample rate\n");
return false;
}
if(context->analogFrames)
gAudioFramesPerAnalogFrame = context->audioFrames / context->analogFrames;
return true;
}
void render(BelaContext *context, void *userData)
{
for(unsigned int n = 0; n < context->audioFrames; n++) {
if(gAudioFramesPerAnalogFrame && !(n % gAudioFramesPerAnalogFrame)) {
// read and map the LDR
gLDR = map(analogRead(context, n, 1), gDark, gLight, 0.0, 0.5);
}
/*
// Uncomment the below code to print the LDR reading to the console
// to set the thresholds
if(!n%2){
if(gSampleCount >= 44100) {
rt_printf("%f\n", analogRead(context, n, 1));
gSampleCount = 0;
}
}
gSampleCount++;
*/
// generate some noise with random number generator
gNoise = 0.1f * ( rand() / (float)RAND_MAX * 2.f - 1.f);
for(unsigned int channel = 0; channel < context->audioOutChannels; channel++) {
// output the noise multiplied by the LDR reading
audioWrite(context, n, channel, gNoise*gLDR);
}
}
}
void cleanup(BelaContext *context, void *userData)
{
}