Saturday, September 3, 2016

Windows Console on Demand in Go

There are two kinds of Windows programs: Windows GUI or Console Application. There could be third case:  process, which does not have any visual representation at all and needs to be running in the background. For that case program maybe be built as Windows GUI, but it should not have any code, which creates Windows objects.  But what if  you want from application sometimes  to be silent and sometimes  to be verbose and to have a console. Possible use cases are:
  • Printing version of the utility if started with special flag (like -V)
  • Program needs complicated turn up through the  command line arguments or configuration file, but normally is  running on the background. It would be beneficially to have a choice either run it with console or run it quietly.
That could be achieved by compiling application as Windows GUI and allocating  or attaching console to the process during run-time if needed. There are a lot of examples how to do that in C/C++. When I myself looked for the solution several years ago I have found this link  helpful. Fragment of the code, which creates console may look like this.

 // taken from: http://www.codeproject.com/KB/dialog/ConsoleAdapter.aspx

 AllocConsole();
 int fdout = _open_osfhandle((long)GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT);
 FILE* fout = _fdopen(fdout, "w");
 *stdout = *fout;

 int fdin = _open_osfhandle((long)GetStdHandle(STD_INPUT_HANDLE), _O_TEXT);
 FILE* fin = _fdopen(fdin, "r");
 *stdin = *fin;


Nowadays I found myself  programming more and more in Go. While initially Go compiler was intended for Linux only,  that is not the case anymore. Windows now is the first class citizen in the Go word. Recently I needed to create application, which may open the console if that demanded by  command line argument, but work invisibly  otherwise . To my surprise there were not that many online information how to do that in Go. I did find one answered question in StackOverflow. Alas, proposed solution did not work for me out of the box. But using it as starting point and after some googling I have found workable solution. Here is sample of Go application, which will allocate console, print some prompt, wait for keyboard input and quit.

// go build -ldflags -H=windowsgui
package main

import "fmt"
import "os"
import "syscall"

func main() {
 modkernel32 := syscall.NewLazyDLL("kernel32.dll")
 procAllocConsole := modkernel32.NewProc("AllocConsole")
 r0, r1, err0 := syscall.Syscall(procAllocConsole.Addr(), 0, 0, 0, 0)
 if r0 == 0 { // Allocation failed, probably process already has a console
  fmt.Printf("Could not allocate console: %s. Check build flags..", err0)
  os.Exit(1)
 }
 hout, err1 := syscall.GetStdHandle(syscall.STD_OUTPUT_HANDLE)
 hin, err2 := syscall.GetStdHandle(syscall.STD_INPUT_HANDLE)
 if err1 != nil || err2 != nil { // nowhere to print the error
  os.Exit(2)
 }
 os.Stdout = os.NewFile(uintptr(hout), "/dev/stdout")
 os.Stdin = os.NewFile(uintptr(hin), "/dev/stdin")
 fmt.Printf("Hello!\nResult of console allocation: ")
 fmt.Printf("r0=%d,r1=%d,err=%s\nFor Goodbye press Enter..", r0, r1, err0)
 var s string
 fmt.Scanln(&s)
 os.Exit(0)
}
I would like to point some details about syscall.Syscall invocation for AllocConsole :
  • This function  has five arguments. It is different of what you will find in the online Go Doc . Looks like doc references Linux definition, which is not the same as Windows.
  • Second parameter here is number of arguments in dll function. For our case it is 0.
  • Function returns three variables, but only first is really meaningful. It is the result returned by AllocConsole function. Second variables always 0. Third variables  is an  error, but in cannot be analyzed in the regular Go way as far as it is never nil.  Still it could be useful: in case of success its value is different from value on failure (for example if application was build with no windowsgui flag and already has the console ) .


Saturday, April 9, 2016

Not for Insulation Only

