Arduino R2R DAC: Writing to Ports

A few days ago I wrote a post outlining the R2R Digital to Analog Converter. This project is in it’s early stages, but there were a few refinements I wanted to make prior to expanding it’s functionality. The first thing I want to modify is the way that the code handles writing values to the digital pins.

The digitalWrite function on Arduino is only capable of changing the state of one pin at a time. This means we are currently writing to PIN_8, then PIN_9, then 10 and so on. This becomes an issue at high speeds since I am setting my voltage levels based on the sum of these pin’s outputs. The time in between the first and final pin switching will not match the desired voltage and can cause the wave to break down.

The solution to this problem involves pulling back a layer of abstraction from the Arduino. By bypassing the digitalWrite function and writing directly to the ports of the Arduino we can manipulate these pins at the same time. This will provide us faster and more efficient code.

What’s a Port

In the architecture of ATMEGA chips (The chips that run Arduinos) as well as most microprocessors the pins are organized into a set of Ports. These ports are a way of organizing the i/o pins and simplify the chips internal logic.

In the case of the Arduino we have 3 ports. They are as follows:

  • Port B: Digital Pins 8 – 13
  • Port C: Analog Input Pins
  • Port D: Digital Pins 0-7

This project uses pins 8-11 so I am interested in Port B. But how do I access this port?

Port Registers

Each port functions with the aid of three registers. A register is a special section of volatile (non-permanent) memory. Registers hold parameters or values for the system. Each of these three registers has a different task relating to the port. Further each of these registers is made up of 8 bits with each bit corresponding to a pin in the port.

DDR – Port Data Direction Register – As it’s name suggests the DDR port controls the direction of data flow for each pin in the port. If a bit in this register is set to 1 the corresponding pin is an output. Meanwhile the pin is an input when the corresponding bit is set to zero.

PORT – Port Data Register – This port governs the data being written to the pins in the port. When working with output pins we can write zeros or ones to this register to output high or low on the corresponding pins.

PIN – Port Input Register – This register is less relevant to this project but is still good to be aware of. The input register is where you can read the values being received by any of the input pins.

Each of these registers is set up as a variable within the Arduino IDE making them very easy to access. To access one of these registers we just need to append the port name to the register name. For this project I will be using DDRB and PORTB.

Setting Pin States

