Kimball Kaiser

21.05.27 DTS Final Presentation

Demo Video:

Current Machine:

12 Nozzle Print using Arduino functions:

The code that made the print above, using TinyG board as an Input, and the Arduino functions:

const int TinyG = A5;
int TinyGstate = 0;
int outPin2 = 2;
int outPin3 = 3;
int outPin4 = 4;
int outPin5 = 5;
int outPin6 = 6;
int outPin7 = 7;
int outPin8 = 8;
int outPin9 = 9;
int outPin10 = 10;
int outPin11 = 11;
int outPin12 = 12;
int outPin13 = 13;

void setup() {
  // put your setup code here, to run once:

pinMode(outPin2, OUTPUT);    // sets the digital pin as output
  pinMode(outPin3, OUTPUT);
  pinMode(outPin4, OUTPUT);
  pinMode(outPin5, OUTPUT);
  pinMode(outPin6, OUTPUT);
  pinMode(outPin7, OUTPUT);
  pinMode(outPin8, OUTPUT);
  pinMode(outPin9, OUTPUT);
  pinMode(outPin10, OUTPUT);
  pinMode(outPin11, OUTPUT);
  pinMode(outPin12, OUTPUT);
  pinMode(outPin13, OUTPUT);
  pinMode(TinyG, INPUT);      // sets TinyG as input for printhead

}

