BaSzErr - prjs

dyndns_update

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:51 +0000

dyndns_update

recently i started to use DynDNS service. to automatically manage IP changes on machine involved i wrote simple shell script. since it is on the router with OpenWRT installed, it includes IP-getting technique required there.

new feature is “-f” option to force IP updating. it is a good thing to do so from time to time, to prevent account removal after 30 days.

#!/bin/sh
USER="username"
PASS="topsi_kret"
DOMAIN="$USER.dyndns.org"
# metchod of getting current IP; this one's valid for OpenWRT/Backfire
IP="`ifconfig  eth0.1 | grep addr: | sed 's#^ *inet addr:##' | sed 's# .*##'`"
 
# get last set IP
LAST_IP_FILE="$HOME/.dyndns_last_ip"
touch "$LAST_IP_FILE"
LAST_IP="`cat "$LAST_IP_FILE"`"
 
# skip if not changed and not forced
[ "$1" != "-f" ] && [ "$LAST_IP" = "$IP" ] && exit 0
 
# update on change
wget -O /dev/null "http://$USER:$PASS@members.dyndns.org/nic/update?hostname=$DOMAIN&myip=$IP&wildcard=NOCHG&mx=NOCHG&backmx=NOCHG" || exit $?
echo "$IP" > "$LAST_IP_FILE"
exit $?

script in raw (i.e. text) form can be obtained here: dyndns_update.

img_randomizer

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:50 +0000

img_randomizer

img_randomizer is a short shell script that given a set of images randomizes one of them. it uses non-uniform randomization to prefer images that have not been selected yet (or have been selected less often then the others).

motivation

it is interesting alternative to typical tools for randomizing images to be placed on your desktop, since you won't get bored with old images that fast. i personally use it giving directory with my favorites images from trips, vacations, etc… each time i come back from trip, i get new images and put best of them into that directory. since they were not present before, they have higher probability of being selected. therefor i have recent images on my desktop more often.

download

you can download script here: img_randomizer.tar.bz2. current version is v0.3.2. note that current implementaiton does not required explicit config file – if it is missing, it will be automatically generated, with default values.

new version better handles big sets of images, containing thousands of images. it is faster as well.

configuration

after unpacking archive copy “img_randomizer” executable to your path (for example ~/bin). when run for the first time script will automatically create file ~/.img_randomizer/config. edit it, before usage.

there are 2 variables: ROOT and SEL_PNT that have to be set. ROOT is root directory containing images (searched recursively). SEL_PNT is points count to be added to image that has been selected – it makes images already seen less probable to reappear next time (the bigger value, the less probable it is).

that's all. now each time you run script, it'll return name of selected image as output.

plans_and_ideas

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:51 +0000

plans and ideas

this section describes projects that i plan to realize and some ideas that came through my mind. most of this will probably never be done, since 24h/day limitations but it's worth noticing that interesting idea came up.

TODO

print-if-error_shell

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:50 +0000

print-if-error shell

cron is a very nice and useful tool. it has a bit annoying mailing policy – it sends e-mail each time something is output on the screen, by the task being executed. in u*ix silence is gold. however there are commands that do no obey this rule (ex. gnu/make), mix stdout with stderr (ex. unix2dos), and so on… this is annoying, since each time job executes it sends an e-mail you're not really interested in. to silence bastard you need to redirect stdout and stderr to /dev/null. but wait! what if there actually IS a problem? what if your backups are no longer executing nightly? well – you'll never find out.

even if you discard only stdout, you still might be missing some context information, in case some script is more verbose by nature. when scripting it is often much easier to handle errors by aborting shell, and pointing out what's going on in case of longer running ones by echoing non-error messages. so in fact you're loosing some pieces of information.

solution

being sick and tired of this i've decided to write a wrapper to handle this. rules are simple:

mail should be sent ONLY if the command returned an error.
mail should contain the full output of the command.

wrapper script has been named printiferror – pretty self-explaining. :)

the initial solution used syntax for taking command and its arguments as parameters (the way time or exec commands do). the original crontab:

# ...
31 2 * * 0   ionice -c 3 nice make-backup --full
31 2 * * 1-6 ionice -c 3 nice make-backup --inc
# ...

