Your Crickit contains a special interface chip we call seesaw. Like a see-saw you see in a playground, it goes up/down back/forth. In this case, instead of holding children, it sends commands and responses back and forth - motor movement, sensors inputs, signal i/o...

The seesaw code is contained in a microcontroller near the bottom of the Crickit, and that chip comes with the seesaw firmware on it already when  you get it!

But we do make improvements to the seesaw firmware, fix bugs, and improve performance

So its a good idea to update your Crickit when you get it! It's easy and only takes a few seconds.

Step 1. Plug in USB cable into seesaw/Crickit

There's a little USB connector at the bottom of your Crickit labeled seesaw only! Plug a standard data-sync USB cable into that port and into your computer. You do not need to plug in the DC power jack or power the Feather/CircuitPlayground.

Do check that the switch on the Crickit is switched to ON

Step 2. Double-click the Crickit Reset button

Step 3. Look for pulsing yellow LED and green NeoPixel

Step 4. Look for a New Disk on Your Computer

Step 5. Download the latest firmware

Click here to go to the download page for the latest Crickit firmware releases.

Download the correct file for your specific hardware:

• Crickit HAT (Raspberry Pi) = seesaw-crickitHat.uf2
• All others = seesaw-crickit.uf2

Step 6. Drag UF2 file onto CRICKITBOOT

The first thing you'll learn when making robots is that they use a lot of power. So making sure you have your power supply all worked out is super important. We've tried to make the power supply as easy and safe as possible, so you don't have to worry about damaging your electronics or robot. To do that we made some important design decisions.

How to Power your Crickit

It's really important to read and understand how to power your Crickit!

• You MUST provide about 4-5 Volts DC power to the Crickit to power the servos, motors, solenoids, NeoPixels, etc.
• You CANNOT provide this power by plugging the Crickit, micro:bit, Feather, Raspberry Pi or  Circuit Playground into USB. Computer USB ports cannot provide the 2 Amp + required to drive robotics, LEDs, speakers...
• Power to the Crickit is provided via the 2.1mm DC Jack only!
• The Cricket has two LEDs to let you know how the power supply is doing. If you see the green LED next to the smiley face, you're good to go. If you see the red LED next to the warning triangle, the voltage is too high, too low or too much current is being drawn.
• The Crickit power will also power the Circuit Playground Express, micro:bit, Raspberry Pi or Feather so you don't need separate power for your microcontroller board (however, if you want to plug it into USB for programming, that's totally OK too!)

Here's our recommended ways to power the Crickit:

Plug In DC Power Supplies

These get wall power and give you a nice clean 5V DC power option. 5V 2A works for most project with a motor or two...

And a 5V 4A supply will give you lots of power so you can drive 4 or more servos, motors, etc. Use this if you notice you're running out of power with a 5V 2A adapter

AA Battery Packs

On the go? Portable power is possible! Use AA battery packs.

The number of batteries you need depends on whether you are using Alkaline or NiMH rechargeables.

We recommend NiMH rechargeables. For one, they have less waste, but they also perform better than alkalines in high-current draw robotics. So if you can, please use NiMH!

4 x AA Battery Packs for NiMH ONLY

NiMH batteries have a 1.3V max voltage, so 4 of them is 4 x 1.3 = 5.2 Volts. Perfect!

3 x AA Battery Packs for Alkaline ONLY

Alkaline batteries have a 1.5V max voltage, so 4 of them is 4 x 1.5 = 6 Volts. That's too high! Instead we recommend 3 in series for 3 x 1.5V = 4.5 VDC

If you're making a custom battery pack you may want to pick up a 2.1mm DC jack adapter, so you can connect battery pack wires

Not Recommended Power supplies

• LiPoly Batteries - 1 battery is 3.7V, too low. 2 batteries is 7.2V, too high! You could possibly use a 7.2V pack and then a UBEC to step down to 5V but its not recommended
• Lead Acid Batteries - These are heavy and you'll need a custom charging solution. You can probably get away with a 2 x 2V cell pack, or a 3 x 2V cell pack and then add some 1N4001 diodes to drop the voltage, but it's for advanced hacking!
• USB Power Packs - In theory you can use a USB to 2.1mm DC power adapter, but power packs sometimes dislike the kinds of current draw that motors have (high current peaks for short amounts of time) So experimentation is key!

Setup Virtual Environment

