Contents

• Summary
• Design
• Materials
• Build Instructions
• Use Cases
• Alternate Hardware
• Update 8/24/2022

Summary

My daughter, a teacher, knows that I have strong maker/DIYer tendencies and that I like to be challenged. For the upcoming school year, her school is providing the teachers with new big screen TVs and iPad tablets. Previously, she used a mobile phone connected to a scissor-bracket, connected to a desk clamp for a document camera. Her complaint about that setup was that it was pretty wiggly. Now that she has shiny new hardware, she wanted an upgrade to her document camera setup, and she wanted to use the iPad’s screen mirroring capabilities.

Design

My approach was to design something budget-friendly and easy to build. PVC pipe and fittings are budget friendly, and the build only required one tool, besides a tape measure: a low-cost ratcheting PVC cutter. I saw other designs that required saws and drills. This design avoids using a saw or drill by utilizing off-the-shelf mounting hardware.

The lengths of the PVC pipe sections were based on fitting a normal, letter-sized sheet of paper under the camera. The height of the 9-inch vertical posts create a working distance that fits the whole sheet of paper within view of an iPad camera.

Materials

My design is composed of: low-cost 3/4-inch PVC pipe and fittings, a tablet/phone tripod mount, an 11-inch Magic Arm — a 2-section articulating bracket a short Magic Arm, and a Super Clamp — a clamp suited well for mounting photographic equipment to cylindrical objects, such as poles, stands handlebars, and pipes. What’s magic about the Magic Arm is that 1 knob loosens and tightens all joints. Manfrotto is the company behind the original, high-quality, pricey versions of the Magic Arm and Super Clamp. I am using knock-offs, but the specifications say that they will support a payload of 2kg 3.5kg, which exceeds the weight of an iPad and the tripod mount. I chose the particular tripod mount because it’s all metal and accommodates both tablets and phones.

Bill of materials

• 3/4-inch (inner diameter) PVC pipe: 2 x 3-inches (back of base), 2 x 6-inches (front of base), 2 x 9-inches (vertical posts), 1 x 12-inches (cross bar): https://www.homedepot.com/p/VPC-3-4-in-x-24-in-PVC-Sch-40-Pipe-22075/202300505
• 4 end caps https://www.homedepot.com/p/Charlotte-Pipe-3-4-in-PVC-Schedule-40-Socket-Cap-PVC021160800HD/203811671
• 2 x PVC tees: https://www.homedepot.com/p/Charlotte-Pipe-3-4-in-Schedule-40-S-x-S-x-S-Tee-PVC024000800HD/203812197
• 2 X 90 degree elbows https://www.homedepot.com/p/Charlotte-Pipe-3-4-in-PVC-Schedule-40-90-S-x-S-Elbow-Fitting-PVC023000800HD/203812123
• 11-inch Magic Arm and Super Clamp https://www.amazon.com/dp/B09FPWWDWN $17.53 when purchased
• SmallRig Super Clamp with Ball head Magic Arm https://www.amazon.com/dp/B0B5LFC6L3 $18.69 when purchased
• tablet/phone tripod mount https://www.amazon.com/dp/B08Z7Z7QZ3 $17.95 when purchased

Build Instructions

• Cut the necessary pieces of PVC pipe with a ratcheting cutter https://www.amazon.com/dp/B08YDL3NK9
• Assemble the PVC parts as shown in the above photo. Optionally, glue parts together.
• Adjust the tablet/phone tripod mount so it accommodates the target device in portrait orientation. Loosen the mount a little bit so the device can slide out for now.
• Screw one end of the Magic Arm onto the Super Clamp and the other end onto the tripod mount. Before doing this step, you might want to tighten the Magic Arm so that it isn’t so floppy. The clamp needs to be around 8 inches from the right vertical post, not centered when using an iPad, because of its camera location.
• Clamp the Super Clamp onto the 12-inch PVC cross bar with the opening facing down.
• Insert the camera device (tablet or mobile phone). Secure in place by tightening the tripod mount.
• Turn on the camera device and adjust its position by loosening the Magic Arm knob, setting a position, then tightening the Magic Arm knob. To get the device in a position that worked for me, I positioned the pivoting slots of the ball heads to face front, thereby allowing for x-axis tilt.

