A friend who recently acquired a CO2 laser cutter for his school sent me a message. “What is the difference between a laser that will cut metals and one that won’t?”. I thought this is a good question, as the answer will help with understanding how to work with many materials.

But before the answer will make sense, we need to revisit the basics of how a laser cutter works in more detail.

How the laser cutter works: 101

The common C02 laser cutter can be thought of as “thick” beam of IR light that moves out of a laser tube, bounces of mirrors until to get to the head. In the head it passes through a lens that focuses the beam, such that it is strong enough to ablate certain material though heat. A jet of air clears debris, and if upgraded from the piddly inbuilt compressor, will minimise scorching on materials like wood. The fact the beam is wide means that it can be bounced around off mirrors wit out imparting too much energy to one spot, such that it burns though a mirror, or the lens.

How the laser cutter works: 102

Now think of a laser cut in slow motion and zoomed in massively.  The laser hits a material. The focal point is probably beneath the surface and the beam is still a bit wide (less hot).

The area at the surface vaporises and a little pilot hole forms. This hole is like the first domino, the material near it is now deformed. This deformed material (sub millimetre area) is like the plastic left in the sun, less robust and more sensitive to light. The cut now picks up momentum and deepens as a “pool of vaporising material eating into the ground”. The air stream is ejecting loose material and anything ‘molten’ that was not instantly vaporised.

The ability to cut well is a balance of many factors, primarily the right laser strength, air flow and movement speed – for a given material at a certain thickness.

Relevant to later discussions with metal, is getting a good movement speed.

