Trans Scend Survival

Trans: Latin prefix implying "across" or "Beyond", often used in gender nonconforming situations – Scend: Archaic word describing a strong "surge" or "wave", originating with 15th century english sailors – Survival: 15th century english compound word describing an existence only worth transcending.

Category: DIY (page 1 of 5)

…To Lasercut / 3DP a Really Accurate Coil Winder

...To Lasercut / 3DP a Really Accurate Coil Winder

See the repo here:
https://github.com/Jesssullivan/maggen/tree/master/coilbot_ArduinoRampsDriver

Parent here:
https://github.com/subatomicglue/maggen

Parent machine:
undefined

...Adding a parametric (wire gauge, coil bobbin width, stepper resolution) guide:


...More to come soon xD

Decentralized Pi Video Monitoring w/ motioneye & BATMAN

Visit the me here on Github

Decentralized Video Monitoring over a Pi 'Zero W' Mesh Network

Using motioneye video clients on Raspbian & a BATMAN-adv Ad-Hoc network

link: motioneyeos
link: motioneye Daemon
link: Pi Zero W Tx/Rx data sheet:
link: BATMAN Open Mesh

The Pi Zero uses an onboard BCM43143 wifi module. See above for the data sheet. We can expect around a ~19 dBm Tx signal from a BCM43143 if we are optimistic. Unfortunately, "usable" Rx gain is unclear in the context of the Pi.

This implementation of motioneye is running on Raspbian Buster (opposed to motioneyeos).

Calculating Mesh Effectiveness w/ Python:

Please take a look at dBmLoss.py- the idea here is one should be able to estimate the maximum plausible distance between mesh nodes before setting anything up. It can be run with no arguments-

python3 dBmLoss.py

...with no arguments, it should use default values (Tx = 20 dBm, Rx = |-40| dBm) to print this:

you can add (default) Rx Tx arguments using the following syntax:
                 python3 dBmLoss.py 20 40
                 python3 dBmLoss.py <Rx> <Tx>                 


 57.74559999999994 ft = max. mesh node spacing, @
 Rx = 40
 Tx = 20

Try a few values from a shell or take a look in the file for more info.

Order of Operations:

All shell scripts should be privileged to match chmod u+x and assume a Raspbian Buster environment.

See ./motionConfig.sh to configure motioneye.
See ./batmanConfig.sh to install & configure BATMAN-adv.
See ./batmanRC.sh to initialize the network
See batmanBATSpace.service for a systemd service framework

dBmLoss.py:

from math import log10
from sys import argv
'''
# estimate free space dBm attenuation:
# ...using wfi module BCM43143:

Tx = 19~20 dBm
Rx = not clear how low we can go here

d = distance Tx --> Rx
f = frequency
c = attenuation constant: meters / MHz = -27.55; see here for more info:
https://en.wikipedia.org/wiki/Free-space_path_loss
'''

f = 2400  # MHz
c = 27.55 # RF attenuation constant (in meters / MHz)

def_Tx = 20  # expected dBm transmit
def_Rx = 40  # (absolute value) of negative dBm thesh

def logdBm(num):
    return 20 * log10(num)

def maxDist(Rx, Tx):
    dBm = 0
    d = .1  # meters!
    while dBm < Tx + Rx:
        dBm = logdBm(d) + logdBm(f) - Tx - Rx + c
        d += .1  # meters!
    return d

# Why not use this with arguments Tx + Rx from shell if we want:
def useargs():
    use = bool
    try:
        if len(argv) == 3:
            use = True
        elif len(argv) == 1:
            print('\n\nyou can add (default) Rx Tx arguments using the following syntax: \n \
                python3 dBmLoss.py 20 40 \n \
                python3 dBmLoss.py <Rx> <Tx> \
                \n')
            use = False
        else:
            print('you must use both Rx & Tx arguments or no arguments')
            raise SystemExit
    except:
        print('you must use both Rx & Tx arguments or no arguments')
        raise SystemExit
    return use