Use Cases

Portrait Orientation

When using the camera for a document in portrait orientation, I think it’s helpful to lock the tablet or phone in portrait orientation before inserting it into the mount. Place the whole setup so that you are looking at the document in the correct orientation.

Landscape Orientation

When using the camera for a document in portrait orientation, I think it’s helpful to lock the tablet or phone in landscape orientation before inserting it into the mount. Place the whole setup so that you are looking at the document in the correct orientation.

Screen mirroring

On an iOS device, an iPhone or iPad, you need to use AirPlay screen mirroring. Turn screen mirroring on/off by using the Control Center (swipe down from upper right corner of screen), tapping on the Screen Mirroring icon, and selecting the target device. Air Play can also be activated within certain apps such as YouTube by tapping the AirPlay icon.

On an Android device, you need to first grant Microphone permission in Google Play Service app by going to Settings > Apps > Google Play Services > Permissions. To turn on casting, run the Google Home app, and tap the tile of the target cast device. As in iOS, tapping the casting icon within some apps activates casting.

Annotation with an Apple Pencil on an iPad

To use an Apple Pencil for annotation:

• Take a photo of the object of interest
• Tap on the photo thumbnail in the camera app
• Tap on “Edit”
• Tap on the Markup icon
• Select a color and tool
• Start annotating

When not in use

With the selected tripod mount, the screw at the top of the mount allows you to easily loosen the mount enough to slide the tablet out when not in use, which you will probably want to do. Loosening the Magic Arm knob allows the tripod mount to hang vertically instead of protruding horizontally when not it use.

Alternate Hardware

The 11-inch Magic Arm could be replaced with something not as flexible in regards to adjustment potential. This isn’t a big deal because any possible target device’s camera has zoom capability.

The ball head that came with the tripod mount and an additional purchase of a male-male 1/4″-20 adapter https://www.amazon.com/gp/product/B09NR4W846 could possibly replace the Magic Arm in the design. The height adjustment capability would be eliminated.

A shorter Magic Arm could also be used since probably not so much height adjustment is necessary. Some alternatives:

• Neewer Super Clamp with Double Ball Head Mount https://www.amazon.com/gp/product/B09128Q3YH
• Neewer 5.9″/15cm Magic Arm and Super Clamp Kit https://www.amazon.com/Neewer-Adjustable-Articulating-Mirrorless-Camcorders/dp/B07SV5ZQ4J

Update 8/24/2022

After some experimentation, I decided that the 11-inch Magic Arm was too long. Instead, I chose to use a smaller SuperRig Super Clamp with Ball Head Magic Arm. It doesn’t provide much height adjustment, but camera zoom can compensate for that. Another advantage is its outstanding 3.5 kg (7.7 lb.) load capacity.

The post DIY Tablet or Phone Document Camera appeared first on Lucina.

Here’s a starting point for your own Bernie Sanders and mittens at Biden’s inauguration.

Here’s the link to a .PNG file with a transparent background.

The post DIY Bernie Meme appeared first on Lucina.

This is a Google Data Source chart of data contained in a Google Sheet, containing DataSF open data.

The post San Francisco COVID-19 Cases appeared first on Lucina.

This is a Google Data Source chart of data contained in a Google Sheet, containing DataSF open data.

The post San Francisco COVID-19 Testing appeared first on Lucina.

This is a Google Data Source chart of data contained in a Google Sheet, containing DataSF open data.

The post San Francisco COVID-19 Hospitalizations appeared first on Lucina.

The post Protection masks in stock and shipped from the US appeared first on Lucina.

• Introduction
• Installing CircuitPython
• My CircuitPython Code
• Download code, image and audio files
• Program instructions
• 3D printed case

Introduction

After seeing this new Adafruit product on Instagram (@adafruit, @ecken, and @videopixil) I was very anxious to get my hands on an Adafruit PyBadge, part handheld game console, part micro-controller board. It has a 1.8 inch 160×128 pixel built-in color display, video game-style buttons, built-in sound, neopixels for bling, file storage for game assets, an accelerometer, an ambient light sensor, and a speedy ATSAMD51 processor. I was excited to run it through its paces. First, I learned how to update its bootloader, Next, I tried out an example MakeCode project. After that, I gathered a board definition and the libraries that are necessary to write code for it using the Arduino development environment. I needed to make sure that the Adafruit board definition URL was included in the Additional Boards Manager URLs in the Arduino preferences. After going through the manual process of adding libraries for the PyBadge, I finally got the example code, arcada_pybadge_test running. The example code, demonstrating the Arcada Library, was almost all text, so it wasn’t very exciting.