Hobbyist and DYI makers very often extend usage of elements and components beyond its usual assignments.  I would like to share with you one such a case. 
Whenever you drill through the wooden or plastic sheet you has to be really careful not to drill through. The common well know method to prevent that is to use tape or scotch wrapped around the drill bit. Once I was out of tape and had to look for substitution. Piece of  heat shrink tube came in handy. It fitted drill bit exactly, I just needed to cut proper length of it. That was very lucky finding. I entirely stopped using tape for this task and switched to heat shrink or straw tubing. Especially convenient it becomes  for projects which  needed drilling with the same drill size but with different depth. Switching between tubes can be done in a second.  
The best result is achieved when tube sits tight  on the drill bit. In case you does not have exact heat shrink size, you may cut tube, which is too narrow,  alone. It will still work.  But you need to be more careful to stop drilling right at the moment when tube touches the surface. Otherwise it may be torn away by drill rotation.

Heat shrink actually suited for various tasks. I even   published blog, picturing some of  them : http://www.instructables.com/id/Not-for-Insulation-Only/,  Here is list from that blog in a short:
  • Controlling depth of drilling (that idea you actually see here).
  • Using heat shrink while hanging picture  on sheet rock wall
  • Protecting awl tip
  • Keeping tweezers tips together. 
  • Making paper clip to work better. 

That topic got some attention and was even featured by one of the site editor.  Author Phil B told me about one more usage of heat shrink:  fixing claps on kindle reader case. I am sure there are many more cases which extends usage of heat shrink tubes.


Sunday, January 11, 2015

Computer Desk Hutch with Sit or Stand Option

This project is a remake of the DIY project "Sit-n-Stand monitor station" described in the my old post: How did I join the Uprising. Recently my family moved into the new house and a lot of old stuff including some of DIY things did not survive the moving. I have to make the  station again. This time it  looks less DIY and more furniture like  (I hope). The basic principle is the same: desk with monitor moves up and down within sides sliders. Pulley system with counter weight compensates gravity force making moving easy. But there are some  differences:
  • Instead of single pulley line in the middle of the desk there are two lines on both sides of the desk.
  • I made desk as light as possible (but without any sacrifice of sturdiness).  
  • Light desk allowed me to switch from 3-times advantage pulley system to 2-times advantage system. As a result of that counterweight moves withing the boundaries of the hutch.
  •  I mounted  two shelves in the inner side of the hutch making some use of hutch volume.
Detailed steps of this project is published on the "Instructables" site right here: Sit&Stand Computer Desk Hutch . I even submitted it to couple of "Instructables" contests.  I cannot tell that submission made the big splash but project got some attention. While it does not win first prize it reached one contest final and here is my award: "Instrcutables" robot t-shirt. 


Saturday, November 1, 2014

Business Card Holder with $805 Price Tag



No, I did not pay that many for this cardholder. I am not even sure I ever will pay $5 for any  cardholder. I got mine completely free. It was taken  out of computer, which was prepared to be utilized by E-waste service. Processor passive cooler  grabbed my attention and pretty soon I have found some use in it. That was an easiest project I ever made. Out of curiosity I did the online search to find out the pedigree of this beast.   And here you can see the result.

Indeed it has a spectacular specification and outstanding price. That money may buy you Apple MakBook Air nowadays. Why people complain about an inflation?

Friday, July 4, 2014

Useless Machines, Atmel Controllers & Protothreads


This is the project I made in 2010 as a response to the publication about useless machines in Make Magazine1. In overall excellent article there was one statement which looked controversial to me. Author stated that a machine with a microprocessor does not cut itself completely off power and from that point of view cannot be fully qualified as useless machine. This is not true. Sure you can build a machine with microprocessor which at the end of cycle cuts itself off power. And here is its wiring diagram of the machine from the clip above.