def main():

    if useargs() == True:
        arg = [int(argv[1]), int(argv[2])]
    else:
        arg = [def_Rx, def_Tx]

    print(str('\n ' + str(maxDist(arg[0], arg[1])*3.281) + \
        ' ft = max. mesh node spacing, @ \n' + \
        ' Rx = ' + str(arg[0]) + '\n' + \
        ' Tx = ' + str(arg[1])))

main()

Persistent, Live Ubuntu for College

Below is are live mirrors of my "PSU Hacking Club" Ubuntu repos.


https://github.com/psu-hacking/iso-gen

Generate psu-hacking.iso image & bootable media

The 'psu-hacking' disk image extends the Ubuntu LTS (18.04.x) operating system with common dependencies/software for the discerning college student.

  • Live, Persistent file storage
  • Fast: Ubuntu LTS + mkusb (casper-rw) = efficient
  • Use (almost) any hardware- take your desktop OS with you
  • Completely self sufficient: does not interact with your existing OS or other hard disks!

There are a variety of methods to setup a persistent, live OS.

Features & Software:

  • Atom editor with Chapel language support
  • R language + RStudio editor / IDE
  • Google Chrome
  • Libre Office suite
  • Common Runtimes and Compilers

Recommended Method:

For Ubuntu + PSU Hacking additions, use mkusb with the 2x USB drive method (below), and run the /scripts/start-once.sh post install script:

git clone https://github.com/psu-hacking/iso-gen
cd iso-gen/scripts
chmod u+x start-once.sh && sudo ./start-once.sh
sudo reboot now

Visit /Disk-Speed-Testing for speed testing scripts and other info.

Visit /scripts for all install scripts and files for post install, Cubic utility, etc.

Visit /Alt-info_VBox_DD-Util for information on persistent, live environments from VBox VDI.

Make Your Own:

Thus far, the recommended way to get a persistent/live image installed is with two USB sticks:
One completely live (not persistent) Ubuntu drive, from which you can download and run the mkusb utility on the second USB stick.

Personal OS:

  • Download the official Ubuntu image here https://ubuntu.com/download/desktop
  • Download Etcher from here https://www.balena.io/etcher/
  • Use Etcher to burn Ubuntu to USB stick #1

USB stick #1:

  • Boot from the USB stick:
    • Mac hardware- hold the alt/option key when the machine turns on
    • Other hardware- hold the boot loader key (usually F12, or F2 / F10) when the machine turns on
  • Follow the Ubuntu prompts (please avoid the host hardware’s disk, do not install anything anywhere yet)

Open a terminal and copy these commands:

# get mkusb
sudo add-apt-repository universe  
sudo add-apt-repository ppa:mkusb/ppa
sudo apt-get update
sudo apt-get install mkusb mkusb-nox usb-pack-efi
  • insert USB stick #2
  • Open mkusb:
    • Follow prompts, psu-hacking iso should be in directory “home”
    • Select NO for “Quick Option” on host’s disk
    • Finish the prompts, quit, shutdown

USB stick #2: - Remove drive #1 - Boot from USB stick #2: - Mac hardware- hold the alt/option key when the machine turns on - Other hardware- hold the boot loader key (usually F12, or F2 / F10) when the machine turns on - Congratulate yourself, you are done!

Building the image:

On Ubuntu LTS

Note: mkusb utility is only available for Debian/Ubuntu

About persistent live Ubuntu:

When burned into a usb stick, this OS is completely self-sufficient and compatible with most (x86-64) computers- the environment, file system, preferences, etc are saved regardless of hardware.

Note:  Cubic utility is no longer used!

Links: https://launchpad.net/cubic

https://help.ubuntu.com/community/mkusb


https://psuhacking.club/

https://github.com/psu-hacking/static-site

Simple File Hosting

Static site built with Hugo CLI

Note, file "core_psu-hacking.iso" is omitted for size constraints- hosted site contains this file @ directory /static/static/

# on OSX
# get hugo

brew install hugo

# clone site