• Slow enough that the pit will work all the way through, before the beam moves on.
• Fast enough that the material is not given too much heat (see diagram to right, not all the beam is vaporising goodness and its not all equal in strengths.
  • From the parts of the beam not near the focal point that are not hot enough .
  • From outer areas of the beam not as intense
• Different lenses will help with thicker materials, butt you first limitation is you will need more power for thicker materials. Otherwise you will need to move at a slow speed that brings many other problems of heat dissipation.

Reading the above may lead you to think you will need to get the most powerful laser cutter you can afford, for those times when you want to do a thick material. But… power is a two edged sword. The laser will only fire at a minimum of say 40%. So your 120W laser that will get you through 20mm acrylic, won’t be any good for etching designs on clothing (it will punch straight through at it minimum of 48W).

Problems that will affect metal

• Many metals are reflective of IR beams (C02 lasers), preventing even etching of the surface.
  • NB: other lasers, such as solid state lasers which work with a different wavelength will be several times more efficient than C02 lasers for most metals.
• Metal is a heat sink, it will draw heat away from the cut. Preventing the laser beam from melting any of the metal, or forming the initial pit.
• Many metals are not cool/safe in gaseous form. You may need venting.

Etching metal

Your enemy for etching, is not the heat conductivity of the metal, it’s the fact it reflects.
On cutters around your size it is often possible to etch certain metal. You will need to paint the surface with something (there are products that are sold for this purpose, but some people just use black $3 fiddly bit paint from buntings). The pit will form in the paint and you will get sufficient heat in to mark the metal. But then go no further down.

Cutting metal

Generally laser cut metal is not ablated/vaporised (turned to gas) like other materials. It is instead it is melted (turned to liquid), and blown out of the way by forced airflow. This is sometimes referred to as ‘melt and blow’ cutting. It is messy and provides issues that can damage a machine:

• Bits of molten metal can settle on the lens, this will absorb heat that the lens would otherwise transmit. The lens will now heat up and be damaged / burnt though.
• The metal / molten metal can reflect focused beam of light back at the lens. This can damage the lens, because the amount of IR radiation passing though it is now double.
  • The focused light can even propagate back along the mirrors and into the laser tube (damaging the very expensive parts of the machine).

Its worth mentioning that metal needs a lot more power to get the piloting pit going. And the pit is not a nice vaporised area with laser friendly material next to it. It’s a stubborn pool of liquid that sits in the way of your laser. This means cutting requires bigger lasers, or one or more assisting technologies to reduce the necessitated “bigness” of your laser.

Such assisting technologies, for CO2 lasers, may include.

• High pressure gas, to blow the molten metal out of the hole.
• Blowing Oxygen or Nitrogen into the cut to make things more efficient.
• Using a more focused beam to get the metal to melt before heat dissipation sets in.
• A lens that moves, so that the focal point travels with your pit as it goes down.

As some lasers can be coerced into cutting metal, why is it not more common?

Firstly, the risk to the machine means many operators don’t feel it is worth it.

But there are other issues:

• Solid state lasers are becoming more popular for cutting metal over the use of a large C02 Laser.
• The cut speed of lasers on metal can be slow, and the depth of cut limited.
• Tuning air/ laser/ lens /speed parameters is more difficult, and the results are not always a clean cut for inexperienced operators.

But more importantly there are many more attractive  alternatives for cutting of metal, including water jet cutting and CNC milling.

Further reading:

For clarity I simplified and glossed over some less important concepts in the above explanation.

The following industry articles explore things in more depth:

• Laser comparison – cutting speed and rate of feed. http://jmtusa.com/laser-comparison-cutting-speed-and-rate-of-feed/
• Lasing reflective metals http://www.fsmdirect.com/cutting/laser-cutting/326-lasing-reflective-metals
• Back to basics: The subtle science of burr-free laser cutting. https://www.thefabricator.com/article/lasercutting/back-to-basics-the-subtle-science-of-burr-free-laser-cutting

Rule of thumb. If you would you would not be happy with this kind of material on the surface of whatever you are coating, remove your finger prints.

• So a very thin coat of paint is 0.02mm, but often thicker.  So wash your hands, then it’s probably OK to touch. But don’t “Pizza and Paint”.
• Thermal paste on your CPU is 0.07mm  to 0.12mm thick, So Pizza hands are a definite problem. A single normal finger print may well produce a small but noticeable effect to cooling. A well handled CPU with a few prints is probably not good, you would not leave scraps of plastic wrap on the CPU after all.
• Some glues may dilute your finger print and not care (super glue). While other (silicone adhesives) will probably bond poorly.
• Solder – The NASA soldering standards (NASA_STD_8739 .3) state: “When handling metal surfaces that are to be soldered is unavoidable, clean, lint-free gloves or finger cots shall be used. “. Many commercial soldering standards also follow this advise for handling of both solder and parts.
  • Whats interesting is that some manufactures are particularly concerned about what is on your hands (moisturisers and hand lotions cited as being particularly problematic to solder).
  • The finger print contamination of solder joints is often resolved by just keeping the joint hot until the solder takes. This extra heating burns of enough contaminate to allow solder to flow, but can damage components amongst other problems.
  • UPDATE: The new IPC standards (IPC-J-STD-001ES), which NASA, and many other companies, have adopted, don’t mention fingers or gloves specifically. They only broadly reference that handling mechanisms stall not contaminate the board or parts.

Managing arduino projects can be a nightmare because you only see the software side in your code documentation, the hardware is hard to keep track off.

To enable easy documentation of pin assignments, I created a couple of ASCII art arduinos; complete with ports, PWM and coms all marked. Simply paste as a comment into your code and marvel at your new found organisation.

I suggest altering the image (eg. a letter or X in the [ ]) to keep track of the pins you ended up using.

Find this project on gitHub

Plain Text – Arduino Pinout

Here is copy/paste-able Arduino Pinout ASCII art ready to go (tip: you can use the copy button, at the top of each ASCII art piece, to make the process easy).
     I place them in the Creatice Commons [Creative Commons Attribution (BY) license].
     Attribution via the url: “http://busyducks.com/ascii-art-arduinos”

                                      +-----+
         +----[PWR]-------------------| USB |--+
         |                            +-----+  |
         |         GND/RST2  [ ][ ]            |
         |       MOSI2/SCK2  [ ][ ]  A5/SCL[ ] |   C5 
         |          5V/MISO2 [ ][ ]  A4/SDA[ ] |   C4 
         |                             AREF[ ] |
         |                              GND[ ] |
         | [ ]N/C                    SCK/13[ ] |   B5
         | [ ]IOREF                 MISO/12[ ] |   .
         | [ ]RST                   MOSI/11[ ]~|   .
         | [ ]3V3    +---+               10[ ]~|   .
         | [ ]5v    -| A |-               9[ ]~|   .
         | [ ]GND   -| R |-               8[ ] |   B0
         | [ ]GND   -| D |-                    |
         | [ ]Vin   -| U |-               7[ ] |   D7
         |          -| I |-               6[ ]~|   .
         | [ ]A0    -| N |-               5[ ]~|   .
         | [ ]A1    -| O |-               4[ ] |   .
         | [ ]A2     +---+           INT1/3[ ]~|   .
         | [ ]A3                     INT0/2[ ] |   .
         | [ ]A4/SDA  RST SCK MISO     TX>1[ ] |   .
         | [ ]A5/SCL  [ ] [ ] [ ]      RX<0[ ] |   D0
         |            [ ] [ ] [ ]              |
         |  UNO_R3    GND MOSI 5V  ____________/
          \_______________________/
		  
		  http://busyducks.com/ascii-art-arduinos

                                      +-----+
         +----[PWR]-------------------| USB |--+
         |                            +-----+  |
         |           GND/RST2  [ ] [ ]         |
         |         MOSI2/SCK2  [ ] [ ]  SCL[ ] |   D0
         |            5V/MISO2 [ ] [ ]  SDA[ ] |   D1
         |                             AREF[ ] |
         |                              GND[ ] |
         | [ ]N/C                        13[ ]~|   B7
         | [ ]IOREF                      12[ ]~|   B6
         | [ ]RST                        11[ ]~|   B5
         | [ ]3V3      +----------+      10[ ]~|   B4
         | [ ]5v       | ARDUINO  |       9[ ]~|   H6
         | [ ]GND      |   MEGA   |       8[ ]~|   H5
         | [ ]GND      +----------+            |
         | [ ]Vin                         7[ ]~|   H4
         |                                6[ ]~|   H3
         | [ ]A0                          5[ ]~|   E3
         | [ ]A1                          4[ ]~|   G5
         | [ ]A2                     INT5/3[ ]~|   E5
         | [ ]A3                     INT4/2[ ]~|   E4
         | [ ]A4                       TX>1[ ]~|   E1
         | [ ]A5                       RX<0[ ]~|   E0
         | [ ]A6                               |   
         | [ ]A7                     TX3/14[ ] |   J1
         |                           RX3/15[ ] |   J0
         | [ ]A8                     TX2/16[ ] |   H1         
         | [ ]A9                     RX2/17[ ] |   H0
         | [ ]A10               TX1/INT3/18[ ] |   D3         
         | [ ]A11               RX1/INT2/19[ ] |   D2
         | [ ]A12           I2C-SDA/INT1/20[ ] |   D1         
         | [ ]A13           I2C-SCL/INT0/21[ ] |   D0
         | [ ]A14                              |            
         | [ ]A15                              |   Ports:
         |                RST SCK MISO         |    22=A0  23=A1   
         |         ICSP   [ ] [ ] [ ]          |    24=A2  25=A3   
         |                [ ] [ ] [ ]          |    26=A4  27=A5   
         |                GND MOSI 5V          |    28=A6  29=A7   
         | G                                   |    30=C7  31=C6   
         | N 5 5 4 4 4 4 4 3 3 3 3 3 2 2 2 2 5 |    32=C5  33=C4   
         | D 2 0 8 6 4 2 0 8 6 4 2 0 8 6 4 2 V |    34=C3  35=C2   
         |         ~ ~                         |    36=C1  37=C0   
         | @ # # # # # # # # # # # # # # # # @ |    38=D7  39=G2    
         | @ # # # # # # # # # # # # # # # # @ |    40=G1  41=G0   
         |           ~                         |    42=L7  43=L6   
         | G 5 5 4 4 4 4 4 3 3 3 3 3 2 2 2 2 5 |    44=L5  45=L4   
         | N 3 1 9 7 5 3 1 9 7 5 3 1 9 7 5 3 V |    46=L3  47=L2   
         | D                                   |    48=L1  49=L0    SPI:
         |                                     |    50=B3  51=B2     50=MISO 51=MOSI
         |     2560                ____________/    52=B1  53=B0     52=SCK  53=SS 
          \_______________________/         
         
         http://busyducks.com/ascii-art-arduinos

You may notice that the clean layout of these diagrams makes them very readable, personally I feel many graphical versions present too much information at once.

Some Updates (new models)

This idea seems to have caught on quickly, so I will keep the art coming.

Redit user plasticluthier adapted a nano version here, I thought that was spiffy, so I fixed an error tweaked it a bit and added chips and ports.

                      +-----+
         +------------| USB |------------+
         |            +-----+            |
    B5   | [ ]D13/SCK        MISO/D12[ ] |   B4
         | [ ]3.3V           MOSI/D11[ ]~|   B3
         | [ ]V.ref     ___    SS/D10[ ]~|   B2
    C0   | [ ]A0       / N \       D9[ ]~|   B1
    C1   | [ ]A1      /  A  \      D8[ ] |   B0
    C2   | [ ]A2      \  N  /      D7[ ] |   D7
    C3   | [ ]A3       \_0_/       D6[ ]~|   D6
    C4   | [ ]A4/SDA               D5[ ]~|   D5
    C5   | [ ]A5/SCL               D4[ ] |   D4
         | [ ]A6              INT1/D3[ ]~|   D3
         | [ ]A7              INT0/D2[ ] |   D2
         | [ ]5V                  GND[ ] |     
    C6   | [ ]RST                 RST[ ] |   C6
         | [ ]GND   5V MOSI GND   TX1[ ] |   D0
         | [ ]Vin   [ ] [ ] [ ]   RX1[ ] |   D1
         |          [ ] [ ] [ ]          |
         |          MISO SCK RST         |
         | NANO-V3                       |
         +-------------------------------+
         
         http://busyducks.com/ascii-art-arduinos

I have a Pro Mini project coming up, so knocked one of these out as well.

		                  D0   D1   RST
		   GND  GND  VCC  RX   TX   /DTR
        +--------------------------------+
        |  [ ]  [ ]  [ ]  [ ]  [ ]  [ ]  |
        |              FTDI              |
    D1  | [ ]1/TX                 RAW[ ] |    
    D0  | [ ]0/RX                 GND[ ] |    
        | [ ]RST        SCL/A5[ ] RST[ ] |   C6
        | [ ]GND        SDA/A4[ ] VCC[ ] |    
    D2  | [ ]2/INT0    ___         A3[ ] |   C3
    D3  |~[ ]3/INT1   /   \        A2[ ] |   C2
    D4  | [ ]4       /PRO  \       A1[ ] |   C1
    D5  |~[ ]5       \ MINI/       A0[ ] |   C0
    D6  |~[ ]6        \___/    SCK/13[ ] |   B5
    D7  | [ ]7          A7[ ] MISO/12[ ] |   B4
    B0  | [ ]8          A6[ ] MOSI/11[ ]~|   B3
    B1  |~[ ]9                  SS/10[ ]~|   B2
        |           [RST-BTN]            |    
        +--------------------------------+  
		
		http://busyducks.com/ascii-art-arduinos

How to use them

Just fill in the spaces, either with an X, or with a reference letter which you document below the ASCII art.

They can be pasted into code comments, (use /* and */ in the arduino IDE to create a block comment). They can also be useful in forums, when you need a quick arduino diagram, but don’t want to fire up an image editor.

This is a snippet from a recent project. The sketch starts out with comments that set-out how the hardware is setup, this helps me a lot when I have to look at it again in a years time. Its also great if I want to share the code, as people don’t need to dig-around in the code to see how to connect the arduino to other devices.

/*

                                      +-----+
         +----[PWR]-------------------| USB |--+
         |                            +-----+  |
         |           GND/RST2  [ ] [ ]         |
         |         MOSI2/SCK2  [ ] [ ]  SCL[ ] |   C5
         |            5V/MISO2 [ ] [ ]  SDA[ ] |   C4
         |                             AREF[ ] |
         |                              GND[ ] |
         | [ ]N/C                    SCK/13[A] |   B5
         | [ ]v.ref                 MISO/12[A] |   .
         | [ ]RST                   MOSI/11[A]~|   .
         | [ ]3V3    +---+               10[ ]~|   .
         | [ ]5v     | A |                9[ ]~|   .
         | [ ]GND   -| R |-               8[B] |   B0
         | [ ]GND   -| D |-                    |
         | [ ]Vin   -| U |-               7[A] |   D7
         |          -| I |-               6[A]~|   .
         | [ ]A0    -| N |-               5[C]~|   .
         | [ ]A1    -| O |-               4[A] |   .
         | [ ]A2     +---+           INT1/3[A]~|   .
         | [ ]A3                     INT0/2[ ] |   .
         | [ ]A4      RST SCK MISO     TX>1[ ] |   .
         | [ ]A5      [ ] [ ] [ ]      RX<0[ ] |   D0
         |            [ ] [ ] [ ]              |
         |  UNO_R3    GND MOSI 5V  ____________/
          \_______________________/
		  
		  http://busyducks.com/ascii-art-arduinos
*/

//------------------------------------------------------------------ 
// [A]		Adafruit music shield
//------------------------------------------------------------------ 
// Connect CLK, MISO and MOSI to hardware SPI pins. 
// SPI Clock, shared with SD card
#define CLK_PIN (13)       
// Input data, from VS1053/SD card
#define MISO_PIN (12)      
// Output data, to VS1053/SD card
#define MOSI_PIN (11)      

// VS1053 reset pin (unused!)
#define SHIELD_RESET_PIN  (-1)   
// VS1053 chip select pin (output)
#define SHIELD_CS_PIN     (7)      
// VS1053 Data/command select pin (output)
#define SHIELD_DCS_PIN    (6)      
// Card chip select pin
#define CARDCS_PIN (4)     
// VS1053 Data request, ideally an Interrupt pin
#define DREQ_PIN (3)       

//------------------------------------------------------------------  
// [B]		WS2811 LED stip
//------------------------------------------------------------------ 
#define LED_STIP_PIN  (8)

//------------------------------------------------------------------  
// [C]		Servo Motor
//------------------------------------------------------------------ 
#define SERVO_PIN (5)

Related Projects (based on this work)

• I modified a version of this for markdeep and made it available for download  here.
  • There is a unofficial mirror (by vanderZwan) of the markdeep work here
• A console version, by paulfantom, for terminal users is available here.

Our markdeep version (click image to download)

Stay Up To date and Provide Feedback

• Contribute  to the project on https://github.com/busyDuckman/ascii-art-arduinos
• I will check back on the facebook page for any comments, like the page to stay up to date.
  • https://www.facebook.com/BusyDucks/
• I set up a redirected URL http://busyducks.com/ascii-art-arduinos  that is both the CC-BY attribution line, and will always redirect to the latest version of these ascii art arduinos.

Version History

• 18-11-2015   markdeep version added (as suggested by vanderZwan here)
• 19-11-2015   typos fixed (as noted by oroki here)
• 21-112015    Added nano (derived from plasticluthier’s contributions ) &  Pro Mini
• 1-12-2015     Fixed typo’s spotted by Basile Laderchi. Also minor visual tweak to the arduino CPU.

A lot of components in the C# environment are essentially a K-ary [kay-er-ee] tree. From tree-view nodes, to serialising a type via reflection, to directory listings to menu hierarchies, and so on.

Often we need to iterate through these types of structures, or our own trees, and we just write some code to do it as needed. This code is often problematic as it’s non-trivial to do well, because:

• It’s complex to do certain traversals in an iterative manor. (non recursive);
• Traversal is prone to bugs, as there are many edge cases;
• Software hangs if a circular reference exists and you don’t catch it;
• Unit-testing of once-off code is often neglected;
• Examining / verifying correct behaviour of tree traversal algorithms is difficult in the debugger.

Wanting to rid myself of this re-occurring situation I built a few helper methods to do the following traversals iteratively:

• Depth First Pre Order
• Depth First Post Order,
• Breadth First

The helpers are generic [BYO data type] and dont require a specific interface. You just supply a Func to return a nodes sub nodes. Thus you can drop a working tested algorithm onto whatever situation you encounter.

Iteration

Example:

• Made using an example data type “Node”
  • See the unit-tests at the  bottom of the page for implementation
• First it shows using a foreach loop on a depth first pre-order iterator
• Then is shows using a breadth-first iterator to convert a tree to an array using Linq.

/*
* Test tree
*                  A
*                / | \ 
*              B   C   D
*            / |       | \
*          E   F       G   H
*        / |         / | \
*       I  J        K  L  M
*/
Node<char> tree = Node<char>.TestTree();

//EXAMPLE 1: Pre-order traversal via foreach loop
foreach(var node in  Misc.EnumerateNodes(tree, 
                                    N => N.Nodes, 
                                    NodeVisitOrder.DepthFirstPreOrder))
{
    Console.Out.Write(node.Item);
}
Console.Out.WriteLine();
//outputs ABEIJFCDGKLMH

//EXAMPLE 2: Creating an array via breadth first traversal 
string s = new String(Misc.EnumerateNodes(tree, N => N.Nodes, NodeVisitOrder.BredthFirst)
                            .Select(N => N.Item)
                            .ToArray());
Console.Out.WriteLine(s);
//outputs ABCDEFGHIJKLM

This was a simplistic example, but it works, its unit-tested, its efficient and non-recursive. It all ties into linq and IEnumerable so many neat tricks are possible.

Lets examine the crucial line in detail.

EnumerateNodes(tree, N => N.Nodes, NodeVisitOrder.DepthFirstPreOrder)

• The first parameter is the root node. This is method is generic, so any class type will do.
• The second is a lambda expression for an enumerable  set of sub-nodes
• The third is the traversal method.

Another example of how flexible the method is, using DirectoryInfo as the node, and iterating over all subdirectories:

• This time we use the optional forth parameter to enable circular reference checking. this prevents any chance of an infinite loop

DirectoryInfo root = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments));
 
