Thanksgiving Bannister 

I enrolled my kids and my parents and my sister, niece and brother in law in making decorations for our new bannister post. We drew animal themed shapes and Bob and I cut them out of some birch plank with my scroll saw. I used a plastic brush wheel in my drill press to clean up the cuts and sand away the pencil marks. A few pilot holes in each and I let the kids tack them into ace with small finishing nails.  

Challenge of Two Cases

Small and portable PCs are an attractive computing option. Unfortunately, they are at odds with much of the technical networking world. If you merely need one large graphics card or one beefy 10GbE networking card, you can get away with your MiniITX form factor system.

Contrast that with doing WiFi and wired network testing: often you want a system that can emulate an upstream network and emulate user clients on WiFi. This means two 1GbE ports to bond with a 4×4 Access Point these days. You can maybe get by with a mini ITX if it somehow had multiple 1GbE ports (like an AsRock Rack motherboard would), but that’s not the common request I’m hearing.

Let’s go for two 4×4 nics, 1 3×3 nic, and one 2x 10GbE card. Four slots. First challenge: a reliable MicroATX motherboard: a SuperMicro x11ssm-f will work pretty well. Second challenge: a case. Well, people often don’t consider a 2U rack mount case “portable.” The dimensions on that are often 17x14x3.5in. Most home theater PC cases are actually quite close to that size, or larger. Most of SilverStones HTPC cases are 18x15x4.5.

Antec has an attractive case: VSK2000-u3: 14 x 13 x 4in. This case can sit horizontal or vertical. It appears to be the smallest MicroATX case on the market. It comes with a 92mm case fan that is PWM* (once you strip and re-wire the plug). It requires a TFX power supply which limits us to 350W. This is sufficient, but we lack air draw thru such a small PSU.

Rosewill has a very small MicroATX case that might be more useful: 15.74 x 14.4 x 7.3in. This case is bigger. It’s a mini-tower and has a vertical tower orientation. Anything bigger might be harder to ship, but doesn’t have much bearing on the weight. We can fit an ATX power supply in this case, allowing us up to 750W with ease, and plenty of air draw through all parts of the case.

A desktop environment is the typical setting for a portable case unit. Fans are a challenge, and the premium silent fans (think Noctua) just don’t produce adequate airflow for such high heat density. We’re combining an 80W processor plus ~50W of network cards right next to each other with only about 30-50 CFM airflow through the whole case. Coolers that fit a HTPC form factor case come with 92mm x 15mm fans which move about 28-35CFM, and tend barely to keep the system below 73C. That is not adequate. A 2U server does a much better job at cooling at the cost of noise, however, with 3000RPM fans.

So which case is better? The smaller case that you have to discard your stock fans out of (discard the vertical heat sink fan for a 92x25mm ~50CFM fan, along with case fan)? Extra effort, waste. Or the bigger system that will allow a 120mm fan on a tower cooler?

Gimp multi-layer technique

When I work on a photo using the GIMP, I typically follow a technique that focuses either on the Grain Merge filter or the Value filter.

Before I decide the values for any filter, I create two layers, copied from the base picture:
– BW
– CE
And later I might create some masks or shade layers, and I’ll explain those later.

My base image:Screenshot at 2016-09-10 21:19:08.png
First: the desaturated layer (BW) I often use a luminance style desaturation, since that provides more intersting contrast. I might use the Brightness-Contrast filter on that layer afterwards, in order to boost that layers effect. When it comes to using that layer, recently I use it as a Value layer at full opacity. I used to use it as a Grain Merge layer at about 50% opacity, but I tend to find that effect too bold.

screenshot-at-2016-09-10-211748

Next, I use a color enhance step on the CE layer. This I tend never to use at full opacity, that would be absurd. I generally apply a color enhanced layer at about 20-40% opacity as visually appropriate. This helps me get to the saturation level I pre-visualized for the photo.

screenshot-at-2016-09-10-211847Recently, I’ve been using a channel-mixer layer. In this case, i clone the original layer as I would normally, but I choose to Channel Mixer, and often I pull down the blue and green channels to boost the golden or red hues of the scene. You don’t have to do this much, even 10% for each channel can be plenty. And when I do this, I might apply it as a Color or as a Soft Light layer in the mix.

Some times I apply some sharpening, but most of the time I tend not to, as Unsharp Mask can be a very heavy hammer to wield on a photo.

The combination of a desaturated Value layer enhances constrast, the channel mixer and or the color enhancement layer provides the color boost I typically want.  Some sharpening is optional. Please try the technique and let me know what kind of results you find!

spencer-spit-sunset-pano-4000x1080

Adopting Complexity 

Becoming a grey beard geek has involved adopting complexity. Some would assume unnecessary complexity… But other recognize ideal underneath the tangle: a challenge to master. 

Setting yourself a regular challenge keeps your hopes set higher than the horizon. Geek on! 

Updated Bash CPU Meter

In August, I did a post on a pretty simple bash cpu meter. This one is still Intel-only, but is records the range of frequencies used during a report.

#!/bin/bash
COLWID=17
MAXTURBO=4200
function find_lines {
   local i=0
   local j=0
   while read line; do
      if [[ $line =~ cpu\ MHz ]]; then
         cpu[i]=$j
         ((i++))
      fi
      ((j++))
   done < /proc/cpuinfo
}
function get_mhz() {
   mhz=()
   local cpulines=()
   local line hunks m L i c
   for i in `seq 1 15`; do
      c=0;
      readarray cpulines < /proc/cpuinfo
      for L in "${cpu[@]}"; do
          line="${cpulines[$L]}"
          hunks=($line)
          m=${hunks[3]}
          mhz[c]+="${m%.*} "
          ((c++))
       done
       sleep 0.1s
    done
}
# main
find_lines
while [[ 1 = 1 ]]; do
    COLS=`tput cols`
    mhz=()
    get_mhz
    cpunum=0
    for A in ${cpu[@]}; do
       lowest=0
       highest=0
       for H in ${mhz[$cpunum]}; do
         (( $H > $highest)) && highest=$H
         (( $lowest == 0    )) && lowest=$H
         (( $H < $lowest )) && lowest=$H
      done      
      outline=""      
      bars=$(( ($lowest * ($COLS-$COLWID) )/$MAXTURBO))
      for (( L=1; L<=$bars; L++ )); do
         outline=$outline"-"
      done
      bars=$(( (((1+$highest)-$lowest) * ($COLS-$COLWID))/$MAXTURBO))
      for (( L=1; L<=$bars; L++ )); do
         outline=$outline"="
      done
      d=$(($cpunum+9900))
      echo "${d##99} $lowest-$highest $outline"
      ((cpunum++))
   done
   echo ""
   sleep 0.1
done
#