void loop() {
  // put your main code here, to run repeatedly:

TinyGstate = digitalRead(TinyG);
  if (TinyGstate == HIGH)
  {

digitalWrite(outPin2, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin2, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin3, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin3, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin4, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin4, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin5, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin5, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin6, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin6, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin7, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin7, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin8, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin8, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin9, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin9, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin10, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin10, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin11, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin11, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin12, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin12, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

digitalWrite(outPin13, HIGH); // sets the pin on
  delayMicroseconds(5);      // pauses for 5 microseconds
  digitalWrite(outPin13, LOW);  // sets the pin off
  delayMicroseconds(1000);      // pauses for 1000 microseconds

}

else{
    digitalWrite(outPin2, LOW);
    digitalWrite(outPin3, LOW);
    digitalWrite(outPin4, LOW);
    digitalWrite(outPin5, LOW);
    digitalWrite(outPin6, LOW);
    digitalWrite(outPin7, LOW);
    digitalWrite(outPin8, LOW);
    digitalWrite(outPin9, LOW);
    digitalWrite(outPin10, LOW);
    digitalWrite(outPin12, LOW);
    digitalWrite(outPin13, LOW);

}

Updated method using direct port manipulation on the Atmega chip. Same print with 12 nozzles using new method - results are a lot faster and more ink:

The code that made the print above, using TinyG board as an Input, and direct port manipulation:

const int TinyG = A5;
int TinyGstate = 0;

void setup() {
  // put your setup code here, to run once:

DDRD = B11111100; // Sets 2-7 Output, 0-1 Input
  DDRB = B11111111; // Sets 8-13 Output
  pinMode(TinyG, INPUT);      // sets TinyG as input for printhead

}

void loop() {
  // put your main code here, to run repeatedly:

TinyGstate = digitalRead(TinyG);
  if (TinyGstate == HIGH)
  {

PORTD = B00000100; // 2
    delayMicroseconds(8);
      PORTD = B00000000;
  PORTD = B00001000; // 3
    delayMicroseconds(8);
      PORTD = B00000000;
  PORTD = B00010000; // 4
    delayMicroseconds(8);
      PORTD = B00000000;
  PORTD = B00100000; // 5
    delayMicroseconds(8);
      PORTB = B00000000;
  PORTD = B01000000; // 6
    delayMicroseconds(8);
      PORTD = B00000000;
  PORTD = B10000000; // 7
    delayMicroseconds(8);
      PORTD = B00000000;
  PORTB = B00000001; // 8
    delayMicroseconds(8);
      PORTB = B00000000;
  PORTB = B00000010; // 9
    delayMicroseconds(8);
      PORTB = B00000000;
  PORTB = B00000100; // 10
    delayMicroseconds(8);
      PORTB = B00000000;
  PORTB = B00001000; // 11
    delayMicroseconds(8);
      PORTB = B00000000;
  PORTB = B00010000; // 12
    delayMicroseconds(8);
      PORTB = B00000000;
  PORTB = B00100000; // 13
    delayMicroseconds(8);
      PORTB = B00000000;

delayMicroseconds(1000);

}

else{
    PORTB = B00000000;
    PORTD = B00000000;

}

With the direct port manipulation, there was also an idea about producing a print more like machine produced calligraphy.

Printing Kanji above:

Results above, printed at an angle to almost get a brush like effect.

Considerable efforts were also put into programming the printhead to do things like print letters with all 12 inkjets. We now have written the code for all 26 letters of the English alphabet, 0-9, and some punctuation as well, so full sentences can be written with the machine.

Above is a printed example of where our letters have ended up. Below is the code for printing this example and letters "D" and "E" to show what the main code is referencing.

const int TinyG = A5;
int TinyGstate = 0;

void AF();
void BF();
void CF();
void DF();
void EF();
void FF();
void GF();
void HF();
void IF();
void JF();
void KF();
void LF();
void MF();
void NF();
void OF();
void PF();
void QF();
void RF();
void SF();
void TF();
void UF();
void VF();
void WF();
void XF();
void YF();
void ZF();
void oneF();
void twoF();
void threeF();
void fourF();
void fiveF();
void sixF();
void sevenF();
void eightF();
void nineF();
void zeroF();
void PPF();
void PEF();
void PSF();

void setup() {
  // put your setup code here, to run once:

pinMode(TinyG, INPUT);      // sets TinyG as input for printhead

DDRD = B11111100; // Sets 2-7 Output, 0-1 Input
    DDRB = B11111111; // Sets 8-13 Output

}

void loop() {
  // put your main code here, to run repeatedly:

TinyGstate = digitalRead(TinyG);
  if (TinyGstate == HIGH)
  {

delay(500);
MF();
AF();
KF();
KF();
sF();
WF();
AF();
SF();
sF();
HF();
EF();
RF();
EF();
PPF();
delay(10000);

delay(500);
DF();
EF();
AF();
RF();
sF();
DF();
IF();
AF();
RF();
YF();
PPF();
delay(10000);

delay(500);
TF();
OF();
DF();
AF();
YF();
sF();
IF();
sF();
WF();
AF();
SF();
sF();
WF();
IF();
TF();
HF();
sF();
MF();
YF();
sF();
FF();
RF();
IF();
EF();
NF();
DF();
sF();
DF();
TF();
SF();
PPF();
delay(10000);

delay(500);
SF();
IF();
NF();
CF();
EF();
RF();
EF();
LF();
YF();
sF();
MF();
AF();
KF();
KF();
PPF();
delay(10000);

}

else{
    PORTB = B00000000;
    PORTD = B00000000;

}

Letter "D":

void DF() {

//StraightLine

PORTD = B00000100; // 2
delayMicroseconds(8);
  PORTD = B00000000;
PORTD = B00001000; // 3
  delayMicroseconds(8);
    PORTD = B00000000;
PORTD = B00010000; // 4
  delayMicroseconds(8);
    PORTD = B00000000;
PORTD = B00100000; // 5
  delayMicroseconds(8);
    PORTB = B00000000;
PORTD = B01000000; // 6
  delayMicroseconds(8);
    PORTD = B00000000;
PORTD = B10000000; // 7
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00000001; // 8
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00000010; // 9
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00000100; // 10
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00001000; // 11
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00010000; // 12
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00100000; // 13
  delayMicroseconds(8);
    PORTB = B00000000;

delayMicroseconds(1000);

//2 Horizontals

for (int i = 0; i < 35; i++) {
  PORTD = B00000100; // 2
  delayMicroseconds(8);
    PORTD = B00000000;
  PORTB = B00100000; // 13
    delayMicroseconds(8);
      PORTB = B00000000;

delayMicroseconds(1000);
    }

//EndOfD

PORTD = B00001000; // 3
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00010000; // 12
  delayMicroseconds(8);
    PORTB = B00000000;
  delayMicroseconds(1000);
PORTD = B00001000; // 3
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00010000; // 12
  delayMicroseconds(8);
    PORTB = B00000000;
  delayMicroseconds(1000);
PORTD = B00001000; // 3
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00010000; // 12
  delayMicroseconds(8);
    PORTB = B00000000;
  delayMicroseconds(1000);

PORTD = B00010000; // 4
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00001000; // 11
  delayMicroseconds(8);
    PORTB = B00000000;
    delayMicroseconds(1000);
PORTD = B00010000; // 4
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00001000; // 11
  delayMicroseconds(8);
    PORTB = B00000000;
    delayMicroseconds(1000);
PORTD = B00010000; // 4
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00001000; // 11
  delayMicroseconds(8);
    PORTB = B00000000;
    delayMicroseconds(1000);

PORTD = B00100000; // 5
  delayMicroseconds(8);
    PORTB = B00000000;
PORTD = B01000000; // 6
  delayMicroseconds(8);
    PORTD = B00000000;
PORTD = B10000000; // 7
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00000001; // 8
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00000010; // 9
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00000100; // 10
  delayMicroseconds(8);
    PORTB = B00000000;
    delayMicroseconds(1000);

delay(150); // Pause

}

Letter "E":

void EF() {

//StraightLine

PORTD = B00000100; // 2
delayMicroseconds(8);
  PORTD = B00000000;
PORTD = B00001000; // 3
  delayMicroseconds(8);
    PORTD = B00000000;
PORTD = B00010000; // 4
  delayMicroseconds(8);
    PORTD = B00000000;
PORTD = B00100000; // 5
  delayMicroseconds(8);
    PORTB = B00000000;
PORTD = B01000000; // 6
  delayMicroseconds(8);
    PORTD = B00000000;
PORTD = B10000000; // 7
  delayMicroseconds(8);
    PORTD = B00000000;
PORTB = B00000001; // 8
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00000010; // 9
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00000100; // 10
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00001000; // 11
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00010000; // 12
  delayMicroseconds(8);
    PORTB = B00000000;
PORTB = B00100000; // 13
  delayMicroseconds(8);
    PORTB = B00000000;

delayMicroseconds(1000);

//3 Horizontals

for (int i = 0; i < 35; i++) {
  PORTD = B00000100; // 2
  delayMicroseconds(8);
    PORTD = B00000000;
  PORTD = B10000000; // 7
    delayMicroseconds(8);
      PORTD = B00000000;
  PORTB = B00100000; // 13
    delayMicroseconds(8);
      PORTB = B00000000;

delayMicroseconds(1000);
    }

delay(150); // Pause

}

While this works mainly in concept, the idea here (below), is that the machine is capable of printing on its own parts.

This piece then becomes the top of the electronics box, and includes a label for the power button and "2-13" to indicate the orientation of the inkjets for programming.

However, the implications of this idea conceptually is to suggest that the further development of this machine could produce capabilities of milling parts and then printing assembly guides/instructions on the discrete parts to later be assembled by a different user.

Lastly, one of our major goals was to print on a complex 3D surface. We milled this piece of foam on our machine, and then generated a matching gcode that follows a 3D path to print on top of it.

Below is that print where we have also printed on more than one face of the object.

This at a larger scale also has implications we have been thinking about. If our machine was scaled up, we could be looking at machine that prints on larger 3D dimensional parts that could eventually become architecturally scaled components.

Fin.