Installing CircuitPython

Since Adafruit seems to be touting the powers of CircuitPython, I wanted to see what all of the hoopla was about. My previous Python experience had been with Raspberry Pis. As you can tell from my introduction, finding all of the software is very much like a scavenger hunt. I had to download CircuitPython for the PyBadge from CircuitPython.org and install it onto the PyBadge. I had to download the latest release of the Adafruit CircuitPython Bundle (libraries) from GitHub. For a text editor, Adafruit suggests using the simple Mu editor, which I also installed. It simplifies iterative development, since changes are automatically saved to the PyBadge.

My CircuitPython code

Now that the scavenger hunt for all of the software is complete, on to the code… The code below is basically composed of example snippets that I gathered to do the things that I wanted to learn how to do: sound, text, images, buttons, neopixels, accelerometer, and ambient light sensor. To run this code, you will need my 160×128 8-bit .bmp format images (0.bmp – 10.bmp) in an /images folder, a sound file (tink.wav), a bitmap font (Arial-12.bdf) in a /fonts folder, and additional libraries placed in the /lib folder:

• neopixel
• adafruit_bitmap_font
• adafruit_busdevice
• adafruit_display_text
• adafruit_imageload
• adafruit_lis3dh

Download code, image and audio files

Download the CircuitPython code, images and audio

#
# This is a CircuitPython example file for the Adafruit PyBadge
# Lucina 2019-06-06
#
# -- play sounds
# -- set display brightness
# -- fill screen
# -- write text
# -- load and display an image
# -- turn on, set brightness of neopixels
# -- read buttons
# -- read accelerometer
# -- read ambient light sensor
#
import analogio
#import array
import audioio
import board
import busio
import digitalio
import displayio
import math
import neopixel
import time
import neopixel
import adafruit_imageload
from adafruit_bitmap_font import bitmap_font
from adafruit_display_text.label import Label
import adafruit_lis3dh  # accelerometer
from gamepadshift import GamePadShift

# Button Constants
BUTTON_LEFT = 128
BUTTON_UP = 64
BUTTON_DOWN = 32
BUTTON_RIGHT = 16
BUTTON_SEL = 8
BUTTON_START = 4
BUTTON_A = 2
BUTTON_B = 1

NUM_IMAGES = 11
BKG_COLOR = 0xCC44FF
MY_NAME = "@lucina__m"
NAME_FONTNAME = "fonts/Arial-12.bdf"
NAME_COLOR = 0xFFFFFF
NUM_NEOPIXELS = 5
NEO_COLOR = 0x000088
NEO_BRIGHTNESS = .1
BACKLIGHT = .9

whichNeo = 0
neoBrightness = NEO_BRIGHTNESS
brightness = BACKLIGHT

def fadeIn():
    for b in range(20, brightness*100, 1):
        board.DISPLAY.brightness = b/100   # 0.0 --> 1.0
        time.sleep(.02)
    
def fadeOut():
    for b in range(brightness*100, 20, -1):
        board.DISPLAY.brightness = b/100   # 0.0 --> 1.0
        time.sleep(.02)

def loadImage(index):
    # load image into bitmap and palette
    #message("loading...")
    fadeOut()
    (bitmap, palette) = adafruit_imageload.load("images/"+str(index)+".bmp",
                       bitmap=displayio.Bitmap,
                       palette=displayio.Palette)
    # create sprite
    sprite = displayio.TileGrid(bitmap,
                               pixel_shader=palette,
                               x=0, y=0)
    # remove loading message
    #group.pop()
    # remove previous layer
    group.pop()
    # add new layer
    group.append(sprite)
    updateNeopixels()
    fadeIn()
    