evolved to:

# ...
31 2 * * 0   /usr/local/bin/printiferror ionice -c 3 nice make-backup --full
31 2 * * 1-6 /usr/local/bin/printiferror ionice -c 3 nice make-backup --inc
# ...

script works like a charm! what it does is save stdout and stderr in a temporary file and in case command fails, it prints output of that file on the console. this way cron mails only if the script fails.

solution 2.0

it is annoying to put printiferror command in front of all cron jobs. it is also error prone, by design (if you forget, by the morning you can end up with dozens of spam messages). this is why i went a step ahead – i've made this script behave as if it was a shell! thanks to this syntax using it is plain simple – one extra line in the crontab and we're done:

SHELL=/usr/local/bin/printiferror
# ...
31 2 * * 0   ionice -c 3 nice make-backup --full
31 2 * * 1-6 ionice -c 3 nice make-backup --inc
# ...

and voila! no spam, and in case of error, you get full messages.

download

you can download and use printiferror for free – enjoy. :)

prjs

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:53 +0000

projects

One man's “magic” is another man's engineering. “Supernatural” is a null word. – Robert Heinlein

some of my projects are listed below. hope you'll find them interesting too. :)

almost all of my projects are developed under GNU/Linux, mostly with gcc or clang – you will need these (and possibly some more) to build them.

i also use external servers for keeping repositories, with lots of projects, often not (yet) listed here, due to early stages of development. you can find me on:

software-hardware

some of my projects that combines software with hardware.

AVR Servo – multiple servo mechanism controller.
DNS-320 – Linux on D-link DNS-320 NAS
door light – micro-project of proximity sensor for LEDs light turn on.
T-20 EVO – Compaq EVO T-20 is thin-client PC-compatible computer without moving parts¹⁾. here is some short description how to install Linux on it.
TIER – mobile robot with simple mono vision system that i've made as my master thesis.
TIGER – new mobile robotic platform i work on.
USB power controller – power extension cord controlled via USB.
USMC – Universal Stepper Motor Controller.

software

software project that i do/have done.

beamer C++ template – easy to use presentation template, based on beamer, that makes presenting code (C++ by default) easier.
AxpLinCam – console tool for rotating pan/tilt AXP IP camera under linux.
build process – complete build process for C/C++ based projects written with Makefiles.
EZDlin – software for linux to flash uCs with zl5prg and zl6prg programmers.
LaTeX template – easy to use LaTeX template (+ some macros) for books/reports, with PDF build in Makefile.
system – C++ template library with some useful wrappers and helper classes.
team tools – collection of scripts to perform rebase and deliver operations. very useful when working in teams and on separate branches.

3d prints

projects made with 3d printer.

toothbrush holder – holder for classical toothbrushes.
LCD case for prusa i3 – case for electronics and LCD for Prusa i3 printer.
filament holder – holder for filament w/o own spool.
filament spool holder – holder for filament with own spool, of different sizes.
braun oral-b brush holder – multiple users? not a problem any more… :)

misc projects

very small projects (programs/devices) i've done, plus some, that do not fit in other categories.

dyndns_update – script updating dyndns entry.
img_randomizer – non-uniform distribution image randomizer.
print-if-error shell – pseudo-shell to smart-send cron outputs.
rand_junk – high-speed pseudo random generator.
rootn.bc.bz2 – script computing n'th root of given number with given precision. written in bc.
sledge – sledge with spring, created during my last days off.
usb2ttlrs – USB to TTL-level RS-232 converter.

abandonware

this is section for the projects that were introduced on this site but, for some reason, are no longer maintained.

graphics – C++ template library for manipulating images.
vectors – C++ template library for manipulating multidimensional vectors.

¹⁾

this page was previously hosted on one of these.

rand_junk

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:50 +0000

rand_junk

few times i've found a need of getting large amounts (tens..hundreds of gigabytes) of pseudo-random data, where randomness is not as important as speed of it's generation.

this software is on revised-BSD license.

common use cases