void setup() {
  for (int k = 0; k < 4; k++){
    pinMode(DAC_bus[k], OUTPUT);
  }

In my original code I used the loop above to set pins 8-11 to Output. This is not very efficient. Instead we can use the register DDRB to set these pins. One important note is that the lowest pin in the port is tied to the last bit in the register. That means to set pins 8-11 to Output I need to write B00001111 into the register. The “B” here tells the compiler this is a binary number. Since the most significant bits here are all zeros we can even shorten this slightly to give us B1111. This gives us the following setup function.

void setup() {
  DDRB = B1111;      //Set Pins 8-11 as Inputs
}

This shortens our code and minimizes the amount of memory required on the Arduino. Additionally this new setup function will run much faster. As a housekeeping item, I also added a comment to clarify what is happening since it is no longer clear in the code.

Writing To A Port

void test_run2(){
  for (int i = 0; i < 15; i++){
    int value = i;
    for (int k = 0; k < 4; k++){
      digitalWrite(DAC_bus[k], value%2);
      value = value/2;
    }
    delay(1);
  }
}

Above I’ve included my original function to draw a sawtooth pattern. In addition to being inefficient this function is just plain ugly. Using the PORTB register we should be able to get rid of the nested loop and write the value directly to the register. Conveniently the variable i is stored in the Arduino in binary. This means we don’t have to do any kind of conversion, we can write the value directly into the port.

void draw_saw(){
  for (int v_level = 0; v_level < 15; v_level++){
    PORTB = v_level;         
    delayMicroseconds(500);
  }
}

That looks a lot cleaner! By making this change I’ve now assured all of the digital pins update simultaneously. This will allow the oscillator to run much more accurately at high speeds. Additionally I’ve reduced the size of the program freeing more memory in the Arduino.

Notice I also made a few other changes to the function. I have changed the function and variable names to be more descriptive. This makes it much clearer what is happening. Additionally I have swapped the Arduino delay function for delayMicroseconds. This allows me to use much smaller delay times and achieve significantly higher frequencies.

With these changes I can now create saw waves throughout the audio frequency range (20 – 20,000Hz) and well beyond it. I’ve been able to shrink the code while improving performance. Further I’ve honed what will be a valuable skill moving forward. That’s all for today but I hope you are all staying healthy. I’ll see you again soon!

Sine Waves on Arduino

I’ve spent the last few weeks going over the fundamentals of PWM and implementing them on my Arduino Uno. Today it’s time to apply those basics to something a little more interesting. I want to get my Arduino outputting sine waves. I’m going to focus on creating a workable 10Hz sine wave and then in forthcoming posts I’ll look at manipulating the frequency and modelling more interesting wave-forms.

Know Thy Limits

Before I go to far into this project I want to talk a little bit about the limitations of the Arduino. The Arduino has a maximum PWM frequency of 980Hz which is quite low, especially when working in the audio space. As an example if I wanted a sin wave with a frequency of 100Hz I would only be able to use approximately 10 PWM cycles per sine wave. The fewer cycles you have per wave the more misshapen your output wave will be. I’ve had some success creating “relatively” clean 100Hz waves but going much higher than this results in the wave breaking down entirely.

One nice thing about the sine wave is that the changes in voltage through the wave are continuous. This means we can push our samples much closer than the normal settling time discussed in my last post. However, the idea of creating an full audio oscillator with this method is an impossibility. An LFO or envelope generator though are still realistic goals.

If you are interested in creating an audio oscillator using your Arduino I would recommend looking into off-board DACs (Digital to Analog Converters) which use serial communication with the board to provide much higher output speeds and resolutions.

The Filter

Low Pass Filter With RC=0.0047

To get started I set up an RC Low Pass Filter. After the experiments in my last post I settled on an RC value of 0.005 (or 0.0047 more accurately). This should give me a good balance between stability and low settling time. I used a 47K ohm resistor and a 0.1uF capacitor to accomplish this.

The Sine Wave

Sine Wave Equation with DC Offset

I want to have a quick look at the sine wave equation before I start coding. There are a number of variables which we can use to adjust the waves properties. The first thing to note is the variable n. If you’ve worked with continuous sine waves you may have seen this formula as a function of t. Where t represents time (a continuous variable), n represents discreet samples. This means n will always be a whole number (0, 1, 2, …) which lends itself to working in a digital environment.

The next variable we have to look at is w which represents the angular velocity (also called normalized frequency depending on your background). This represents how quickly your sine wave will move through a full cycle. We can determine the value for w with the following formula:

In the above formula N represents the total number of samples it will take to traverse a full cycle of the sine wave.

Next up is A which is known as the amplitude or scaling factor of the wave and C which represents the offset. A typical sine wave varies between 1 and -1 centered at 0. However, on the Arduino the duty cycle of a PWM signal is set by an integer between 0 and 255. To get our sine wave to fill this range we first multiply the sine wave by 127 (A). This creates a wave which varies between -127 and 127. Next we add the offset of 127 (C) to the output which gives us our final sine values between 0 and 254.

Choosing Your Frequency

Two factors affect the frequency of the sine wave. N (Discussed above) is the first. If you are moving through your samples at a constant rate the more samples you have the longer it will take. The trade off here is as you might imagine, the more samples you have the cleaner your sine wave will look.

Sample time (given in ms) is the other. This is the time the Arduino will wait between each step of the sine wave. This again is something of a balancing act as you must allow enough time for your signal to stabilize at each new voltage level.

Taken together we can create the following formula to determine our final frequency:

Discreet Frequency Calculation

You may recognize that this is essentially the calculation to find frequency from the period (f = 1/p). In this equation N*(sample time) represents the period (the number of samples * the time it takes for each sample). Since sample time is in ms we use 1000 as a conversion factor.

The Code

Now that we’ve got everything set up it’s time to write the code. I’ll start out by declaring the necessary variables:

int PWM_out = 5;           //PWM output at pin5

int sample_time = 5;       //ms
int N = 20;                //int
int duty_cycle;            //unitless

int i;                     //Counter variable

Here you can see I’ve set the sample_time to 5 and N to 20. Using the formula I showed earlier this should give me a frequency of 10Hz (1000/(5*20) = 1000/100 = 10Hz).

For this program I don’t need to run any kind of set-up. That means I can leave the set-up block blank:

void setup() {
}

Next comes our main loop where all the magic happens:

void loop() {
  for (i = 0; i < N; i++){
    duty_cycle = 127+127*sin(i*(2*3.14)/N);
    analogWrite(PWM_out, duty_cycle);
    delay(sample_time);
  }
}

Lets go through this one in a bit more detail. First I set up a for loop which will iterate through the code N times incrementing i each time.

Next I calculate the duty_cycle value using the sine wave equation. Notice I have placed the angular velocity equation directly inside the sine equation (2*pi/N) to simplify the line. From there we write that duty cycle value to the PWM_out pin (pin5) using analogWrite.

Finally there is a delay command. The delay waits for the amount of time defined by sample_time before beginning the next iteration of the loop.

10 Hz Sine Wave From Arduino

And there we have it. As you can see from my oscilloscope output the wave is far from perfect, nonetheless we’ve created an analog sine wave using a digital microcontroller! This is no small accomplishment and I can’t wait to build on it further. I encourage you all to set up this code and play around. Try changing the variables and values to see how each impacts the design. I’ll be back soon with more!

40106 Oscillator Continued

40106 Oscillator Schematic

I left my last post (40106 Triangle Waves) on a bit of a cliff hanger. I had shown how to pull a triangle wave from the circuit and identified some issues with the oscillator as it stood. Today I’d like to go over those issues and how I corrected them to get this oscillator up and running.

I do want to mention the oscillator design above is still in a somewhat rudimentary form. I expect there will be quite a bit of optimization that can be done on it as time goes on.

Buffering

Since we are pulling our outputs directly from the loop which sets the frequency, any elements we add to the circuit which draw current will affect the frequency. This is not ideal. What we need to do is isolate the oscillator circuitry from any further additions to the circuit. For the square wave this is extremely straight forward. Since the signal is binary (digital) we can simply send the output through a second inverter on the 40106 chip. Take note: this will invert the signal (when the original oscillation was high the buffered oscillation will be low) however since this is a repeating signal it won’t cause any impact.

The triangle is slightly more difficult to buffer since we need to concern ourselves with a range of analog values. I accomplished this by feeding the signal through an LM324 op-amp set up as a voltage follower with an additional 10uF capacitor on the output.

Amplification

After the buffering stage I was still left with dramatically different amplitudes for the two wave forms. The square wave after the buffer sat at almost 9V while the triangle was only 1.4V (The output voltage of the LM324). There’s a number of ways you can approach this inconsistency however I found myself somewhat limited by the parts I had on hand and by my decision to run this oscillator on a single 9V battery supply.

How I ended up overcoming this was by using voltage dividers to lower both signals to about 1V peak to peak. From here the selected input is sent into a very basic LM386 power amplifier.

This solution does introduce a large amount of noise into the square wave signal so you may choose to bypass the amplifier with the square wave and only use it on the triangle.

Set up this way I got both signals to reliably output approximately 5Vpp.

Decoupling

One issue I ran into a lot with this circuit, especially building on breadboards was noise. The frequency would bounce around and the wave-forms would not be crisp. This can be largely overcome by adding decoupling capacitors between the negative and positive supply lines. An excellent overview of decoupling (and many other common capacitor uses) can be found over at SparkFun.

40106 Triangle Waves

Recently I completed a post discussing the 40106 Inverter and a simple square wave oscillator. I wanted to build on that post a little more today and look at how we can modify this same oscillator to output triangle waves along with square. These triangle waves will sound profoundly different than square waves in the audible range, giving our oscillator 2 distinct voices. Additionally, we can use the oscillator at a low frequency to drive a voltage controlled amplifier or filter. We can get much more variance from the rising and falling triangle wave in these applications than we would with the simple switching of a square wave.

So Where Are These Triangles?

40106 Oscillator with Triangle Output

If you read my previous post you may remember that this oscillator works by charging and discharging a capacitor. As the capacitor charges and discharges it allows the voltage to rise and fall at the input. This rise and fall causes the output of the inverter to turn on and off producing the square wave. What we can also do is take an output at the input of the inverter where the voltage is rising and falling to produce a triangle wave!

An Amplitude Problem

If you try building this circuit as is you’ll very quickly notice an issue with the design. Connecting a speaker to the output of the square wave sounds great but the triangle is barely audible! If you look at the two waveforms above you’ll see that the square wave has a peak to peak voltage of 6.32V. The triangle however is only registering a fraction of that at 1.22V. This is because the output of the inverter (where we draw the square) always outputs a full digital signal. Meanwhile the voltage at the input only rises until it reaches a threshold voltage. At that point the inverter changes state and the capacitor begins discharging again. In this case (running the 40106 on 9V) that threshold appears to be 1.22V.

So What Now?

In my next post I’ll be exploring the use of op-amps to buffer these outputs and equalize them to a usable voltage. Once we’ve accomplished this we’ll be able to start using this oscillator in all kinds of awesome projects. See you all soon!

40106 Hex Schmitt Inverter

The 40106 Hex Schmitt Inverter is an incredibly useful and popular IC in the world of DIY synthesis. It is cheap, easy to use and is central to one of the simplest oscillators around. Today I’d like to have a look at this chip, explain how and why it works and show you how you can use it to start making some noise.

A Hex Schmitt What-Now?

As the name suggests the 40106 chip is a Hex Schmitt Inverter (Or 6 Hex Schmitt Inverters) on a 14 pin chip. An Inverter is a digital component which takes an input (0 or 1) and outputs the opposite value. Typically in digital electronics these would be represented as 0V or 5V meaning if 0V is sent to the input 5V will be output by the output and vice versa. What makes a Hex Schmitt Inverter special is its capacity to take analog inputs rather than just 0 or 5V. The way this is accomplished is by setting a threshold voltage where the output changes. Looking off the datasheet for the 40106 we can see that in typical operation this happens at 0.9V when the chip is being powered with 5V or 2.3V when being powered with 10V. When the voltage on the input goes above that threshold the output turns off. When the input goes below that threshold the output a digital high voltage (usually 5V).

Dividing By Zero?

This Isn’t Going To Work

That probably all sounds as clear as mud so lets go over a simple use case to see if we can make some sense of it. We know that when you input a high voltage to an inverter it outputs a low voltage and vice versa. So what would happen if we connected the output back to the input? Now we’ve built a bit of a paradox! When the output is high it sends that high signal back to the input which makes the output low which makes the input low which makes the output high which makes the output low which makes…. you get the idea. The problem is since this is happening instantly its faster than the chip can handle and the whole thing breaks down.

Capacitor To The Rescue!

Simple 40106 Oscillator

What we need is a way to delay the signal traveling from the output back to the input so we can get a consistent oscillation. We can accomplish this by adding a capacitor between the input and the ground and a resistor between the output and input. The capacitor is initially in its uncharged state and the input is low. This low input voltage causes the output to go high, however an uncharged capacitor provides no resistance between the input and ground so all current flowing out of the output goes to ground and the voltage stays at 0V at the input.

As current flows into the capacitor it begins to charge which in turn resists more current traveling through it. This new resistance allows the voltage on the input to begin to grow proportional to the resistance provided by the capacitor. Eventually this voltage will reach the threshold voltage of the inverter and cause the output to go low. Then the whole thing happens in reverse, as the capacitor discharges the voltage drops until it falls below the threshold voltage and the output switches back to high.

The resistor functions to limit the current traveling from the output to the capacitor which slows the charging of the capacitor.

So How Do We Control This Thing?

Simple 40106 Oscillator with Control Pot

The key to taking this from a curiosity to something useful is control, we need to be able to select a frequency range and modify it in real time. Since the speed the inverter flips from high to low and back is governed by the charging and discharging of the capacitor we can control the frequency by controlling the speed the capacitor charges and discharges.

The first way to do this (as you may have guessed) is by changing the size of the capacitor. A smaller capacitor will charge quickly providing you a very high frequency while a larger capacitor will charge slower and provide a substantially lower frequency. Choosing the right capacitor is a great way to select a range of frequencies for your oscillator however as variable capacitors are rare and expensive this is not an ideal method for making real time changes to the frequency.

This leads us to the second method which is adjusting the resistance. This resistance limits the current flowing to the capacitor. The less current flowing to the capacitor the slower it will charge. Further since potentiometers (variable resistors) are common components we can add a knob to adjust the frequency of our oscillator on the go.

An easy way to calculate the approximate frequency with any resistor capacitor combination is using the equation f = 1.5/RC

555 Based Drone Synthesizer With LFOs

Today I have an update to the 555 Based Drone Synthesizer which I posted last week. I was having a lot of fun with my Drone synth but wanted to expand on it to get a bit more variation from the sound. To do this I added a set of LFOs to modulate the frequency of the drone oscillators.

To accomplish this I built a second set of three 555 based oscillators. These new oscillators are identical to the ones in the drone synthesizer except for a change to the capacitor between pin 2 and ground. By increasing this capacitor from 0.01uf to 1uf I was able to lower the frequency of the square wave they produce. This makes them perfect for use as LFOs.

I then connected the output (pin 3) of each of these new oscillators to the control voltage input (pin 5) of the corresponding oscillator in the drone synthesizer through a 1K resistor. An additional modification that can be made to this circuit to provide further control would be to replace this 1K resistor with a 10K or 50K ohm potentiometer which would allow you to modify the amount which the LFO modulates the oscillator in the drone synth.

In this experiment I have used LFOs but you could easily control the drone synth in other ways as well by providing a control voltage to pin 5. I am interested to see how this set-up would react to a control from a sequencer or keyboard and may try this in the future.

Simple 555 Based Drone Synth

Today I have another very simple breadboard project based around the 555 timer. I’ve built three 555 astable oscillators similar to what I used in my 555 Serial Oscillator Project. This time however instead of connecting the oscillators in series I have run their square wave outputs through a simple mixer onto a single audio channel. This is known as a drone synthesizer.

As you can see from the schematic this drone synth is a fairly straightforward build. If you are familiar with 555 oscillators you probably recognize the layout of the 555 chips as a basic astable oscillator almost directly out of the 555’s datasheet. Once the three oscillators were created I added a 1K ohm resistor to the output of each (pin 3) and connected these outputs together. Once the three outputs are connected you can run this through a large capacitor (I used 330 uf) and out through your output jack. It is also possible to connect this circuit directly to a speaker though the audio level may be a bit low without amplification.

Once you’ve built this circuit you can begin experimenting with it. Pin 5 on the 555 chip can be used as a control voltage input so you could easily add a method of control voltage to this circuit. The easiest way to do this would be to build three more 555 oscillators and connect their outputs to pin 5 of the 555 chips in your drone synth. These will function as basic LFOs and modulate the frequency of the drone’s oscillators. You could also experiment with other voltage controls like a sequencer or keyboard. You could also replace one or more of the potentiometers with things like photo-resistors or body contacts to make the project even more interesting.

Lastly I wanted to mention that this drone synth is not limited to three oscillators. You can add as many 555 oscillators as you want in parallel to make an even deeper and stranger sound. If you’re interested in seeing the extreme of this a YouTube user by the name of Look Mum No Computer recently built a 100 Oscillator Drone that is definitely worth checking out.

555 Oscillators in Series

I’ve been spending a lot of time lately playing around with 555 timer chips and wanted to quickly share my latest creation. This project uses four 555 timers each set up as a standard astable oscillator. I’ve then connected the output from pin 3 of each oscillator to the control voltage at pin 5 of the next subsequent chip. Essentially this means each 555 timer is working as an LFO for the next oscillator to it’s right. I also increased the size of the capacitor between pin 6 and ground of the two left-most oscillators in order to  lower their frequency.

I was quite pleased with the range and depth of sounds it produced however, it should be said that I built this as a proof of concept and it is not fully flushed out. I would be very interested to try a similar setup with a different waveform. I feel like this idea would really come into it’s own if used with a triangle or sine wave oscillator which produced a wider range of tones. I have also been experimenting, with some success, with adding capacitors between the output and control voltage inputs to smooth the square wave slightly and create a saw tooth pattern. Without an oscilloscope on hand however this is proving difficult to optimize.

This is also a circuit which can be easily expanded by adding additional oscillators and admittedly there is a little voice screaming in my head to take it to it’s logical conclusion. I expect in my near future I’ll spend a rainy afternoon stringing together as many 555 circuits as I can fit on my breadboards and see what I end up with. I’ll be sure to share the results.

VTech Apple Part 5 – 555 Trigger Oscillator

circuit bending, loop trigger, 555

I have to admit for some time I have been stalled with my Vtech Alphabet Apple circuit bending project. I love the toy aesthetically and have always felt like there should be more bends available then what I was able to find. However even after hours of experimenting and dissecting this toy I was left feeling somewhat underwhelmed with the results. Over the weekend though I brought it back out determined to turn it into a more functional instrument, and to do that I needed to create a trigger oscillator.

If you want to get caught up before going forward don’t hesitate to visit my previous posts on this toy:

VTech Apple Part 1 – Kill Switch and Line Out

Vtech Apple Part 2 – Exploration and Pitch Adjustment

Vtech Apple Part 3 – Voltage Starve

Vtech Apple Part 4 – Body Contacts

Since I hadn’t had any luck finding a loop on the board I moved on to less straight forward methods. I decided what I needed was a way to send a signal at repeating intervals to one of the contacts on the button matrix to trick the Vtech Apple into thinking a button was being repeatedly pressed and trigger a repeating sound. By generating this signal independently I could manipulate its frequency and control to suit my needs.

Once I had a clear definition of what I needed to get the job done the solution seemed all to clear, what I needed was a 555 timer. By setting up an astable 555 timer as a trigger oscillator I could route the square wave signal into the button matrix to repeatedly trigger the button (or buttons) of my choosing. Further by using a potentiometer I would be able to adjust the frequency of the square wave and therefore control the time between button presses as needed.

555 astable
This is a simple mock up of the circuit I used. Note that for this to work the positive voltage must be supplied by the toy itself and the ground must be share with the toy as well. This is easily accomplished by running the power from either the positive power connection on the Apple’s circuit board or directly from the kill switch installed in Part 1 . Just ensure it is connected at or past the kill switch so that the kill switch will remove power from the oscillator as well. Similarly the ground can be connected to any ground point on the circuit.

Astable 555 circuit
After testing my plan using a breadboard I put together this small 555 timer circuit on a scrap piece of perf board I had laying around from a previous project. I did my best to keep everything as small and compact as possible as my space inside the toy is somewhat limited. I’ve seen some circuit benders using what is called the “Dead Bug Method” in these situations to further minimize the size of the circuit. When building a dead bug circuit the components and connections are soldered directly to the pins on the IC rather than onto a piece of perf board. This can be an excellent way to shrink the circuit for those really tight fits but also leaves you with a more fragile product so since I could get away with using a board in this toy I did in order to get more stability and durability from the circuit. I will revisit dead bug circuits in a future post but in the interim there are many demonstrations of the method on YouTube if you deem it necessary.

Wiring 555 Oscillator
Once I had my 555  trigger oscillator circuit built the next step was to install it in my Vtech. I started out by planning positions and drilling holes for the potentiometer, switch and LED. Once these were in place I began the process of wiring the leads I had left on the 555 trigger oscillator circuit to their respective locations on the toy. On the diagram below I have marked the approximate paths of each wire upon installation. In planning this mod I did my best to limit the number of wires crossing between the back and front sections of the toy as these wires tend to get put under a lot of stress when the toy is being opened and closed. To achieve this I pulled power from my kill switch and sent ground directly to the negative terminal on the battery box. Since the switch and pot are mounted on the back portion this means only the pulse out wires have to cross over to the front half of the apple.

Wiring Vtech Apple

You may also notice that there are two pulse out wires leading from the switch to the button matrix. I used a 3 position on-off-on switch for this bend which allowed me to send the pulse to two locations based on the switch position (as well as nowhere in the off position) By connecting the opposing sides of the switch to different positions on the key matrix I am able to choose between two different buttons when running the oscillator. If you were so inclined and had the space to work with you could take this even further using a rotary switch or patch bay to allow you to select where the pulse was being sent. If there is a specific key you are after which you are not finding by touching the pulse to the solder points on the matrix try using your probe to connect sets of two points on the matrix together. If you find that this is necessary to get the input you desire this can be done by bridging the two points with a transistor and feeding the pulse into the base (more on that in a future article).

Finished Vtech Apple Loop
Once everything was wired I secured the 555 circuit and LED with hot glue, taped down all the loose wires and closed up the toy. I have to say after playing with it a bit I am really enjoying this modification. I’ve been able to produce a host of strange noises and effects and without having to use a hand to continually press the buttons I feel like I’m finally able to take full advantage of the other bends on this device. I’ve been having particular fun using the power starve to produce glitches in conjunction with the continuous oscillating noise produced by raising the rate of the 555 to high frequencies.

That’s all for today but I hope you guys have fun. Happy soldering!