As central component this project utilizes Pololu B-168 controller 2 with Atmel ATmega168 as a brain. In addition controller has two H-bridges for bi-polar load. One bridge in this project controls the motor, another controls the reed relay which keep the machine on power disregarding of the control switch state. To eliminate toggle switch (the reason for that you can read here) I designed the push button custom made out of two micro-switches. To justify presence of the controller more complicated task assigned to the machine. This task could be described in in these statements:
  • The Machine waits till tester hits the button. With first hit turn itself on.
  • Thew Machine waits some time if there is no hits anymore.
  • The Machine calculates the number of hits.
  • If pause after last hit is big enough working cycle begins and the machine arm hits button as many time as tester did.
  • At the end machine cuts itself off power.
While preparing this post I decided to rewrite program having in mind to try one well known but new to me technique, namely Protothreads 3. This is the framework based on C language trick which allows operator switch to be embedded inside C code blocks like if, while or for. Such obscure language feature allows to use case statements as breakpoints where the task may yield execution to other tasks and from where it can resume execution when it gets the control next time. For the detail explanation I would reference you to author website. After reading it you will understand why not everyone in programming community accepts these ideas and why there is no known company which includes it into the corporate coding standards. But for hobby project I can use whatever I like, right? Fragment of the code below contains protothread routine which implements machine working cycle 4.

// script routine
int protothread(struct pt* upt)
{  // called each timer interrupt 
 static int count=0, ix;
 static u_time timer;
 PT_BEGIN(upt); // PT_INIT is called form the main function
 // just in case to avoid race condition at the end
 PT_YIELD_UNTIL(upt,isButtonPressed());
  
 turnRelay(DeviceON); // keep device powered 
 turnMotor(DeviceOFF);
 turnLED(DeviceOFF);
 do { // counting cycle
  PT_WAIT_UNTIL(upt,isButtonReleased());
  timer = schedule(750);
  count++;
  PT_WAIT_UNTIL(upt,isExpired(timer)||
    isButtonPressed());
 } while(!isExpired(timer));
 
 for(ix = 0; ix != count; ++ix) { // working cycle
  turnLED(DeviceON);
  turnMotor(DeviceON);
  PT_WAIT_UNTIL(upt,isButtonPressed());
  turnMotor(DeviceOFF);
  timer = schedule(20);
  PT_WAIT_UNTIL(upt,isExpired(timer));
  turnMotor(DeviceBACKWARD);
  turnLED(DeviceOFF);
  PT_WAIT_UNTIL(upt,isArmDown());
  turnMotor(DeviceOFF);
  timer = schedule(20);
  PT_WAIT_UNTIL(upt,isExpired(timer));
 }
 turnRelay(DeviceOFF); // kill the machine
 timer = schedule( 20);
 PT_WAIT_UNTIL(upt,isExpired(timer));
 PT_END(upt);
 return PT_EXITED;
}

See for yourself but to me it looks like good pseudo code which expresses program logic in clear and conscious way.
And at the end some observations from my limited experience with protothreads:
  • All yields/resumings of particular protothread have to be in the same protothread routine, in other words you cannot spread switch case statements across more then one function.
  • Protothread states must not be stored inside local auto variables, only static or global variables have to be used.
  • When working with Microsoft Visual Studio projects you must change default project setting of Debug Information Format field from Program Database For Edit and Continue (/ZI),to Program Database(/Zi). Otherwise your program will not compile.

1 Brett Coulthard. '"The most useless machine" (Issue 23 of Make Magazine). 2010
2 You cannot buy it anymore but there is the substitution with a better functionality in the same package but with slightly different wiring.
3Protothread Home Page.
4 The whole source code is available at this storage.

Sunday, June 15, 2014

From the Garage to the Kitchen

People use pegboards as garage tool organizers. This is well-known fact. Sometimes pegboards are used inside kitchen to arrange cooking spoons, knifes etc. This is not so well-known but still an old trick. In this project I put pegboard inside the picture frame. Picture frame serves here two purposes: it strips pegboard off its garage-like look and it makes process of installation easy.
Project is very simple. First you need to choose the proper frame. Be sure that it has two hangers (if not you have to install them yourself as I did). Then cut the proper size pegboard, put it into the frame and hang the organizer on the kitchen wall.