typical example is preparing hard drive for an encryption. using /dev/urandom with reads about 8MB/s takes ages to fill modern-sized drives, and initial filling of them is just a way to prevent easy estimation where the data really is.

another good example is checking/comparing the compression level of different algorithms. just render few random files and try to compress them with different packers.

testing high-speed networks bandwidth can be a case too. thanks to this you minimize influence of compression, that might be provided by underlying protocols. after sending and receiving such a data you can check their checksums as well, to check if it works fine.

tool and usage

this is where this program comes in – it generates pseudo-random junk to stdout at the speed of about 0.7GB/s, on a casual PC. this is sufficient to saturate modern drives, by the the order of magnitude.

usage is simple. to build just type 'make'. Makefile is prepared to handle gcc 4.6 and gcc 4.7, since program uses C++11 features. to generate 100GB file of pseudo-random content just type:

./rand_junk.out 1001024 > my_rand_file.bin

there is also a simple tool that shows how much of a different characters there was on an input (i.e. distribution of output bytes):

./check.out < my_rand_file.bin

note that 'check' tool is just a simple checker and was never optimized, thus is MUCH slower than 'rand_junk'.

how does it work

the idea is simple – it reads 1MB of pseudo-random data from the /dev/urandom and launches two threads:

constantly reading new content from /dev/urandom
doing some pseudo-random modifications at a high speed (xoring with random values, etc…)

at the same time main thread is constantly outputting buffer's content on the stdout, until specified amount of data is produced. to make data even more equally distributed it also does xor of data with the previous content, in each thread, before publishing. all of this happens in parallel (separate threads), thus making output “random enough” for many typical usages, where huge amount of pseudo-random data is needed.

download

you can download rand_junk and do what ever you want with it. :) current version is v2.0.1.

sledge

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:50 +0000

sledge

motto: “if it smells it's chemistry, if it crawls it's biology, if it doesn't work it's physics”.

at the begin of february 2009 i had few days off which i've spent at my home city. wanting to do something unusual this time i've decided to create sledge of my own invent. you can but a lot of them in different stores for very low prices, but the fun is not the same… :)

sledge has been optimized for sledge running. :)

total cost of project was around 150PLN (~25EUR) + painting (i haven't done this yet ;)).

main ideas

there are two ideas that i wanted to implement in the construction:

slanting runner
seat with a spring

first idea is to make sledge more stable when going through curves. when runners are made from closed profile of rectangular shape and are under some angle to the ground, when one runner goes up the second one gives extra friction which helps getting back to initial position.

second idea is obvious – when doing sledge running behind a car, riding with higher speeds (let's say: 40-60[km/h]) “meeting” hole in the ground can be painful… ;) having spring (part of absorber) can minimize this unpleasant effect plus can give you additional fun when riding on highly-hollow ground. :)

the mechanics

having in mind technical problems i've decided to resign from making slanting runner under some angle to the ground. mayby next time, when i'll have more time and patience… ;)

making amortization with a spring appeared to be a bit more tricky. after talk with Kuba we've decided to use horizontal configuration (horizontal spring) as shown on the picture: where colors are:

black – main construction (welded)
green – spring mounting and a screw to connect both ends (long one :))
yellow/black – spring itself
blue – silentblock
red – strut-like element that makes crucial structural part far more resistible

silentblocks are place at the both sides of sledge. this allows moving seat up and down under the pressure, which in turn squeezes spring.

parts

details you'll need are:

spring – you can but these as a part of car suspension (absorber is not needed here – spring itself should give more fun :)) at the car dumping places (in polish: “szrot” :)).
spring's mounting – it is best to ask lathe hand to do this for you in metal. shape depends on spring's mounting parts you already have bought with a spring.
two silentblocks.
wood for covering the seat.

in addition you'll need following metal parts (all are closed profiles):

name	type [mm]x[mm]	length[cm]	count
runners	20×50	100	2
back column	30×30	11	2
back cross-bar	30×30	40	1
front column	30×30	20	2
front cross-bar	30×30	34	1
suspension's transmission	30×30	20	1
seat sides	30×30	70	2
seat ends	30×30	34	2