If you are installing on the Bookworm version of Raspberry Pi OS or later, you will need to install your python modules in a virtual environment. You can find more information in the Python Virtual Environment Usage on Raspberry Pi guide. To Install and activate the virtual environment, use the following commands:

To activate the virtual environment:

Installer script

Luckily its quite easy to install support for I2S DACs on Raspbian.

These instructions are totally cribbed from the PhatDAC instructions at the lovely folks at Pimoroni!

Run the following from your Raspberry Pi with Internet connectivity:

We've added an extra helper systemd script that will play quiet audio when the I2S peripheral isn't in use. This removes popping when playback starts or stops. It uses a tiny amount of CPU time (on a Pi Zero, 5%, on a Pi 2 or 3 its negligible). You don't need this on RetroPie because it never releases the I2S device, but it's great for Raspbian.

You will need to reboot once installed.

After rebooting, log back in and re-run the script again...It will ask you if you want to test the speaker. Say yes and listen for audio to come out of your speakers...

If it sounds really distorted, it could be the volume is too high. However, in order to have volume control appear in Raspbian desktop or Retropie you must reboot a second time after doing the speaker test, with sudo reboot

Once rebooted, try running alsamixer and use arrow keys to lower the volume, 50% is a good place to start.

If you're still having audio problems, try re-running the script and saying N (disable) the /dev/zero playback service.

You can then go to the next page on testing and optimizing your setup. Skip the rest of this page on Detailed Installation if the script worked for you!

Detailed Install

If, for some reason, you can't just run the script and you want to go through the install by hand - here's all the steps!

Update /etc/modprobe.d (if it exists)

Log into your Pi and get into a serial console (either via a console cable, the TV console, RXVT, or what have you)

Edit the raspi blacklist with

If the file is empty, just skip this step

However, if you see the following lines:

blacklist i2c-bcm2708
blacklist snd-soc-pcm512x
blacklist snd-soc-wm8804

Update the lines by putting a # before each line

Save by typing Control-X Y <return>