git clone https://github.com/psu-hacking/static-site
cd static-site

# Compile and compress public directory

hugo
zip -r site-archive.zip public

# upload and host with sftp & ssh

sftp user@yoursite.net
> cd yoursite.net
> put site-archive.zip

# new terminal window

ssh user@yoursite.net
# check your remote filesystem- the idea is:
> unzip site-archive.zip
> rm -rf yoursite.net/site-archive.zip

visit us


Also, check out the evolving PSU Hacking Club wiki here!

xD  - Jess

Summer 2019 Update!

GIS Updates:

Newish Raster / DEM image → STL tool in the Shiny-Apps repo:

https://github.com/Jesssullivan/Shiny-Apps

See the (non-load balanced!) live example on the Heroku page:

https://kml-tools.herokuapp.com/

Summarized for a forum member here too:  https://www.v1engineering.com/forum/topic/3d-printing-tactile-maps/

CAD / CAM Updates:

Been revamping my CNC thoughts- 

Basically, the next move is a complete rebuild (primarily for 6061 aluminum).

I am aiming for:

  • Marlin 2.x.x around either a full-Rambo or 32 bit Archim 1.0 (https://ultimachine.com/
  • Dual endstop configuration, CNC only (no hotend support)
  • 500mm2 work area / swappable spoiler boards (~700mm exterior MPCNC conduit length)
  • Continuous compressed air chip clearing, shop vac / cyclone chip removal
  • Two chamber, full acoustic enclosure (cutting space + air I/O for vac and compressor)
  • Full octoprint networking via GPIO relays

FWIW: Sketchup MPCNC:

https://3dwarehouse.sketchup.com/model/72bbe55e-8df7-42a2-9a57-c355debf1447/MPCNC-CNC-Machine-34-EMT

Also TinkerCAD version:

https://www.tinkercad.com/things/fnlgMUy4c3i

Electric Drivetrain Development:

BORGI / Axial Flux stuff:

https://community.occupycars.com/t/borgi-build-instructions/37

Designed some rough coil winders for motor design here:

https://community.occupycars.com/t/arduino-coil-winder/99

Repo:  https://github.com/Jesssullivan/Arduino_Coil_Winder

Also, an itty-bitty, skate bearing-scale axial flux / 3-phase motor to hack upon:

https://www.tinkercad.com/things/cTpgpcNqJaB


Cheers-

- Jess

Deploy Shiny R apps along Node.JS

Find the tools in action on Heroku as a node.js app!

https://kml-tools.herokuapp.com/

See the code on GitHub:

https://github.com/Jesssullivan/Shiny-Apps

After many iterations of ideas regarding deployment for a few research Shiny R apps, I am glad to say the current web-only setup is 100% free and simple to adapt.   I thought I'd go through some of the Node.JS bits I have been fussing with. 

The Current one:  

Heroku has a free tier for node.js apps.  See the pricing and limitations here: https://www.heroku.com/pricing as far as I can tell, there is little reason to read too far into a free plan; they don’t have my credit card, and thy seem to convert enough folks to paid customers to be nice enough to offer a free something to everyone.  

Shiny apps- https://www.shinyapps.io/- works straight from RStudio.  They have a free plan. Similar to Heroku, I can care too much about limitations as it is completely free.  

The reasons to use Node.JS (even if it just a jade/html wrapper) are numerous, though may not be completely obvious.  If nothing else, Heroku will serve it for free….

Using node is nice because you get all the web-layout-ux-ui stacks of stuff if you need them.  Clearly, I have not gone to many lengths to do that, but it is there.

Another big one is using node.js with Electron.  https://electronjs.org/ The idea is a desktop app framework serves up your node app to itself, via the chromium.  I had a bit of a foray with Electron- the node execa npm install execa package let me launch a shiny server from electron, wait a moment, then load a node/browser app that acts as a interface to the shiny process.  While this mostly worked, it is definitely overkill for my shiny stuff.  Good to have as a tool though.

-Jess

« Older posts