var dirs = Misc.EnumerateNodes(
                root,
                N => { try { return N.GetDirectories();  } 
                       catch (Exception) { return null; } },
                NodeVisitOrder.DepthFirstPreOrder, 
                CircularRefernceBehaviour.Skip);
 
foreach (var dir in dirs)
{
}

Duplication

Often you just need to copy one tree structure to another (possibly of a different type):

• Loading a directory structure into a TreeView control
• Turning a tree of commands into Menu Items
• Working with expression parsing  and evaluation
• Just making a deep copy of a tree structure

/*
* Test tree
*                  A
*                / | \ 
*              B   C   D
*            / |       | \
*          E   F       G   H
*        / |         / | \
*       I  J        K  L  M
*/
Node<char> tree = Node<char>.TestTree();

TreeNode n = Misc.RebuildTree(tree,  
							 N => N.Nodes, 
							 N => new TreeNode("" + N.Item), 
							 (T, N) => T.Nodes.AddRange(N.ToArray()));

Neeto, one line of code, and our tree is duplicated into a TreeView (or whatever) in a efficient, reliable manor.

RebuildTree takes five parameters:

1. The root of the tree to be copied.
2. Func for an enumerating sub-nodes in the source structure
3. Func to create a new destination  node form a source node
   • Just the data of the node, Leave the child nodes unpopulated