def updateNeopixels():
    global whichNeo
    global neoBrightness
    for n in range(0, NUM_NEOPIXELS):
        if n == whichNeo:
            neopixels[n] = NEO_COLOR
        else:
            neopixels[n] = 0
    neopixels.brightness = neoBrightness
    neopixels.show()
    if whichNeo == NUM_NEOPIXELS-1:
        whichNeo = 0
    else:
        whichNeo = whichNeo + 1
    print(neoBrightness)

def message(text):
    label = Label(nameFont, text=text)
    label.color = NAME_COLOR
    (x, y, w, h) = label.bounding_box
    label.x = (80 - w // 2)
    label.y = (64 - h // 2)
    group.append(label)
    
def splashScreen(color):
    splashBitmap = displayio.Bitmap(160, 128, 1)
    splashPalette = displayio.Palette(1)
    splashPalette[0] = color
    splashSprite = displayio.TileGrid(splashBitmap,
                               pixel_shader=splashPalette,
                               x=0, y=0)
    group.append(splashSprite)
    
# make the image display
group = displayio.Group(max_size=10)
board.DISPLAY.show(group)
board.DISPLAY.brightness = BACKLIGHT   # 0.0 --> 1.0

# make a splash screen background
splashScreen(BKG_COLOR)

# display my name while image loads
nameFont = bitmap_font.load_font(NAME_FONTNAME)
message(MY_NAME)

# required for PyBadge audio
speakerEnable = digitalio.DigitalInOut(board.SPEAKER_ENABLE)
speakerEnable.switch_to_output(value=True)
dac = audioio.AudioOut(board.SPEAKER)

# Generate one period of sine wave
#length = 8000 // 440
#sineWave = array.array("H", [0] * length)
#for i in range(length):
#    sineWave[i] = int(math.sin(math.pi * 2 * i / 18) * (2 ** 15) + 2 ** 15)

# audio output
#rawSine = audioio.RawSample(sineWave, sample_rate=8000)
#dac.play(rawSine, loop=True)
#time.sleep(1)
#dac.stop()
#rawSine.deinit()

# play wav file
data = open("tink.wav", "rb")
wav = audioio.WaveFile(data)
dac.play(wav)
while dac.playing:
    pass
wav.deinit()
dac.deinit()

# prepare for neopixels
neopixels = neopixel.NeoPixel(board.NEOPIXEL, NUM_NEOPIXELS,
                            brightness=NEO_BRIGHTNESS, auto_write=False,
                            pixel_order=neopixel.GRB)
for n in range(0, NUM_NEOPIXELS):
    neopixels[n] = 0
neopixels.show()

# prepare for gamepad buttons
pad = GamePadShift(digitalio.DigitalInOut(board.BUTTON_CLOCK),
                   digitalio.DigitalInOut(board.BUTTON_OUT),
                   digitalio.DigitalInOut(board.BUTTON_LATCH))

# prepare accelerometer
i2c = busio.I2C(board.SCL, board.SDA)
int1 = digitalio.DigitalInOut(board.ACCELEROMETER_INTERRUPT)  # Set this to the correct pin for the interrupt!
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)

# prepare light sensor
light = analogio.AnalogIn(board.LIGHT)  # dinit() when done
        
group.pop()     # remove name
index = 0
loadImage(index)

# main loop
current_buttons = pad.get_pressed()
last_read = 0
speed = 5

while True:
    # Reading buttons too fast returns 0
    if (last_read + 0.1) < time.monotonic():
        buttons = pad.get_pressed()
        last_read = time.monotonic()
    if current_buttons != buttons:
        # Respond to the buttons
        if (buttons & BUTTON_RIGHT) > 0:
            if index < NUM_IMAGES-1:
                index = index + 1
            else:
                index = 0;
            loadImage(index)
        elif (buttons & BUTTON_LEFT) > 0:
            if index > 0:
                index = index - 1
            else:
                index = NUM_IMAGES - 1;
            loadImage(index)
        elif (buttons & BUTTON_UP) > 0 and brightness < .9:
            brightness += .1
            board.DISPLAY.brightness = brightness   # 0.0 --> 1.0
        elif (buttons & BUTTON_DOWN) > 0 and brightness > .1 :
            brightness -= .1
            board.DISPLAY.brightness = brightness   # 0.0 --> 1.0
        elif (buttons & BUTTON_A) > 0 and neoBrightness < 0.5:
            neoBrightness += 0.05
            updateNeopixels()
        elif (buttons & BUTTON_B) > 0 and neoBrightness > 0.05:
            neoBrightness -= 0.05
            updateNeopixels()
        elif (buttons & BUTTON_SEL) == BUTTON_SEL:
            pass
        elif (buttons & BUTTON_START) == BUTTON_START:
            pass
    current_buttons = buttons
    # accelerometer
    x, y, z = lis3dh.acceleration
    print(x, y, z)
    if lis3dh.shake(shake_threshold=15):
        print("Shaken!")
    # light sensor
    print(light.value)

Program instructions

• up, down buttons: change the screen brightness
• left, right buttons: change the image (this may crash because of memory allocation errors)
• a, b buttons: change neopixel brightness, change which neopixel is lit

To customize the code, you can create your own 8-bit (256) 160×128 pixel images. I used Windows 10 Paint to convert .jpg files. Name the images by number, starting with 0.bmp. Set the image count using the constant NUM_IMAGES. The name displayed on the startup splash screen is defined in the MY_NAME constant. The name of the sound file, tink.wav, is set in the code.

3D printed case

Since I’m a 3D printing aficionado, I’ll bring up the case I’m using. I downloaded a snap-fit case from Thingiverse, and modified the model to include the speaker grill from the screw-together model. You may download the modification.

The post Programming an Adafruit PyBadge using CircuitPython appeared first on Lucina.

Hurry to take advantage of the $370 flash sale at GearBest.com.

Learn More

I previously wrote about how the Tevo Tornado compares to the popular Creality 3D CR-10.

TEVO Tornado US PLUG 110V

The post Tevo Tornado — only $370 with US Plug 110V appeared first on Lucina.

Features

• LED text display
• Colored LED indicator
• Ceramic nozzle
• Temperature adjustable by degree from 160° to 220° C
• 4 filament extrusion speeds
• Supports 2 types of  1.75mm filament: PLA and ABS
• Can be used with a 5V 2A portable power bank

Package Contents

• 3D pen
• Pen cap
• USB barrel connector power cable
• 5V 2A power adapter
• 2 meters of 3 colors of PLA filament
• Transparent acetate sheet to place on top of stencils
• Design stencils
• English manual

Controls

• Extrude ▼
  • Feed filament
  • Double press to activate continuous feed
  • Stop extrusion if continuous feed active
• Retract ▲
  • Remove filament
  • Press for 2 seconds to activate continuous retraction
  • Stop continuous retraction if active
• Select material +
  • PLA or ABS
  • After pressing Extrude button, decrease temperature
• Select material –
  • PLA or ABS
  • After pressing Extrude button, increase temperature

• Slower
  • Decrease extrusion speed (SP-1 – SP-4)

• Faster
  • Increase extrusion speed (SP-1 – SP-4)

Tips

• If the pen is straining to extrude, raise the temperature.
• If the pen is oozing filament uncontrollably, lower the temperature.
• Only load and unload filament when the pen is heated to temperature
• After extruding, lightly tap the nozzle on the print to avoid stringing.
• Use a finger to  pat down on a freshly printed area to smooth it.
• Handy tools to have
  • Pointy tweezers to remove bits of filament from the nozzle
  • Diagonal wire cutter pliers to make the end of the filament clean for inserting into pen
  • Third hand clamp for holding printed object
• Practical uses:
  • Repair prints made with a 3D printer
  • Use like a hot-glue gun for repairing household objects: joining objects, patching holes

Review

Pros:

• Temperature is adjustable to a specific  degree.
• USB cable allows for flexible power options (e.g. portable power source).
• Pen functions well.

Cons:

• It’s difficult to avoid pressing the speed buttons when pressing the extrude button.
• Holding the pen is a little uncomfortable.
• Two meters of 3 colors of filament isn’t enough to make very much,  yet is very inexpensive (around $0.08 USD per meter).
• The included stencils aren’t very good.

Recommendation

This 3D pen functions well. The ergonomics could be better, specifically the button placement. Having the adjustable temperature would justify its selection among low-priced 3D pens.

The post B660 3D Printing Pen Review appeared first on Lucina.

The post 12% Off 3D Printers at GearBest.com Coupon/Promo Code appeared first on Lucina.