-
Notifications
You must be signed in to change notification settings - Fork 0
/
notes.txt
196 lines (163 loc) · 11.2 KB
/
notes.txt
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
Arduino on breadboard with 32.768 KHz crystal
CKSEL[3:0] = 0010 (Use internal RC oscillator as the clock)
This should be set by the "Arduino on Breadboard" board model.
C_e = 2(12.5) - 6 = 19 pF external capacitors required when using crystal as timer oscillator
(Can try 22 or 15.)
Arduino as ISP -- need to use adafruit's fork and connect pin 9 to pin 9 to provide a clock signal
Slide detection: Just using this to detect movement out of the OFF position, the comparator
threshold may need to be adjusted if the stop size is adjusted significantly. 50 mV seems like a
reasonable starting point. Except that the bottom of the slide isn't really zero, at least on the
pot side that I fried. The other one actually looks OK. It will be nicer to have a larger "OFF"
area anyway so it's harder to turn it on by accident, so I will make that stop larger. And this
threshold needs to actually be something that registers as a stop so you can't end up in an "ON"
state that just drains the battery. You need to know it's on if it's using power. The circuit is a
voltage divider, so the threshold is a percentage of the input voltage. The first stop (where the
buzzer goes off) is currently at 3% of the total voltage, so that's what the voltage divider will
do. So this DEFINITELY needs to be adjusted if the stops are changed.
I tried to avoid possible bad states by having the software always be in "ringing" state when the
slider is below the first stop and just let the state of the power switch circuit override this. So,
if the power switch is in the "off" position, the timer is always actually powered down. However,
this doesn't work. It would make it possible for the motor, when moving the slider to stop zero, to
actually turn off the timer. In other words, when the timer reaches zero, it could just turn itself
off immediately and never ring. Bad idea! The big advantage of the current implementation (treating
OFF as a stop and only shutting down once that stop is reached) is that a human must actually move
the slider to that position before the timer will go off, which is the desired behavior.
How to fix it:
- Stops at fixed intervals, except OFF and ZERO, which should be further apart (wider). This means
division to figure out which stop we're at instead of binary search
- Treat the value coming from the ADC as having some precision (e.g. +/- 2), only do something if
it changes by more than the precision
- Each stop should have a "size" for the purpose of positioning the slider. Once the slider gets
within that range once (currentStop == nextStop), don't move it any more unless it actually goes
to a different stop (either from the stopwatch or because the user moved it)
- Be explicit about the mode we're in, possibly based on what interrupt woke us up
- For the timer, just see if it's time to move to the next stop
- For the ADC, just do the position handling (differently when currentStop == nextStop, as above)
Alarm:
- Getting the melody to work is a pain. The tone() libary seems to use Timer2, which we are already
using. Timer1 would be better. Also, need to decide if we can sleep (and for how long) while the
timer is going off. Don't want to misread a position.
- The buzzer just doesn't sound good. Going to try a speaker. It should actually be easier to play a
sound that way using this library:
https://github.com/TMRh20/AutoAnalogAudio/blob/master/examples/SimpleSine/SimpleSine.ino
Here are the calculations from http://www.electronics-tutorials.ws/amplifier/amp_2.html for the
amplifier circuit assuming a 2N5551 transistor and a 1V drop across the speaker:
V_RE = 3V (5V supply, 1V for speaker, 1V for transitor, so 3V left to drop)
I_C_MAX = (5V - 3V) / 8Ω = 250mA
I_C_Q = ((5V - 3V) / 2) / 8Ω = 125mA
I_B = 125mA / 150 = 833µA
R2 = (3V + 1V) / (10 * 833µA) = 480Ω (470)
R1 = (5V - 4V) / (11 * 833µA) = 109Ω (100)
I_E = 125mA + 833µA = 125.833mA
R_E = 3V / 125.833mA = 24Ω (22)
And redone to produce 250mA (500mA max) at the speaker:
I_C_MAX = 500mA
I_C_Q = 250mA
V_RE = 5V - 500mA * 8Ω = 1V
I_B = 250mA / 150 = 1.667mA
R2 =~ 1kΩ
R1 =~ 220Ω
R_E = 1V / 251.667mA = 3.97Ω (Try 2x10 in parallel)
The above calculations were for a Class A amplifier, which is actually more complicated than
necessary, and also wasteful of power (it constantly has power running through it due to the bias
voltage). A Class B amplfier is far more efficient (using no power when no sound is being generated)
and simpler, needing only two transitors. And there is no reduction in audio quality since the
audio is coming from PWM -- there is no signal in the "dead band", anyway. References:
http://www.electronics-tutorials.ws/amplifier/amplifier-classes.html
https://forum.arduino.cc/index.php?topic=164436.0
I'm using the S9012 and S9013 transistors from my kit.
After trying with the faceplate, it's clear there needs to be some feedback regarding what you set
it to, as I originally wanted to do. But the detentes were impossible to get to work reliably. New
idea: debounce the human-set position, trying to keep the slider in place until the debounce delay
has passed, at which point try to move it to the current stop. But this has a big problem -- when
you let go, the motor moving the slider will also change the current stop, making it impossible to
debounce. Perhaps the debouncing has to only happen in one direction? That is, if the stop is above
the expected stop, debounce until it either settles or moves downward, at which point set the stop
immediately. The opposite when the stop moves downward initially.
Electronic feedback just isn't going to work due to the responsiveness issue. I'm going to try
physical feedback from bumps on the front panel.
The enclosure came out great! But the voltage drop from the motor controller is too much, and the
slider doesn't move reliably. I'll need to try just using a snubber diode and otherwise switching
on and off the power to the motor directly (so it will only be able to move backwards, not forwards).
****************************************
R1 board errata:
- Swap Q2 and Q3 (the labels are swapped)
- R3 should be 220 Ω
- In place of U3:
- Place a 0.1µF ceramic capacitor across pins 8 and 9
- Connect pin 6 to pin 8 (VCC) by bending the leg of the capacitor around to connect to pin 6
- Place a BS170 transistor with pins 1, 2, and 3 at U3 pin 3, U3 pin 16, and U3 pin 4, respectively.
- Connect Q1 pads 2 and 3 together
- Place a diode (1N5819) in J1, anode in pin 2, cathode in pin 1 (square), leaving room to solder the
motor connector to its leads
- Connect the motor with the positive lead connected to pin 2, negative lead to pin 1. When using
the JST connectors from eBay, this means the colors on the wires are as expected (the black wire
goes in the round hole)
*****************************************
I've switched both the motor controller and the amplifier to a single MOSFET. I realized that the
Class B amplifier I created wasn't really doing anything -- since it was a PWM signal alternating
between 0V and VCC, the PNP transistor was just acting as a switch, and the NPN transistor wasn't
doing anything except acting like a flyback diode (the voltage only went negative as a result of
the power dissapated by the speaker acting as an inductor).
Enclosure assembly:
- Two coats of varnish on each side of each piece (Formby's Tung Oil)
- Solder leads to speaker
- Glue speaker to the top piece so it covers the speaker grill using Krazy glue gel
- Be careful to only get the glue on the rubber rim of the speaker, not on the cone
- Make sure the leads are facing the right way (to the left when the back is facing away from you)
- Glue the case together with wood glue
- Pay attention to orientation of the parts, especially the hole for the motor and the screw
holes for the PCB and battery holder on the bottom
I tried (very briefly) to make a brrrrr-ring sound by calling startPlayback() repeatedly, but it
takes too long to initialize. So I'd probably have to build the feature into the PCM library. I
don't think it's worth it.
TODO:
- A "click" sound when you've dialed in a time (at the same time that it would move the slider into
place), see "click" branch
- The alternative battery holders I ordered with the JST connectors are much nicer. But to easily
change the batteries, it needs to be removable (or at least needs to be able to slide forward a
bit). For the next version of the enclosure, add some walls/rails to hold in the battery holder
on the left and right, with a gap behind them (towards the interior wall) for the wire.
Perhaps use a magnet in the back and/or on the bottom to hold it in, or put a small wall in front
(towards the timer door) so that it must be lifted above the wall to be removed. Need to make sure
it doesn't move around when the timer is turned upside-down, though (maybe a wooden "bar" to hold
it down). To save space and cuts, consider using the cut out from the interior panel (where the
slider fits through) for these parts.
- For the next version of the front panel, use the bottom 2mm of dead area on the slider as part of
the "off" area so that the amount of active space used for "off" is minimized (maybe)
-------------------------
For the next revision
- Power management so I can run the logic at 3.3V and the motor at a sufficiently high voltage
- Use PWM to drive the motor slower so we can be more precise
- Reduce power draw to increase battery life. Current power draw (measured on #6 @ 4.8V):
- ~1075 uA when off (??)
- ~1205 uA when running but not ticking
- ~8 mA (max) when ticking
- ~180 mA (max) when ringing
- Anti-pop circuit?
- Analyze speaker power draw
- Could we use a brief push of the motor when going past a stop as tactile feedback?
Much of the power draw when off (0.7 mA) seems to be from the comparator, which is suspiciously
close to its rated "supply current". There is also 0.5 mA from the potentiometer (5V / 10k). We
could significantly reduce both of these by removing the comparator, disconnecting power to the
pot when in sleep mode, but just waking up occasionally to check (via the ADC) if the slider had
been moved.
------------------------
11/25/2022
According to the datasheet, the motor takes about 488µs to move to the next ADC value (out of 1023).
So for 24 values per step, that's about 11.7ms per step. Instead of an independent PWM signal, we
could sync bit-banged PWM to the ADC. So we just run the motor for some time significantly less
than 11.7ms, but at least 488µs, then stop. Once we check the position, if it's not there yet,
repeat.
With new setup, < 14µA both when off and when running but not ticking!
------------------------
1/7/2023
I did some investigation into the amplifier -- I want to remove the pop and make sure it isn't
shorting when first powered. This circuit is the simplest, basically what I have plus a resistor.
It seems to work fine, just need to find the appropriate size of resistor, maybe using a
potentiometer as they suggested:
https://electronics.stackexchange.com/questions/387336/what-all-do-i-need-for-a-simple-speaker-circuit
5 ohms seems to work well, and I'm not hearing a pop. I suspect the pop was due to too much current?
Other options for the amplifier that I rejected:
- https://siliconjunction.wordpress.com/2017/02/28/class-d-amplifier-for-the-arduino/
- https://www.electronics-tutorials.ws/amplifier/mosfet-amplifier.html