4. Action to add a collection of Nodes to an existing node (destination structure)
5. Circular reference checking behaviour

Core Algorithms

Depth First Pre-Order

• Note: visitOk(…) returns true unless a circular reference is detected.
• This works by feeding al nodes onto a stack, a basic way to resolve the recursion.
• Child nodes are pushed in reverse order, so they are pop’ed in the correct order.

LinkedList list = new LinkedList();
HashSet visited = new HashSet();

list.AddLast(node);
while (list.Count > 0)
{
	T item = list.Pop();
	if (visitOk(item, visited, checkType))
	{
		yield return item;
		list.AddLastAll(getSubNodesSafe(item, getSubNodes).Reverse());
	}
}

Depth First Post-Order

• Depth First Post-Order is actually pretty tricky, a few algorithms exist.
• This one initially traverses the entire tree O(n) to fill a stack, then returns each item in the stack.
• The overall time is O(n), with the first iteration being O(n) and all subsequent  iterations being O(1)
• There s a requirement for  extra memory for this to work, but its not too bad.

LinkedList list = new LinkedList();
HashSet visited = new HashSet();

Stack output = new Stack();
list.AddLast(node);
while (list.Count > 0)
{
	T item = list.Pop();
	if (visitOk(item, visited, checkType))
	{
		output.Push(item);
		list.AddLastAll(getSubNodesSafe(item, getSubNodes));
	}
}
foreach (T item in output)
{
	yield return item;
}