Now you can invite the chef to arrange cooking tools in a convenient and aesthetic way.

Thursday, May 8, 2014

Wall Clock with Atmel Microcontroller

Time measuring devices always look special to me.  I admire the royal nobility of a tower clock,the steady pace of a pendulum mechanism, the instant obedience of a stop watch. Eventually I decided to build one such device myself. While making a mechanical device is out of my ability, building an electronic clock is a relatively easy task. All that you need nowadays is a few inexpensive  components, rudimentary soldering skills and some programming experience.  







The clock above is what I made for our bedroom (thanks to my wife who allowed me to put this creature on the wall).
What is special about this clock: 
  •  It is a twenty four hours clock with accuracy up to one minute.
  • It uses a single active component: Atmega328 controller, which keeps the time and controls LEDs without help of any external microchip.
  • Time accuracy is provided  by an external oscillator while internal oscillator provides processor working frequency. 
  • Technique known as charlieplexing is used to handle the number of  LEDs exceeding number of controller's  I/O pins. 
  • This bedroom clock  possess an important feature: it can turns light OFF  and ON according to the schedule. This way it's light does not distract us during sleep time but allows easy time reading at dawn.
Let us describe the clock interface. This clock has two dials: inner (yellow) dial for hours and outer (green) dial for minutes. These two dials provide time reading with accuracy up to three minutes. Three correction  LEDs in the middle improve accuracy up to one minute.

Rules to read the time are simple:
  •   During AM hours single LED is turned ON  showing current hour. LED which points to XII hour  is always OFF.
  • During PM hours group of LEDs are ON staring from the LED which points to XII LED and ending with the current hour. 
  • Next LED is switched ON when there are two minutes left till the start of new hour.
  •  Each green LED of outer dial represents 5 minutes interval. LED which point to 60 minutes is always ON  as well as LED next to the current minute and all LEDs in between. This way the clock provides at least three minutes accuracy.
  • Three LEDs in the middle allow time correction:


Pictures below illustrate time reading rules.

Clock contains this set of components:
  • Atmel controller. I have used Atmega 328 but less powerful controller could be used as well.
  • Clock oscillator 32768 Hz.
  • Thirty LEDs (5 mm size).
  • 15 resistors 51 Ohm each (0.25 or 0.125 does not matter).
  • Radio Shack protopype board (catalog number 276-170)
  • Two three pins  headers (to build ISP connection between controller and PC)
  • Capacitor 0.047 micro farad 
  • Encoder to set up clock time. I have used Panasonic EVQ-WTEF2515B
  • Hookup wire and old IDE cable.
  • Power supply 5 V. It must provide at least 300 mA of current. I have used supply from old Sharp  handheld computer.
These components are connected according to the circuit diagram below:
To make soldering of  four LEDs to the single resistor I  prepared the board by making some cuts with a knife.

Here is how the board looks after soldering of all components.

I decided to use as a clock plate the wooden board from Michael's. As you can see I did not try hard to make it strictly symmetrical, having in mind the asymmetrical shape of the board. 

The clock was programmed with help of Atmel  studio 6.1 in C language. Source code and project file are  available here https://bitbucket.org/jumbleview/clock30/src.

Setting the time is not hard. For that three LEDs at the back of clock are used:

To set the time there is the need to follow next steps:


  1. Push the encoder: reserved LED is turned on
  2. Rotate the encoder to choose value you want to set (hour or minute).
  3. Push the encoder  again, now clock are ready to set the value.
  4. Rotate the encoder to set the proper value.
  5. Push the encoder again: the value is set.

To set the other value you  may repeat steps 1-5.

And here is the movie, which shows process of setting clock minutes.

video