i've also used 4 flats 4[mm] thick, 40[mm] wide and 5[cm] long to mount silentblocks. to make mounting of spring easier i used pipe 90[mm] in cross-section and 90[mm].

improvements made

since project has been initially started (last year, i.e. 2009) i've added 2 small improvements:

addition of strut in place where the strongest forces are present.
added small fenders on the back of the construction, to avoid metal-metal hitting when running high-speed.

i used small piece of thick, metal plate as a strut. i've welded it to both elements, right in the corner, on the both sides. in place of small fenders (ex. like the ones used to block the door from opening too wide) i used tight rope that's doing just fine and does not need that much space and so the spring can move in a bit wider ranges.

both improvement can be seen on the images.

field trials and observations

yesterday²⁾ i've finished field trials – riding down the nearby hills. :) my first observation was that this sledge ride totally different from any one i had a chance to ride ever before! they ride very fast and through the vast range of snow. they ride well on ice/polished snow, just like any others, but they ride very well on fluffy snow as well. from my experience most of the sledges just “dived” into such a snow and stopped, while this one just runs it by! and so the speed is really good, nearly despite of the hill you're riding on.

when welding metal parts last year i got lazy and resigned form slanting runners in favour of regular, “flat” runners (0[deg] angle to the ground). this happened not to be the best idea, since flat runners are responsible for poor manoeuvrability, especially on low speeds. whey you ride faster, you can influence it a bit, but when speed is normal/slow sledge usually just run down the hill.

there is an interesting feature though – since turning direction is so hard, it is easy to rotate it a bit when riding down the hill and keep running in a slide with some angle to the running direction. in practice it is possible to slide in about ~30[deg] constantly. it gives and interesting impression when doing for the first time. :)

since sliding is easy, you can break easily too! when your road ends you can just slide at a higher angle and this will slower you a lot and change direction (when you're on flat area, already off the hill) so in about 2-3[m] you can make 90[deg] turn and stop sledge. on sledges i ride in the past this would be sure crash'n'roll situation.

sledge's construction is pretty heavy – i estimate it to be around 15[kg] in total! and here comes additional feature - since they're heavy and wide, whey're very stable when moving – it's not so easy to roll over on them. until now it happened to me just once, when i was sliding under about 45[deg] and hit small hole in the snow. it was kind of fun – boy, i was sure surprised… ;)

special thanks

last but not least i'd like to give special thanks to Kuba Szurgot for helping getting things done right: starting with the initial concept, helping with choosing proper materials and on searching for them finishing. additional thanks i'd like to direct also to Andrzej Szurgot for giving access to his workshop, where dispite of all you need, you can find more than you can imagine… ;)

²⁾

2010.01.15

usb2ttlrs

anonymous@undisclosed.example.com (Anonymous) — Tue, 15 Jun 2021 20:09:51 +0000

usb2ttlrs - USB to TTL-level RS-232 converter

while working with microcontrollers it is often required to communicate with the computer or other piece of hardware. since nearly all uCs have USART it is a natural choice. the bad news is that RS-232 uses voltages way beyond typical +5V. thus, before connecting to the PC, level conversions need to be done. this is not all - nowadays it is very uncommon for a PC to even have RS-232 port! on the other hand USB is widespread.

the key of this nano-project is to enable easy communications with the uC, that operates on +5V USART, to talk with computer via USB.

there is a nice chip that provides USART to USB conversion, that is 100% USB compatible and does not require any extra hardware parts, nor software on uC side. may i introduce, the hero of this article - FT232. :) the board itself is trivial - one connects USB on the one and and GND, RX, TX, RTS, CTS on the other. for many applications it is just enough to short wire RTS with CTS (no flow control).

though device is simple, it is very useful when debug communication is required fast. board schematics and PCB layout can be obtained via USB2TTLRS project on github. there are recent releases available via tags as well.

license is revised BSD - feel free to do whatever you want with it.

a bit beyond the scope of this project, but it is worth mentioning an interesting tool for linux, to set FT232 parameters – ft232r_prog. FT232 chip has an interesting features that allows setting multipurpose pins to do interesting stuff, like giving accurate clock for uC, or enabling signal for sleep modes. this is an open source program that does it from the command line. enjoy! :)