Breadth First

• This works by feeding al nodes onto a queue, as opposed to the depth first – pre order, which uses a stack.
  • This time Child nodes are not added in reverse order, however

LinkedList list = new LinkedList();
HashSet visited = new HashSet();

list.AddLast(node);
while (list.Count > 0)
{
	T item = list.Dequeue();
	if (visitOk(item, visited, checkType))
	{
		yield return item;
		list.AddLastAll(getSubNodesSafe(item, getSubNodes));
	}
}
break;
}

Source Code:

/*
Available under the BSD 3-Clause License
Copyright (c) 2015, Dr Warren Creemers All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using WD_toolbox;

namespace WD_toolbox
{
    public enum NodeVisitOrder { DepthFirstPreOrder, DepthFirstPostOrder, BredthFirst }

    public enum CircularRefernceBehaviour { DontCheck, ThrowException, Skip }

    public class NodeTraversalException : Exception
    {
        public NodeTraversalException(string message) : base(message) { }
        public NodeTraversalException() : base() { }
        public static NodeTraversalException VisitedTwice(object item) {return new NodeTraversalException("Node already visied: " + item.ToString());} 
    }

    public static class Misc
    {
        /// <summary>
        /// Enumerates any Tree/graph in a non-recursive manor.
        /// Does not check for circularReferences.
        /// </summary>
        /// <param name="node">Root node.</param>
        /// <param name="getSubNodes"> Get the sub-nodes of any given node.</param>
        /// <param name="order">The visit order.</param>
        /// <param name="checkType">If circular references should be checked, and how to handle them. 
        /// Note (1): Checks repeated node, which is not nesesiarly a circular reference (but all circulare references have a repeated node).
        /// Note (2): performance hit reduced if  node generates a good hashcode.
        /// </param>
        public static IEnumerable<T> EnumerateNodes<T>( T node, 
                                                        Func<T, IEnumerable<T>> getSubNodes,
                                                        NodeVisitOrder order = NodeVisitOrder.DepthFirstPreOrder,
                                                        CircularRefernceBehaviour checkType = CircularRefernceBehaviour.DontCheck)
            where T : class
        {
            if (node != null) //assuming null indicats an empty tree
            {
                //this acts as a stack or queue to resolve the recursion
                LinkedList<T> list = new LinkedList<T>();
                HashSet<T> visited = new HashSet<T>();

                switch (order)
                {
                    case NodeVisitOrder.DepthFirstPreOrder:
                        list.AddLast(node);
                        while (list.Count > 0)
                        {
                            T item = list.Pop();
                            if (visitOk(item, visited, checkType))
                            {
                                yield return item;
                                list.AddLastAll(getSubNodesSafe(item, getSubNodes).Reverse());
                            }
                        }
                        break;

                    case NodeVisitOrder.DepthFirstPostOrder:
                        //This has a side effects, the first iteeration is slow (also memory consuming) 
                        //as the entire structure is copied into a stack 
                        Stack<T> output = new Stack<T>();
                        list.AddLast(node);
                        while (list.Count > 0)
                        {
                            T item = list.Pop();
                            if (visitOk(item, visited, checkType))
                            {
                                output.Push(item);
                                list.AddLastAll(getSubNodesSafe(item, getSubNodes));
                            }
                        }
                        foreach (T item in output)
                        {
                            yield return item;
                        }
                        break;

                    case NodeVisitOrder.BredthFirst:
                        list.AddLast(node);
                        while (list.Count > 0)
                        {
                            T item = list.Dequeue();
                            if (visitOk(item, visited, checkType))
                            {
                                yield return item;
                                list.AddLastAll(getSubNodesSafe(item, getSubNodes));
                            }
                        }
                        break;
                }
            }
        }

        // Because getSubNodes(T) may return null to indicate no nodes.
        private static IEnumerable<T> getSubNodesSafe<T>(T node, Func<T, IEnumerable<T>> getSubNodes)
        {
            if ((node != null) && (getSubNodes != null))
            {
                IEnumerable<T> subNodes = getSubNodes(node);
                return (subNodes != null) ? subNodes : new List<T>();
            }
            return new List<T>();
        }

        private static bool visitOk<T>(T item, HashSet<T> visited, CircularRefernceBehaviour checkType)
        {
            if (checkType != CircularRefernceBehaviour.DontCheck)
            {
                if (visited.Contains(item))
                {
                    // error
                    if (checkType == CircularRefernceBehaviour.ThrowException)
                    {
                        throw NodeTraversalException.VisitedTwice(item);
                    }
                    return false; //indicate it's not ok to visit (ie skip)
                }

                //no error
                visited.Add(item);
                return true;
            }

            //no check
            return true;
        }


        /// <summary>
        /// Copies a tree structure. (useful in copying a tree structure to a tree view).
        /// </summary>
        /// <typeparam name="A">The node type of the tree to copy.</typeparam>
        /// <typeparam name="B">The destination node type.</typeparam>
        /// /// <param name="getSubNodes"> Get the sub-nodes of any given node.</param>
        /// <param name="newNode">To create a simple non-recursive copy of a node.</param>
        /// <param name="addSubNodes"></param>
        /// <param name="checkType"> Type of circular reference checking to perform.</param>
        /// <returns></returns>
        public static B RebuildTree<A, B>(A srcNode,
                                           Func<A, IEnumerable<A>> getSubNodes,
                                           Func<A, B> newNode,
                                           Action<B, IEnumerable<B>> addSubNodes,
                                           CircularRefernceBehaviour checkType = CircularRefernceBehaviour.DontCheck)
            where A : class
            where B : class
        {
            return RebuildTree(srcNode, getSubNodes, newNode, addSubNodes, P => true, checkType);
        }
        
        /// <summary>
        /// Copies a tree structure. (useful in copying a tree structure to a tree view).
        /// </summary>
        /// <typeparam name="A">The node type of the tree to copy.</typeparam>
        /// <typeparam name="B">The destination node type.</typeparam>
        /// /// <param name="getSubNodes"> Get the sub-nodes of any given node.</param>
        /// <param name="newNode">To create a simple non-recursive copy of a node.</param>
        /// <param name="addSubNodes"></param>
        /// <param name="where"></param>
        /// <param name="checkType"> Type of circular reference checking to perform.</param>
        /// <returns></returns>
        public static B RebuildTree<A, B>( A srcNode,
                                           Func<A, IEnumerable<A>> getSubNodes, 
                                           Func<A, B> newNode,
                                           Action<B, IEnumerable<B>> addSubNodes,
                                           Predicate<A> where,
                                           CircularRefernceBehaviour checkType = CircularRefernceBehaviour.DontCheck)
            where A : class
            where B : class
        {


            LinkedList<Tuple<A, B>> list = new LinkedList<Tuple<A, B>>();
            HashSet<A> visited = new HashSet<A>();
            B newRootNode = null;

            list.AddLast(new Tuple<A, B>(srcNode, null));
            while (list.Count > 0)
            {
                var tuple = list.Pop();
                A item = tuple.Item1;
                B parent = tuple.Item2;

                if (visitOk(item, visited, checkType))
                {
                    if (where(item))
                    {
                        B newItem = newNode(item);
                        if (newRootNode == null) //root node
                        {
                            newRootNode = newItem;
                        }

                        safeAddSubNode(parent, newItem, addSubNodes);
                        
                        list.AddLastAll(getSubNodesSafe(item, getSubNodes).Reverse().Select(N => new Tuple<A, B>(N, newItem)));
                    }
                }
            }

            //done
            return newRootNode;
        }

        private static void safeAddSubNode<B>(B parent, B child, Action<B, IEnumerable<B>> addSubNodes)
        {
            if ((addSubNodes != null) && (parent != null) && (child != null))
            {
                addSubNodes(parent, new B[] { child });
            }
        }
    }
}

Requires The following Extension class to make LinkedList sane.

/*
Available under the BSD 3-Clause License
Copyright (c) 2015, Dr Warren Creemers All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/// <summary>
/// These extensions make usage of the LinkedList more consise.
/// </summary>
public static class LinkedListExtension
{
	/// <summary>
	/// Pops the last value of the linked list.
	/// </summary>
	/// <returns> Value of the (formerly) last item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T Pop<T>(this LinkedList<T> list)
	{
		T item = list.Last.Value;
		list.RemoveLast(); //throws InvalidOperationException
		return item;
	}

	/// <summary>
	/// Dequeues the first value of the linked list.
	/// </summary>
	/// <returns> Value of the (formerly) first item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T Dequeue<T>(this LinkedList<T> list)
	{
		T item = list.First.Value;
		list.RemoveFirst(); //throws InvalidOperationException
		return item;
	}

	/// <summary>
	/// Gets the last value of the linked list.
	/// </summary>
	/// <returns> Value of the last item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T PeekLast<T>(this LinkedList<T> list)
	{
		if (list.Count <= 0)
		{
			throw new InvalidOperationException("LinkedList is empty (call to PeekLast)");
		}

		T item = list.Last.Value;
		return item;
	}

	/// <summary>
	/// Gets the last value of the linked list.
	/// </summary>
	/// <returns> Value of the last item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T PeekFirst<T>(this LinkedList<T> list)
	{
		if (list.Count <= 0)
		{
			throw new InvalidOperationException("LinkedList is empty (call to PeekFirst)");
		}

		T item = list.First.Value;
		return item;
	}

	/// <summary>
	/// Addss items to the end of the list.
	/// </summary>
	/// <param name="items">Items to add.</param>
	public static void AddLastAll<T>(this LinkedList<T> list, IEnumerable<T> items)
	{
		foreach (T item in items)
		{
			list.AddLast(item);
		}
	}

	/// <summary>
	/// Addss items to the end of the list.
	/// </summary>
	/// <param name="items">Items to add.</param>
	public static void AddFirstAll<T>(this LinkedList<T> list, IEnumerable<T> items)
	{
		foreach (T item in items)
		{
			list.AddFirst(item);
		}
	}
}

Unit Tests:

       [TestMethod()]
        public void EnumerateNodesTest()
        {
            /*
            * Test tree
            *                  A
            *                / | \ 
            *              B   C   D
            *            / |       | \
            *          E   F       G   H
            *        / |         / | \
            *       I  J        K  L  M
            */
            Node<char> tree = Node<char>.TestTree();

            Node<char> coruptTree = Node<char>.TestTree();
            //point L  to A
            coruptTree.Nodes[2].Nodes[0].Nodes[1].Nodes.Add(coruptTree); 

            //DepthFirstPreOrder
            string res = new String(Misc.EnumerateNodes(tree, N => N.Nodes, 
                                                        NodeVisitOrder.DepthFirstPreOrder, 
                                                        CircularRefernceBehaviour.ThrowException).Select(N => N.Item).ToArray());



            //System.Diagnostics.Trace.WriteLine("Hello World");
            Assert.AreEqual("ABEIJFCDGKLMH", res);
            
            //DepthFirstProstOrder
            res = new String(Misc.EnumerateNodes(tree, N => N.Nodes, 
                                                    NodeVisitOrder.DepthFirstPostOrder,
                                                    CircularRefernceBehaviour.ThrowException).Select(N => N.Item).ToArray());
            Assert.IsTrue(res == "IJEFBCKLMGHDA");

            //BredthFirst
            res = new String(Misc.EnumerateNodes(tree, N => N.Nodes, 
                                                 NodeVisitOrder.BredthFirst,
                                                 CircularRefernceBehaviour.ThrowException).Select(N => N.Item).ToArray());
            Assert.AreEqual("ABCDEFGHIJKLM", res);

            //just to check no exception thrown
            TreeNode n = Misc.RebuildTree(tree,  
                                         N => N.Nodes, 
                                         N => new TreeNode("" + N.Item),
                                         (T, N) => T.Nodes.AddRange(N.ToArray()), 
                                         CircularRefernceBehaviour.ThrowException);

            //Check an exception is thrown for curupted tree

            try
            {
                n = Misc.RebuildTree(coruptTree,
                                             N => N.Nodes,
                                             N => new TreeNode("" + N.Item),
                                             (T, N) => T.Nodes.AddRange(N.ToArray()),
                                             CircularRefernceBehaviour.ThrowException);

                Assert.Fail("Should never reach this line of code");
            }
            catch (Exception)
            {
            }

            //Just handle a corupt tree by not going backward.
            n = Misc.RebuildTree(coruptTree,
                                 N => N.Nodes,
                                 N => new TreeNode("" + N.Item),
                                 (T, N) => T.Nodes.AddRange(N.ToArray()),
                                 CircularRefernceBehaviour.Skip);

            //NB: Infinite loop on fail

        }

        

        public class Node<T>
        {
            public List<Node<T>> Nodes = new List<Node<T>>();
            public T Item;
            public Node(T item, IList<Node<T>> nodes = null)
            {
                Item = item;
                if (nodes != null)
                {
                    Nodes.AddRange(nodes);
                }
            }

            private static Node<T> NODE<T>(T item, params Node<T>[] Nodes)
            {
                return new Node<T>(item, Nodes);
            }

            public static Node<char> TestTree()
            {
                /*
                * Test tree
                *                  A
                *                / | \ 
                *              B   C   D
                *            / |       | \
                *          E   F       G   H
                *        / |         / | \
                *       I  J        K  L  M
                */


                Node<char> tree =
                    NODE('A',
                        NODE('B',
                            NODE('E',
                                NODE('I'),
                                NODE('J')
                                ),
                            NODE('F')
                            ),
                        NODE('C'),
                        NODE('D',
                            NODE('G',
                                NODE('K'),
                                NODE('L'),
                                NODE('M')
                                ),
                            NODE('H')
                            )
                        );

                return tree;
            }
        }
    }

