Looking for a wall mounted version of the HMD mount? Check out this remix on thingiverse (thanks Sean)!
Here’s a video going over the design:
The printed parts can all be found on thingiverse here. Please let me know if you use any of these! I’d love to talk about potential improvements that could be made.
Here’s a demo run of the code:
From the VisPy website:
VisPy is a Python library for interactive scientific visualization that is designed to be fast, scalable, and easy to use.
While looking for a near real time data visualization alternative to the venerable matplotlib, I came across this jaw dropping demo:
Absolutely insane, achieving that kind of performance in python is amazing to say the least. This demo in particular seems like it would be more likely to come from a pygame application at the least, but looks more like it would be a Unity project.
The VisPy project is massive, but luckily, there is a set of really good examples included in the repo. Reminds me of the Arduino standard library in this way. After through all of running these, I didn’t find exactly what I was looking for.
For how simple the finished product looks, the learning curve on the way there was surprisingly steep. Hopefully this post saves you some time.
|
1 |
pip install git+ssh://git@bitbucket.org/esologic/sample_project.git |
|
1 2 |
pip install git+ssh://git@bitbucket.org/esologic/sample_project.git@master # on the master branch pip install git+ssh://git@bitbucket.org/esologic/sample_project.git@0.0.2 # on the version tag of 0.0.2 |
|
1 2 3 4 5 6 7 8 9 |
(venv) dev@ESO-3:/tmp$ pip install git+ssh://git@bitbucket.org/esologic/sample_project.git Collecting git+ssh://git@bitbucket.org/esologic/sample_project.git Cloning ssh://git@bitbucket.org/esologic/sample_project.git to ./pip-sjec1gbh-build git@bitbucket.org: Permission denied (publickey). fatal: Could not read from remote repository. Please make sure you have the correct access rights and the repository exists. Command "git clone -q ssh://git@bitbucket.org/esologic/sample_project.git /tmp/pip-sjec1gbh-build" failed with error code 128 in None |
setup.py file. Here are best the best set of docs I’ve found on how to make this file.setup.py. This repo will also be the standard example for this post.sample_project as an example, we can do this like so:|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
(venv) dev@ESO-3:/tmp$ pip install /mnt/c/Users/dev/Documents/misc_git/sample_project/ Processing /mnt/c/Users/dev/Documents/misc_git/sample_project Installing collected packages: sample-project Running setup.py install for sample-project ... done Successfully installed sample-project-1.0 (venv) dev@ESO-3:/tmp$ python Python 3.6.8 (default, Jan 14 2019, 11:02:34) [GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux Type "help", "copyright", "credits" or "license" for more information. >>> from sample_project import print_quote >>> print_quote() If they can get you asking the wrong questions, they don't have to worry about answers. >>> |
If your package behaves as expected when installed like this locally, you’re all set to push the changes to your bitbucket repo and continue with the rest of the guide.
dev@esologic.com. Make sure whenever you see that, to substitute email address associated with your bitbucket account.~/.ssh. If you don’t see both id_rsa and id_rsa.pub files in that directory, create them with:|
1 |
ssh-keygen -m PEM -t rsa -C "dev@esologic.com" |
passphrase blank.~/.ssh/id_rsa.pub to bitbucket. The following images should walk you through the steps, make sure to give the key a memorable name.
|
1 2 3 4 |
$ ssh-keygen -m PEM -t rsa -C "dev@esologic.com" -E md5 $ cd C:\Users\dev\.ssh $ ssh-add id_rsa $ ssh -T git@bitbucket.org |
Devon account is an owner of the repo, it will be allowed to read from the repo. The account ci_bot will also be able to read from the repo because it has read permissions.|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
(venv) dev@ESO-3:/tmp$ pip install git+ssh://git@bitbucket.org/esologic/sample_project.git Collecting git+ssh://git@bitbucket.org/esologic/sample_project.git Cloning ssh://git@bitbucket.org/esologic/sample_project.git to ./pip-nkrqsxao-build setsockopt IPV6_TCLASS 8: Operation not permitted: Installing collected packages: sample-project Running setup.py install for sample-project ... done Successfully installed sample-project-1.0 (venv) dev@ESO-3:/tmp$ python Python 3.6.8 (default, Jan 14 2019, 11:02:34) [GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import sample_project >>> sample_project.print_quote() If they can get you asking the wrong questions, they don't have to worry about answers. >>> |
Fantastic! Remember, your pip command git+ssh://git@bitbucket.org/esologic/sample_project.git will be different for your package. It will look something like this: git+ssh://git@bitbucket.org/{your username}/{your project}.git.
sample_project repo.On whatever you system you have been using so far, enter the following commands and remember to leave passphrase blank.
|
1 2 |
mkdir ~/.ssh/ci_bot_keys ssh-keygen -m PEM -t rsa -C "ci_bot@example.com" -f ~/.ssh/ci_bot_keys/id_rsa |
Add the contents of ~/.ssh/ci_bot_keys/id_rsa.pub to bitbucket while signed in as your machine user like we did in step 2.
git+ssh key insertion locally(Note: you can skip this step, but if things don’t work when you add the step to your CI build start looking for errors here.)
GIT_SSH_COMMAND you can select which SSH key gets used by pip when doing an ssh pull.|
1 2 |
export SSH_AUTH_SOCK=none export GIT_SSH_COMMAND='ssh -i ~/.ssh/ci_bot_keys/id_rsa' |
$KEY environment variable in circleci~/.ssh/ci_bot_keys/id_rsa) available to the circle build process.|
1 |
(venv) dev@ESO-3:/tmp$ cat ~/.ssh/ci_bot_keys/id_rsa | tr "\n" "_" |
-----END RSA PRIVATE KEY-----_ in case your terminal doesn’t wrap correctly.sample_project) in.crossbow is the name of my project.build settings -> Environment Variables and then set the variable like so:
Now that the variable is set, we need to change our circle config to use it.
/.circleci/config.yml fileYou have to make sure that the export GIT_SSH_COMMAND step happens in the same step as any pip commands. Your full dependencies installation circle step may look something like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
- run: name: Install Dependencies command: | # Give us access to private repos export KEY_PATH=tmp_id_rsa echo -e "${KEY//_/\\n}" > $KEY_PATH chmod 600 $KEY_PATH export SSH_AUTH_SOCK=none export GIT_SSH_COMMAND='ssh -i $KEY_PATH' python3 -m venv venv . venv/bin/activate pip install -r ./requirements.txtts.txt |
Make sure you select a circle image that has a git version of 2.17.0 or later, or this step will fail without an explanation. I found that the python image of circleci/python:3.7-buster worked when testing.
Check out this comment for some tweaks to this guide to support the latest version of the tools!
Panelization is the process of taking two or more PCB designs and combining them using tabs or v-scores that you would then separate into individual boards once they come back from manufacturing. It’s a way to get more than one design made in a single order.
There are a few forum posts or other snippets on how to accomplish this out there already, but not a real guide. For my own sake, this is how you can do this panelization using all free tools. Here are some photos of a board I had fabricated by OSH Park using this panelization method:
I implement this technique whenever I’m creating closely-related PCBs.
The design highlighted in this blog post is a transmitter/receiver pair, meaning that there would never be a transmitter without a receiver, or vice-versa.
Design is made simple by doing the layouts individually, and manufacturing is made simple by getting them made as a single board, not having to coordinate multiple orders. Let’s get started with the guide.
You probably already have KiCAD. Next, make sure to download GerberPanelizer by This is not Rocket Science (site link) from GitHub. This guide uses the 2018-08-10 snapshot release.
Your designs have to be completely ready for production before starting this process. Components placed, tracks laid, zones poured etc. It is very “one-way” in that it is impossible to update an already panelized design once it has been exported.
You’ll want to add a grid origin that is really close to your design. In KiCAD, select place → grid origin to do this. I am putting it in the top left hand corner of the board.
In pcbnew, select file → plot to adjust the gerber export settings.
Output directory is set to an empty directory somewhere on your disk. In this example, it’s set to tx-gerbers.Use auxiliary axis as originUse Protel filename extensionsF.Paste and B.Paste.And then click Plot.
You should be greeted with a directory of files with dissimilar extensions:
Next, you need to export the .drlfiles.
Select file → fabrication outputs→ Drill (.drl) File...
These settings will automatically be set to match the previous export, but make sure the output folder and the drill origin match the previous settings. Mine looked like this:
Here is my resulting output directory with all of the files:
This step is weird. You need to change the extension of all .gm1 files to .gko. For this example, flail-tx-kicad-Edge_Cuts.gm1 needs to be renamed to flail-tx-kicad-Edge_Cuts.gko as this is what GerberPanelizer expects. Here is my resulting directory:
.gko fileOpen up GerberPanelizer, you will be greeted with this screen:
Select file → new to create a new project. Next, select board placement → add gerber folder and navigate to the output folder from KiCAD. In this example, it was tx-gerbers.
You should be seeing something like this:
Where is the board?! Select board placement → autopack: native and your design will leap into view:
Now, re-do the guide up until this point for however many unique designs you want to add to this panel. If you want to duplicate your design multiple times in the same panel, you can add an instance by right clicking on the instance in the right hand view and then clicking add instance.
Since you’ve been hitting board placement → autopack: native after each board add, your designs should be properly arranged at this point. You can manually move the designs by clicking and dragging them, but I’ve found that using the autopack works really really well. Here’s what my design looks like at this point:
To join the designs together, you need to add breaktabs.
Select breaktabs → insert breaktab, and a small red circle will appear in the top left hand corner of the workspace:
Click and drag the tab between the two designs. Make sure black dots appear on either edge of the design:
Continue to add tabs in the same manner until the text turns a bright green color, this lets you know that the boards will be secured.
There is no way to automatically add the proper tabs, so make sure you use your best judgement.
Now we’re ready to export!
It’s a good idea to first save the design in GerberPanelizer so you can edit the layout later without having to start from scratch. Once you export the final merged gerber files, they cannot be edited or re-arranged. Select file →save as to save the project.
Now to export the gerbers.
Again, in GerberPanelizer, select file → export merged gerbers and choose an empty output directory. The directory has to be empty because you typically send a zip archive of all gerbers to the manufacturer to get made, and this zip archive should just include this export. You should see this window pop up:
The contents of the merged output directory should look like this:
The merged output directory will include several image renderings of your merged designs, this is a great first check to make sure that everything went well.
Looks good! However before you send any critical designs off for manufacturing it’s best practice to visually inspect the layers with a gerber viewer. Save the merged output directory as a .zip file.
KiCAD ships with a program called GerbView to inspect gerber files. Open that gerbview and then open your zipped merged output directory with file → open zip archive file.
There will be an error message which you can ignore.
You should see something like this:
There’s the design as we expect it, you can uncheck the different layers on the right pane just like in pcbnew to inspect them one by one. I’ve uploaded this design to oshpark (a domestic PCB fab service) to see if their preview also looks correct and again, there are no problems.
You’re now ready to send your panelized designs out for manufacturing. Congrats!
Thanks for reading! Did this guide work for you? Let me know in the comments below this post.
Note: This is confirmed to work with KiCAD 4 and 5.
Ever wanted to have multiple different sound files playing on different output devices attached to a host computer? Say you’re writing a DJing application where you want one mix for headphones and one for the speakers. Or you’re doing some sort of kiosk or art installation where you have many sets of speakers that need to all be playing their own sound file but the whole thing needs to be synchronized. This would even be cool for something like an escape room.
The ladder example is where I needed this bit of code. I’ve been working with interdisciplinary artist Sara Dittrich on a few projects recently and she asked if I could come up with a way to play 8 different mono sound files on 8 different loudspeakers. Here’s a video of the whole setup in action, and an explanation of the project:
I’ve wrapped up all of the code for the art installation project, and that can be found in a github repo here. It includes the startup functionality etc. If you’re interested in recreating the video above, that repo would be a good starting place. The following is a list of the parts used to make that build happen:
It is worth it to give a simple example of how to play multiple files on multiple audio devices using python. I couldn’t find an examples on how to do this online and had to spend some time experimenting to make it all come together. Hopefully this saves you the trouble.
To install sounddevice on my Raspberry Pi, I had to run the following commands:
|
1 2 |
sudo apt-get install python3-pip python3-numpy libportaudio2 libsndfile1 libffi-dev python3 -m pip install sounddevice soundfile |
For this example, let’s say there are 4 audio files in the same directory as multi.py , so the directory looks like this:
|
1 2 3 4 5 6 |
multi_audio/ ├── 1.wav ├── 2.wav ├── 3.wav ├── 4.wav └── multi.py |
The code is based on the sounddevice library for python, whose documentation is pretty sparse. This script will find the audio files, and then play them on as many devices as there are attached. For example, if you have 3 sound devices it will play 1.wav, 2.wav and 3.wav on devices 1-3. If you have any questions, feel free to ask:
|
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 |
""" multi.py, uses the sounddevice library to play multiple audio files to multiple output devices at the same time Written by Devon Bray (dev@esologic.com) """ import sounddevice import soundfile import threading import os DATA_TYPE = "float32" def load_sound_file_into_memory(path): """ Get the in-memory version of a given path to a wav file :param path: wav file to be loaded :return: audio_data, a 2D numpy array """ audio_data, _ = soundfile.read(path, dtype=DATA_TYPE) return audio_data def get_device_number_if_usb_soundcard(index_info): """ Given a device dict, return True if the device is one of our USB sound cards and False if otherwise :param index_info: a device info dict from PyAudio. :return: True if usb sound card, False if otherwise """ index, info = index_info if "USB Audio Device" in info["name"]: return index return False def play_wav_on_index(audio_data, stream_object): """ Play an audio file given as the result of `load_sound_file_into_memory` :param audio_data: A two-dimensional NumPy array :param stream_object: a sounddevice.OutputStream object that will immediately start playing any data written to it. :return: None, returns when the data has all been consumed """ stream_object.write(audio_data) def create_running_output_stream(index): """ Create an sounddevice.OutputStream that writes to the device specified by index that is ready to be written to. You can immediately call `write` on this object with data and it will play on the device. :param index: the device index of the audio device to write to :return: a started sounddevice.OutputStream object ready to be written to """ output = sounddevice.OutputStream( device=index, dtype=DATA_TYPE ) output.start() return output if __name__ == "__main__": def good_filepath(path): """ Macro for returning false if the file is not a non-hidden wav file :param path: path to the file :return: true if a non-hidden wav, false if not a wav or hidden """ return str(path).endswith(".wav") and (not str(path).startswith(".")) cwd = os.getcwd() sound_file_paths = [ os.path.join(cwd, path) for path in sorted(filter(lambda path: good_filepath(path), os.listdir(cwd))) ] print("Discovered the following .wav files:", sound_file_paths) files = [load_sound_file_into_memory(path) for path in sound_file_paths] print("Files loaded into memory, Looking for USB devices.") usb_sound_card_indices = list(filter(lambda x: x is not False, map(get_device_number_if_usb_soundcard, [index_info for index_info in enumerate(sounddevice.query_devices())]))) print("Discovered the following usb sound devices", usb_sound_card_indices) streams = [create_running_output_stream(index) for index in usb_sound_card_indices] running = True if not len(streams) > 0: running = False print("No audio devices found, stopping") if not len(files) > 0: running = False print("No sound files found, stopping") while running: print("Playing files") threads = [threading.Thread(target=play_wav_on_index, args=[file_path, stream]) for file_path, stream in zip(files, streams)] try: for thread in threads: thread.start() for thread, device_index in zip(threads, usb_sound_card_indices): print("Waiting for device", device_index, "to finish") thread.join() except KeyboardInterrupt: running = False print("Stopping stream") for stream in streams: stream.abort(ignore_errors=True) stream.close() print("Streams stopped") print("Bye.") |
Here are some more photos of the build:
Here’s a video:
Here are some images:
This is a quick design I came up with rather than spend the $20 on amazon. You can get the STL files on thingiverse here.
This project got featured on the official arduino blog as well as hackaday! Thanks to everyone that shared!
I work with addressable LEDs a lot. For all that they’re great for, they’re kind of hard to debug when you have a lot of them connected up at once. This is especially apparent when you have many small single modules in hard to reach spaces.
Here’s my solution:
This lets me set the color and number of LEDs in a strip, and then displays a color pattern. This way I can tell if an LED has become disconnected in a strip, or if a channel inside a particular has died.
HSV (x, 255, 255) and x loops from 0-255RGB(255, 255, 255)All of the raw code solidworks, and KiCAD have been posted on my github. You can look at the 3D models on thingiverse as well.
Here are a couple of quick renders of the assembly design:
The screw mount behind the pushbuttons is extended to be able to support the pressure without flexing:
I added a ridge so you can grab onto something as you interact with the switches / buttons.
Here’s the circuit:
There really isn’t a lot going on here, the parts are probably the coolest part of the project. The 5V jack is a 6mm DC barrel jack, the pushbuttons are illuminated 16mm pushbuttons from adafruit, the on/off switch is a locking toggle switch, and the 4 position rotary switch can be found here.
I wired up the circuit on a spare piece of perfboard.
My code is available on my github.
The LED driving part of the code is based on FastLED, a beautiful library for driving these types of addressable LEDs.
The rest of the code is mostly just a hardware UI problem, and isn’t all that interesting. LED count “ramps” as you hold the button down. The longer you hold the button, the faster the
That’s pretty much it! I’ve already gotten some use out of this tool and have found great satisfaction in taking the time to make it look nice as it will be a permanent addition to my lab.
I’ll post any updates I make to this project as edits to the top of this post.
Thanks for reading, and here are a few more photos:
It’s well known that nylon based 3D printer filaments need to be dried out before they’re used. What happens though when you have a 30+ hour print? The spool can take on a lot of moisture in that amount of time and compromise the print.
Many people have solved this problem by making filament dryboxes, somewhat airtight containers that contain a desiccant to dry out the air inside of the chamber.
I have to print several large parts from nylon for client, and I was having trouble in the last hours of the print due to the spool taking on water from the air. I decided to build one of these chambers but with a twist:
Mine is wall mounted! Space in my lab is a premium and the walls are free real estate.
The parts for this build is are available on my Thingiverse page. Oh and if you’re curious, I’m using a wall-outlet-rechargeable desiccant pack from Amazon which I got for $15.
The bolts are M3x10mm, and the nuts are M3 nuts, both from McMaster Carr.
Thanks for reading!
Python uses a Global Interpreter Lock to make sure that memory shared between threads isn’t corrupted. This is a design choice of the language that has it’s pros and cons. One of these cons is that in multi-threaded applications where at least one thread applies a large load to the CPU, all other threads will slow down as well.
For multi-threaded Python applications that are at least somewhat time-sensitive, you should use Processes over Threads.
I wrote a simple python script to show this phenomenon. Let’s take a look.
|
1 2 3 4 5 6 7 |
def increment(running_flag, count_value): c = 0 while True: if not running_flag.value: break count_value.value = c # setting a Value is atomic c += 1 |
The core is this increment function. It takes in a Value and then sets it over and over, increment each loop, until the running_flag is set to false. The value of count_value is what is graphed later on, and is the measure of how fast things are going.
The other important bit is the load function:
|
1 2 3 4 5 6 |
def load(running_flag): z = 10 while True: if not running_flag.value: break z = z * z |
Like increment, load is the target of a thread or process. The z variable quickly becomes large and computing the loop becomes difficult quickly.
The rest of the code is just a way to have different combinations of increment and load running at the same time for varying amounts of time.
The graph really tells the story. Without the load thread running, the process and thread versions of increment run at essentially the same rate. When the load thread is running, increment in a thread grinds to a halt compared to the process which is unaffected.
That’s all! I’ve pasted the full source below so you can try the experiment yourself.
|
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 |
from multiprocessing import Process, Value from threading import Thread from time import sleep from ctypes import c_bool, c_longdouble def increment(running_flag, count_value): """ Increment the value in count_value as quickly as possible. If running_flag is set to false, break out of the loop :param running_flag: a multiprocessing.Value boolean :param count_value: a multiprocessing.Value Long Double """ c = 0 while True: if not running_flag.value: break count_value.value = c # setting a Value is atomic c += 1 def load(running_flag): """ Apply a load to the CPU. If running_flag is set to false, break out of the loop :param running_flag: a multiprocessing.Value boolean """ z = 10 while True: if not running_flag.value: break z = z * z def mct(target, flag, value): """ Returns a lambda that can be called to get a thread to increment a increment using a thread """ return lambda: Thread(target=target, args=(flag, value)) def mcp(target, flag, value): """ Returns a lambda that can be called to get a thread to increment a increment using a process """ return lambda: Process(target=target, args=(flag, value)) def mlt(target, flag): """ Returns a lambda that can be called to get a thread that will load down the CPU """ return lambda: Thread(target=target, args=(flag,)) if __name__ == "__main__": f = Value(c_bool, True) # control flag, will be passed into child thread/process so they can be stopped cv = Value(c_longdouble, 0) # increment value child_lists = [mct(increment, f, cv)], [mcp(increment, f, cv)], [mct(increment, f, cv), mlt(load, f)], [mcp(increment, f, cv), mlt(load, f)] for delay in range(10): # maximum run time of 10 seconds max_counts = [] for get_children in child_lists: # reset the flag and increment f.value = True cv.value = 0 # the child thread/processes will end up in here children = [] for get_child in get_children: child = get_child() # create a new instance of the thread/process to be launched child.start() children.append(child) sleep(delay) f.value = False for child in children: child.join() # stop the process max_counts.append(cv.value) s = "" for count in max_counts: s += str(count) + " " print(s) |
Ever wanted to measure the frequency of a square wave using an Arduino? There are a couple of good solutions out of there to do this, but not all of them had the capacity to do multiple inputs. I couldn’t find this quickly so here is my solution.
Here’s the link to the code if you want to skip ahead. The code uses interrupts and doesn’t use any kind of delaying so it’s good for giant state-machine applications. My application for this is measuring signals from 10Hz-100Hz in which this can measure within 1% error. The absolute limits of the code are 1Hz-50KHz.
This project is on GitHub if you want to send a pull request to make improvements.
For testing, I wrote a simple function generator and uploaded it to a separate arduino. It outputs a pulse train with periods of 10ms (100Hz) and 5ms (200Hz) on pins 2 and 3. I attached LEDs and their resistors for debugging.
Pins 2 and 3 on the function generator to pins 2 and 3 on the frequency counter.
The code for this simple function generator is here:
|
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 |
/* * 3/29/2018 - Devon Bray - https://www.esologic.commultiple-frequency-counter-arduino/ */ int pin_100Hz = 2; int pin_200Hz = 3; unsigned long previous_time_100Hz; unsigned long previous_time_200Hz; void setup() { pinMode(pin_100Hz, OUTPUT); pinMode(pin_200Hz, OUTPUT); } void loop() { unsigned long current_time = millis(); if ( (current_time - previous_time_200Hz) >= 5) { digitalWrite(pin_200Hz, HIGH); delayMicroseconds(1000); digitalWrite(pin_200Hz, LOW); previous_time_200Hz = current_time; } if ( (current_time - previous_time_100Hz) >= 10) { digitalWrite(pin_100Hz, HIGH); delayMicroseconds(1000); digitalWrite(pin_100Hz, LOW); previous_time_100Hz = current_time; } } |
This code will work fine in a stateless application, because there are no delay statements (which some other frequency counters I’ve seen online use). It’s a little bit complicated, send me a pull request if you can refactor it to be cleaner.
Here’s the sketch:
|
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 |
/* * 3/29/2018 - Devon Bray - https://www.esologic.commultiple-frequency-counter-arduino/ * * I've written most of the important notes as comments in the source, but a couple more details: * * - The important data is stored in `period_averages_ms` and `frequency_averages_hz`. You address them using the indices defined at the top of the file. These arrays get updated each time `compute_counts()` is called. Keep it `compute_counts()` somewhere in the main() loop. * * - You could easily add more frequencies, you just have to `NUMSIGS`, make a specific ISR, and another `attachInterrupt` line in setup() * * - It uses [interrupts](https://playground.arduino.cc/Code/Interrupts) which might not be right for your proejct, but normally shouldn't get in the way of too much stuff. * * - If the ISR hasn't seen a new edge in 1000000us, both `period_averages_ms[p_index]` and `frequency_averages_hz[p_index]` will be set to zero! * - This means that slowest frequency that this code can detect is 1hz! * */ int freq_pin_1 = 2; // the pin connected to the first signal, must be an interrupt pin! See the arduino docs int freq_pin_2 = 3; // the pin connected to the second signal, must be an interrupt pin! See the arduino docs #define BUFFSIZE 100 // a rolling average of the frequency/period is computed, and this is the size of that buffer #define NUMSIGS 2 #define FREQ1INDEX 0 #define FREQ2INDEX 1 volatile int period_buffer_indices[NUMSIGS] = { 0 }; // the location of the index for adding to the rolling buffer average volatile unsigned long period_buffers[NUMSIGS][BUFFSIZE] = { 0 }; // the buffers volatile unsigned long previous_edge_times_us[NUMSIGS] = { 0 }; // the time that the previous edge came in in microseconds volatile float period_averages_ms[NUMSIGS] = { 0 }; // the period time of a given signal in milliseconds volatile float frequency_averages_hz[NUMSIGS] = { 0 }; // the frequency of a given signal in hertz volatile bool period_buffer_locked[NUMSIGS] = { false }; // spin locks for the different buffers void setup() { Serial.begin(9600); // the pins must be mapped to their ISRs pinMode(freq_pin_1, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(freq_pin_1), new_freq1_edge, RISING); // you could change this mode to whatever you were looking for, FALLING, CHANGE etc. pinMode(freq_pin_2, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(freq_pin_2), new_freq2_edge, RISING); } void loop() { compute_counts(); Serial.print("Pin 1: "); Serial.print(period_averages_ms[FREQ1INDEX]); Serial.print("ms, "); Serial.print(frequency_averages_hz[FREQ1INDEX]); Serial.print(" hz"); Serial.print(" - Pin 2: "); Serial.print(period_averages_ms[FREQ2INDEX]); Serial.print("ms, "); Serial.print(frequency_averages_hz[FREQ2INDEX]); Serial.print(" hz"); Serial.println(""); } void compute_counts() { // computes the average of the buffer for a given signal. Must be called before using the period_averages_ms or frequency_averages_hz buffers. for (int p_index = 0; p_index < NUMSIGS; p_index++) { float buffer_sum = 0; while (period_buffer_locked[p_index]) {}; // wait around for the ISR to finish period_buffer_locked[p_index] = true; // ISR won't add new data to `period_buffers` if ((micros() - previous_edge_times_us[p_index]) < 1000000) { for (int j = 0; j < BUFFSIZE; j++) { buffer_sum += period_buffers[p_index][j]; } } period_buffer_locked[p_index] = false; // ISR will now add new data to `period_buffers` if (buffer_sum > 0){ period_averages_ms[p_index] = ((buffer_sum / (float)BUFFSIZE)) / 1000; frequency_averages_hz[p_index] = (1 / period_averages_ms[p_index]) * 1000; } else { period_averages_ms[p_index] = 0; frequency_averages_hz[p_index] = 0; } } } void new_edge(int period_index) { unsigned long current = micros(); if (period_buffer_locked[period_index] == false) { // if compute_counts is using the buffer, skip adding to it because that process isn't atomic period_buffer_locked[period_index] = true; period_buffers[period_index][period_buffer_indices[period_index]] = current - previous_edge_times_us[period_index]; period_buffer_locked[period_index] = false; period_buffer_indices[period_index]++; if (period_buffer_indices[period_index] >= BUFFSIZE) { period_buffer_indices[period_index] = 0; } } previous_edge_times_us[period_index] = current; // but make sure the new time is set because this operation is atomic } void new_freq1_edge() { new_edge(FREQ1INDEX); } void new_freq2_edge() { new_edge(FREQ2INDEX); } |
I’ve written most of the important notes as comments in the source, but a couple more details:
period_averages_ms and frequency_averages_hz. You address them using the indices defined at the top of the file. Make sure you call compute_counts() before using this data. Keep it somewhere in main().NUMSIGS, make a specific ISR, and another attachInterrupt line in setup()period_averages_ms[p_index] and frequency_averages_hz[p_index] will be set to zero! This means that slowest frequency that this code can detect is 1Hz!If you have any questions on how to add more signals, leave a comment!
Here’s the output in the serial monitor attached to my function generator from earlier:
That’s like less than 1% error! Pretty good!
I also tested the code with a real function generator. Things worked really well until around 50KHz, so I would say that this code can’t be trusted past 50KHz.
10 Hz
50 KHz
Thanks for reading!