Disable headphone audio (if it's set)

Edit the raspi modules list with

If the file is empty, just skip this step

However, if you see the following line:

snd_bcm2835

Put a # in front of it

and save with Control-X Y <return>

Create asound.conf file

Edit the raspi modules list with

This file ought to be blank!

Copy and paste the following text into the file

Save the file as usual

Add Device Tree Overlay

 Edit your Pi configuration file with

And scroll down to the bottom. If you see a line that says: dtparam=audio=on

Disable it by putting a # in front.

Then add:

on the next line. Save the file and reboot your Pi with

Speaker Tests!

OK you can use whatever software you like to play audio but if you'd like to test the speaker output, here's some quick commands that will let you verify your amp and speaker are working as they should!

Simple white noise speaker test

Run

to generate white noise out of the speaker, alternating left and right.

If you have a mono output amplifier, the I2S amp merges left and right channels, so you'll hear continuous white noise

Simple WAV speaker test

Once you've got something coming out, try to play an audio file with speaker-test (for WAV files, not MP3)

You'll hear audio coming from left and right alternating speakers

Simple MP3 speaker test

If you want to play a stream of music, you can try

If you want to play MP3's on command, check out this tutorial which covers how to set that up

At this time, Jessie Raspbery Pi kernel does not support mono audio out of the I2S interface, you can only play stereo, so any mono audio files may need conversion to stereo!

Volume adjustment

Many programs like PyGame and Sonic Pi have volume control within the application. For other programs you can set the volume using the command line tool called alsamixer. Just type alsamixer in and then use the up/down arrows to set the volume. Press Escape once its set

In Raspbian PIXEL you can set the volume using the menu item control. If it has an X through it, try restarting the Pi (you have to restart twice after install to get PIXEL to recognize the volume control

You can use mpg123 for basic testing but it's a little clumsy for use where you want to dynamically change the volume or have an interactive program. For more powerful audio playback we suggest using PyGame to playback a variety of audio formats (MP3 included!)

Install PyGame

Start by installing pygame support, you'll need to open up a console on your Pi with network access and run:

Next, download this pygame example zip to your Pi

On the command line, run

wget https://cdn-learn.adafruit.com/assets/assets/000/041/506/original/pygame_example.zip

unzip pygame_example.zip

Run Demo

Inside the zip is an example called pygameMP3.py

This example will playback all MP3's within the script's folder. To demonstrate that you can also adjust the volume within pygame, the second argument is the volume for playback. Specify a volume to playback with a command line argument between 0.0 and 1.0

For example here is how to play at 75% volume:

Here's the code if you have your own mp3s!

Test Servos

Lets start by controlling some servos. You'll want at least one servo to plug in and test out the servo code. Visit our recommended servo page to check that you have a servo that works. Once you do, plug in a servo into SERVO #1 spot, making sure the yellow or white wire is next to the 1 text label.

This example will show rotating one servo from 0 to 180 degrees with a stop at 90 degrees.

We start by importing the libraries that we need to have time delays ( import time ) and then the main crickit python library that will make it super easy to talk to the motors and sensors on crickit (from adafruit_crickit import crickit)

The crickit object represents the motors and servos available for control. The servos are available on the sub-objects named servo_1, servo_2, servo_3, servo_4

Each of these are adafruit_motor.servo type objects for the curious

Control Servo

Now that we know the servo objects, we can simply assign the angle! crickit.servo_1.angle = 0 is all the way to the left, crickit.servo_1.angle = 90 is in the middle, and crickit.servo_1.angle = 180 is all the way to the right. You'll want to test this to ensure it works with your specific servo, as 0 might be to the right and 180 to the left if it was geared differently.

More Servos!

OK that was fun but you want MORE servos right? You can control up to four!

This example is similar to the 1 servo example, but instead of accessing thecrickit.servo_1 object directly, we'll make a list called servos that contains 4 servo objects with

servos = (crickit.servo_1, crickit.servo_2, crickit.servo_3, crickit.servo_4)

Then we can access the individual using servo[0].angle = 90 or iterate through them as we do in the loop. You don't have to do it this way, but its very compact and doesn't take a lot of code lines to create all 4 servos at once!

Min/Max Pulse control

Originally servos were defined to use 1.0 millisecond to 2.0 millisecond pulses, at 50 Hz to set the 0 and 180 degree locations. However, as more companies started making servos they changed the pulse ranges to 0.5ms to 2.5ms or even bigger ranges. So, not all servos have their full range at thoe 'standard' pulse widths. You can easily tweak your code to change the min and max pulse widths, which will let your servo turn more left and right. But don't set the widths too small/large or you can hit the hard stops of the servo which could damage it, so try tweaking the numbers slowly until you get a sense of what the limits are for your motor.

All you need to do is add a line at the top of your code like this

crickit.servo_1.set_pulse_width_range(min_pulse=500, max_pulse=2500)

The above is for Crickit Servo #1, you'll need to duplicate and adjust for all other servos, but that way you can customize the range uniquely per servo!

Here we've change the minimum pulse from the default ~750 microseconds to 500, and the default maximum pulse from 2250 microseconds to 2500. Again, each servo differs. Some experimentation may be required!

Continuous Rotation Servos

If you're using continuous servos, you can use the angle assignments and just remember that 0 is rotating one way, 90 is 'stopped' and 180 and rotating the other way. Or, better yet, you can use the crickit.continuous_servo_1 object instead of the plain servo_1

Again, you get up to 4 servos. You can mix 'plain' and 'continuous' servos

If your continuous servo doesn't stop once the loop is finished you may need to tune the min_pulse and max_pulse timings so that the center makes the servo stop. Or check if the servo has a center-adjustment screw you can tweak.

Disconnecting Servos or Custom Pulses

If you want to 'disconnect' the Servo by sending it 0-length pulses, you can do that by 'reaching in' and adjusting the underlying PWM duty cycle with:

crickit.servo_1._pwm_out.duty_cycle = 0

or

crickit.servo_1._pwm_out.fraction = 0

Likewise you can set the duty cycle to a custom value with

crickit.servo_1._pwm_out.duty_cycle = number

where number is between 0 (off) and 65535 (fully on). For example, setting it to 32767 will be 50% duty cycle, at the 50 Hz update rate

Or you can use fractions like crickit.servo_1._pwm_out.fraction = 0.5

Test Drive

Lets start by controlling a drive output. You'll need to plug something into the 5V and DRIVE1 terminal blocks. I'm just using a simple LED with resistor but anything that can be powered by 5V will work.

• Note that the drive outputs cannot have 5V output so you must connect the positive pin of whatever you're driving to 5V. Don't try connecting the positive pin to the drive, and the negative pin to GND, it wont work!
• Drive outputs are PWM-able!

This example will show turning the drive output fully on and off once a second:

We start by importing the libraries that we need to have time delays ( import time ) and then the main crickit python library that will make it super easy to talk to the motors and sensors on crickit (from adafruit_crickit import crickit)

The crickit object represents the drive outputs available for control. The drives are available on the sub-objects named drive_1, drive_2, drive_3, drive_4

Note that for the Feather Crickit, these are feather_drive_1, feather_drive_2, feather_drive_3, and feather_drive_4.

Set PWM Frequency

Drive outputs are all PWM outputs too, so not only can they turn fully on and off, but you can also set it half-way on. In general, the default frequency for PWM outputs on seesaw is 1000 Hz, so set the frequency to 1 KHz with crickit.drive_1.frequency = 1000. Even if you aren't planning to use the PWM output, please set the frequency!

Note that all the Drive outputs share the same timer so if you set the frequency for one, it will be the same for all of them.

Control Drive Output

Now that we have a drive pwm object, we can simply assign the PWM duty cycle with the fraction property!

• crickit.drive_1.fraction = 0.0 turns the output completely off (no drive to ground, no current draw).
• crickit.drive_1.fraction = 1.0 turns the output completely on (fully drive to ground)
• And, not surprisingly crickit.drive_1.fraction = 0.5 sets it to 1/2 on and 1/2 off at the PWM frequency set above.

More Drivers!

OK that was fun but you want MORE drives right? You can control up to four!

This example is similar to the 1 drive example, but instead of accessing the crickit.drive_1 object directly, we'll make a list called drives that contains 4 drive objects with

drives = (crickit.drive_1, crickit.drive_2, crickit.drive_3, crickit.drive_4)

Then we can access the individual using drives[0].fraction = 0.5 or iterate through them as we do in the loop. You don't have to do it this way, but its very compact and doesn't take a lot of code lines to create all 4 drives at once!

You can drive two separate DC motors, so lets go ahead and get right to it!

DC motors are controlled by 4 PWM output pins, the 4 PWM pins let you control speed and direction. And we'll use our adafruit_motor library to help us manage the throttle (speed) and direction for us, making it very easy to control motors

Note that each DC motor is a little different, so just because you have two at the same throttle does not mean they'll rotate at the exact same speed! Some tweaking may be required

Import Libraries

We start by importing the libraries that we need to have time delays ( import time ) and then the main crickit python library that will make it super easy to talk to the motors and sensors on crickit (from adafruit_crickit import crickit)

The crickit object represents the motors and servos available for control. The motors are available on the sub-objects named dc_motor_1 and dc_motor_2

Each of these are adafruit_motor.motor type objects for the curious

To make our code easier to read, we'll make new names for each motor:

Control Motor

Now that we have our motor objects, we can simply assign the throttle, this will set the direction and speed. For example, to set the speed to full forward, use motor_1.throttle = 1 and to set to full speed backward use motor_1.throttle = -1. For speeds in between, use a fraction, such as 0.5 (half speed) or 0.25 (quarter speed). Setting the throttle = 0 will stop the motor.

Even though we don't make it really obvious, you can drive stepper motors from the Crickit.

Stepper motors rotate all the way around but only one 'step' at a time. Usually there's a few hundred steps per turn, making them great for precision motion. The trade off is they're very slow compared to servos or steppers. Also, unlike servos they don't know 'where' they are in the rotation, they can only step forward and backwards.

There's two kinds of stepper motors: bipolar (4-wire) and unipolar (5 or 6-wire). We can control both kinds but with some restrictions!

• The voltage we use to power the motor is 5V only, so 5V power steppers are best, but sometimes you can drive 12V steppers at a slower/weaker rate
• You can drive one bi-polar stepper motor via the Motor port
• You can drive two uni-polar stepper motors, one via the Motor port and one via the Drive port
• That means you have have two uni-polar steppers or one uni and one bi-polar. But you cannot drive two bi-polar steppers.

Bi-Polar or Uni-Polar Motor Port

The Crickit Motor port can run a unipolar (5-wire and 6-wire) or bipolar (4-wire) stepper. It cannot run steppers with any other # of wires!

The code is the same for unipolar or bipolar motors, the wiring is just slightly different.

Unlike DC motors, the wire order does matter. Connect one coil to the Motor pair #1. Connect the other coil to the Motor pair #2

• If you have a bipolar motor, connect one motor coil to #1 and the other coil to #2 and do not connect to the center GND block.
• If you are using a unipolar motor with 5 wires, connect the common wire to the center GND port.
• If you are using a unipolar motor with 6 wires, you can connect the two 'center coil wires' together to the center GND port

Here is the CircuitPython code for stepping various ways. You can try tweaking the INTERSTEP_DELAY to slow down the motor.

CircuitPython supports 4 different waveform stepping techniques. More on each is detailed at Wikipedia.

• SINGLE stepping (one coil on at a time) - fast, lowest power usage, weak strength
• DOUBLE stepping (two coils on at a time) - fast, highest power, high strength
• INTERLEAVE stepping (alternates between one and two coils on) - slow (half the speed of single or double!), medium power, medium strength
• MICROSTEPPING - while this is supported its so slow with Crickit we're going to just 'skip' this one!

Unless you have power limiting requirements, DOUBLE is great for most projects. INTERLEAVE gives you smoother motion but is slower. SINGLE is simplest but weakest turning strength.

CircuitPython stepper motor control is pretty simple - you can access the motor port for stepper control via the crickit.stepper_motor object (it's an adafruit_motor.stepper type object).

With that object, you can call onestep() to step once, with the direction and stepping style included. The default direction is FORWARD and the default style is SINGLE.

Note that 'forward' and 'backward' are, like DC motors, dependent on your wiring and coil order so you can flip around the coil wiring if you want to change what direction 'forward' and 'backward' means.

Putting time.sleep()'s between steps will let you slow down the stepper motor, however most steppers are geared so you may not want any delays.

Uni-Polar Only Drive Port

The Drive port can also control steppers although it can only do uni-polar! Don't try connecting a 4-wire bi-polar stepper, it won't work at all.

And here's the CircuitPython code. Note that the only difference is we're using the crickit.drive_stepper_motor object now!

You may want to add buttons, LEDs, switches or simple sensors to your robot project. With Crickit, you get 8 x 'general purpose in/out' (GPIO) pins called signals. Each signal can be a digital input (button/switch), digital output (LED, for example), or analog input.

This lets you add a ton of external components easily, and its all handled by seesaw. Perfect when you have a Feather without analog inputs (like the ESP8266) or just need a ton of extra pins.

The signal pins are on a 3x8 female header, so you can poke wires directly in!

Each of the 8 signal pin numbers is available under the crickit object as SIGNAL1 through SIGNAL8. Note these are not DigitalInOut or Pin objects! We need to use the crickit.seesaw object to set the mode, direction, and readings

To simplify our code we shorted the crickit.seesaw object to just ss

Digital Pin Modes

You can set the mode of each signal pin with ss.pin_mode(signal, mode) where signal is the crickit.SIGNAL# from above and mode can be ss.OUTPUT, ss.INPUT or ss.INPUT_PULLUP.

Digital Read

Then, you can read the values True or False with ss.digital_read(signal)

Don't forget you have to set it to be an INPUT first! And if you don't have an external pull up resistor, you'll need to set it in the code.

Digital Write

Or, you can set the signal you want to a high value with ss.digital_write(signal, True), or set to low value with ss.digital_write(signal, False). Don't forget you have to set it to be an OUTPUT first!

Analog Reads

And here is the example code. You can see we read the signal with ss.analog_read(signal) which returns a value from 0 to 1023.

By printing the value in a python tuple (ss.analog_read(pot),) we can use the Mu plotter to see the values immediately!

You can read the value of the captouch pads from crickit.touch_#.value This will return True (if touched) or False (if not). This is the simplest/easiest way to detect touch, but it has a catch!

We determine if the touch is active by seeing the difference between the current 'raw' reading value and the first value. That means you do need to read the crickit touch pads without touching them first.

Try loading this code and touching the four pads while looking at the REPL

If you want to get more specific, you can read the 'raw_value' value which is a number between 0 and 1023. Because there's always some capacitance its reading you'll see a starting value of about 250.

You can then test against a threshold, or use it to measure how hard someone is pressing against something (a fingertip vs a palm will give different readings)

Using NeoPixels in your Crickit project is easy and fun, providing a dedicated port on the Crickit to directly wire NeoPixels easily.

The sample code for using NeoPixels on the Crickit vary slightly depending on which version of Crickit you have. Look for the appropriate section on this page for your combination of Crickit and microcontroller.

NeoPixels with Circuit Playground Express + Crickit

The NeoPixel terminal block is controlled by the Circuit Playground Express pad A1. The pad A1 definition is obtained by import board. Then the NeoPixel routine is from import neopixel.

Various animations are provided by defined functions wheel, color_chase and rainbow_cycle. Various solid colors are then defined, you are free to use whichever colors you wish.

You can define a new color variable as a Python tuple with three values for red, green, blue, for example WHITE = (255, 255, 255).

NeoPixels and the Crickit FeatherWing or Crickit Hat

The NeoPixel block signal wire is connected to the Crickit Seesaw control chip pin #20. The following code sets up an external 30 NeoPixel strip connected to the Crickit FeatherWing or HAT

On Raspberry Pi, you'll also need to add the library: from your command line run the following command:

sudo pip3 install rpi_ws281x adafruit-circuitpython-neopixel

Crickit for micro:bit

Currently the micro:bit is not supported in CircuitPython. The micro:bit is programmable in MicroPython but there is no Crickit drive support for MicroPython at present.

For More Information

See the tutorial Make It Glow with Crickit.

DC Gearbox Motors

These DC motors have a gear box already built in, and wires attached, so they're super easy to use:

We also have a wide range of matching wheels:

Other accessories are available, check the Adafruit shop for "TT Motor" items for the wide range of add-ons available.

Servo-style DC motor

If you need a motor that is very compact (but not very powerful) these DC-in-servo-body motors can do the job:

Which can be used with this wheel:

Non-Geared DC Motor

Non-geared DC motors are very weak but very fast: great for fans:

This chassis is cute, red and has two DC motors so its super easy to drive from the Crickit's dual DC motor port. You may need to use some wires to extend the DC motor connections (they're a tad short)

This chassis is nearly identical, but has 3 layers, so you can FIT MORE STUFF!

This chassis is not as nice as the above, but if you fancy it, it comes with two servo-style DC motors and can use the DC motor control on the Crickit as well

You're in luck, you can use just about any kind of servo!

Note that many of the photos below don't show the additional motor horns, but every servo comes with plastic clip-on parts!

Servo Extensions

People often ask us what they can do if the wire to their Servo is to short for their project. Not a problem! These cables act as extension cords - now you've got plenty of room.

Popular plastic-gear servos

The most popular/common servos have plastic gears, they're plenty strong and not too expensive!

These can go back and forth, rotating about 180 degrees

They come in 'standard' size:

And 'micro' size, not as strong but much more compact

Continuous Rotation Servos

These servos look a lot like the above but they rotate all the way around. Unlike standard servos you can't control the location of the horn, just the speed and direction it which it turns. Good as an alternative to DC motors for wheeled bots. For that reason, they tend to get purchased with matching wheels!

High Torque Servos

If you need more power, metal-gear servos can give you better torque, but at additional cost (since the gears have to be machined)

These are not continuous rotation

The Class-D amplifier on the Crickit is pretty powerful, so you can make quite a bit of noise!

4Ω Speakers

You'll get a lot louder audio from 4Ω speakers.

We recommend this speaker, you'll  have to either poke wires into the connector, or cut it off and strip the wires to connect to the terminal block, but its nice and durable

This speaker is less expensive but you'll need to solder wires to the back

8Ω Speakers

8 ohm speakers won't be as loud, but that's OK!

This speaker is inexpensive, but you'll need to solder wires to the back

The speakers below work just fine, but because the audio amp is pretty strong so you have to make sure not to damage the speakers by turning up the potentiometer on the Crickit to make the audio really loud.

If you're getting buzzy sounds from them, turn that little trimmer potentiometer down.

Wall or Bone Transducers

You can also use surface transducers if you like; attach/bolt/clamp the transducer to a surface:

Solenoids

Since the Crickit can only drive 5V power, you'll need to stick to this small 5V solenoid

Vibration Motors

You'll need to extend these wires but they'll work great at 5V and buzz very strongly

The capacitive touch pads on the Crickit have large holes so its easy to connect alligator/croc clips. That's how we recommend you attach to them. The "small" size clips work best:

You can also use copper foil tape. Note that if you get foil with conductive adhesive, you can tape the foil right onto the Crickit pads. Otherwise you'll need to use alligator clips to grab onto the copper.

You can use other conductive materials like paints! Either drip the paint into the pad itself and let it harden, or use alligator clips to connect from one pad to a paper with conductive paint on it.

Remember: If you absolutely need more capacitive touch pins, Signal #1, #2, #3, #4 are four more capacitive touch inputs.

Speeding up many requests from Raspberry Pi to CRICKIT

If your project is making a large number of requests from your Raspberry Pi to CRICKIT, the speed of the I2C connection between boards may be an issue. Fortunately this can be changed.

For the best performance, you'll want to consider tweaking the I2C core to run at 1MHz. By default it may be 100KHz or 400KHz

To do this edit the config with sudo nano /boot/config.txt

and add to the end of the file

dtparam=i2c_baudrate=1000000

Brown Outs?

The power supply on the Crickit will let you draw 4 Amps at once, which is a lot. But perhaps you are turning on all the motors at once, causing the power supply to flicker? An extra large capacitor on the 5V and GND pads may help smooth out that power draw!

Use a large electrolytic capacitor, rated for 10V or higher. Even though the power supply is 5V, you may think you can use a 6.3V capacitor, but you want at least 2x the voltage rating if possible so stick to 10V!

Connect the capacitor using the NeoPixel terminal blocks. The 5V and GND lines are shared across the board so even if its a DC motor or servo causing the issues, this will help! It's just the most convenient place to attach a large capacitor because the two terminal blocks are nicely spaced.

My code gives the following error in the REPL/Serial window:

The code from adafruit_crickit import crickit always throws

Traceback (most recent call last):
File "code.py", line 1, in
File "adafruit_crickit.py", line 66, in
MemoryError: memory allocation failed, allocating 152 bytes

CircuitPython will pull in libraries from /lib on the device before looking for any "baked in" ("Frozen" libraries) in the main CircuitPython code. If you are using, for example, the Circuit Playground Express + Crickit build of CircuitPython and you also have the adafruit_crickit and/or adafruit_seesaw libraries in /lib, CircuitPython will load the /lib version and still have the frozen version in memory. Your program will quickly run out of memory on the Circuit Playground Express.

The fix is fairly easy. Only put the libraries you need in the /lib folder of your CIRCUITPY drive. For Crickit, use the special Crickit builds of CircuitPython and be sure that the libraries adafruit_crickit and adafruit_seesaw are not in your /lib folder. You still have that functionality, but they are already loaded due to the special build.

Your Crickit is well tested but there's things that can trip you up! Here's a few common issues we see

My Crickit Is Doing Something Wrong

We do have bugs once in a while, so please always try updating to the latest Crickit seesaw firmware - then see if the bug persists

My Crickit Motors Aren't Moving!

My Crickit Keeps Resetting, It Works For a Bit... Then Fails!

Check the power supply. There's a few ways to know that power is good:

1. Check the "Happy Face" green LED below the power switch, it should stay lit!
2. Check the "Warning Symbol" red LED below the power switch, it should be off

HELP! My Crickit isn't working in MakeCode, and in Python I see a message "No I2C Device at Address: 49"

A super common issue we see is people using the Crickit with Circuit Playground Express (CPX) and the bolts/screws have come loose! Those bolts aren't just mechanical, they pass signals back and forth between the CPX and the Crickit!

If you're having issue, first thing to check is that those screws are tightly attached!

Another common issue we see is not having good power to the Crickit. Check that you have fresh batteries or a good 5V power supply. Also check the Crickit is on! There's an on/off switch next to the power jack

Python: No Pullups found on SDL and SCL

This most often indicated the Crickit is not powered.

If you're running Crickit on battery power, you need fresh batteries.

If you use the wall power brick to provide power, ensure it is plugged in and the power switch is on.

If batteries aren't an issue, try clicking reset on the Crickit board to kick it back into running

micro:bit Crickit does not work

Be sure the micro:bit LED matrix faces towards the Crickit Seesaw chip and USB firmware update plug and the micro:bit reset button faces the Crickit black power jack. If you plug the micro:bit in backwards, it won't control things properly. Unplug the micro:bit, make sure the 5x5 grid of LEDs faces the Crickit printing that says "micro:bit LED grid faces this way" and you should be set.

Files

• PCB Files on GitHub
• Fritzing objects in Adafruit Fritzing Library
• Crickit HAT CAD Files
• Crickit Circuit Playground Express CAD Files

Datasheets

• TPS259573 eFuse power supply protection chip
• DRV8833 DC motor driver chip
• ULN2003A Darlington driver chip

Circuit Playground Crickit Schematics

Click to embiggen

Crickit HAT Schematics