WDLib Library:

This is part of my personal toolbox, WDLib (in the misc class, which is abridged for clarity on this page). I am moving to open source the library at the moment.

Limitations and Usage:

• The circular reference check just checks for a repeated node, which is not necessarily a circular reference (but all circular references have a repeated node). This may deny some malformed trees that could otherwise be safely parsed. Checking can always be disabled if this is your intent.
• Be aware the first iteration of the Depth First Post-Order has a O(n) overhead.

Contact / Feedback

[Sorry I had to remove this, because hundreds of spam emails about SEO]

This software creates mazes of different sizes and configurable appearance. It is designed for teachers and makers. It can save the output as printable sheets or bitmap images.

[updated terms]

• This software is provided free to use for all commercial / non-commercial / educational, puzzle publication purposes.
• The code is licensed under the MIT licence
• see https://github.com/busyDuckman/MazeMaker

[how to show appreciation]

• I super appreciate getting some credit for the work, especially if you are printing a book of puzzles. Something like “puzzles created using Maze Maker software, by Dr Warren Creemers”.
• If you make something cool with it, I would love to see a photo/link.
• If you make a kids book or something like that, I’d really get a kick out of getting a free copy. Gestures like that make my day

Screenshot

Examples of different types of output

Can it do large mazes, like really large mazes?… YES.

Download

Install from the latest release on github

• • Download zip file.
  • Unzip file
  • run setup.exe

First created:  2016-9-29
First published to github: 2019-09-13

Limitations:

• Beta software (minor bugs to iron out, but quite usable)
• Smooth edges when wall width is set to 1 are buggy.
• Even line widths produce a better output.

What is done:

• Generates a valid maze.
• Appearance is configurable.
• Maze size is configurable.
• Printing is enabled (adjust blockSize to alter print output size)
• Zooming in, moving etc (few minor bugs still).
• Support for DPI / block size.

Next Release

• Bug fixes
• Support for graphical inserts
• Ascii output

Road Map

• Will probably combine this with other software I have written to create a puzzle creation suite.

Update:

I have tentatively started working (April 2019) on a online version of this software, to be open sourced.

Contact / Feedback

Please leave feedback and bug reports via: https://github.com/busyDuckman/MazeMaker/issues

Useful image for teachers, overhead slides etc.
NB: This is not always a good DIY or classroom activity. Be aware that some electrical components create a seriously hazardous dust when broken open. Rectifiers, Hi Power transistors, Older IC’s & IC’s with certain head spreaders as well as some IC’s designed for use in microwaves contain Beryllium Oxide.  While safe to handle, the dust particles created when they are damaged will make you gravely ill.

Download large and detailed image [4096 x 5686] (1.5mb) here
Download full scan [16394 x 22761] (27mb, use save as, because images this large still crash some broswers) here

What’s the white grid? Its a standard prototyping board, used to protect the scanner from the IC’s pins.