Noah P. Allen

[In progress] Vertical Ga2O3 Schottky Barrier Diodes with Small-Angle Beveled Field Plates: A Record BFOM of 0.6GW/cm2

2019-06-13T00:00:00-04:00

This manuscript details work done to created a field-plated vertical Gallium Oxide schottky diode. I was responsible for a large portion of this work, where I developed a cleanroom fabrication process using standard tooling to etch circular mesa structures with controllable sidewall profiles into GaOx. Then I patterend the samples with back ohmic contacts and a top, field-plated schottky contact. Next, I measured the I-V characteristics and analyzed the data revealing superior electrical performance. Additional modeling and FIB was performed by Dr. Ming Xiao.

More information available once the manuscript has been accepted.

FIB Cross-Section of Gallium Oxide Mesa Edge

[In progress] Ru/GaN Schottky Barrier Inhomogeneity Dependence on Annealing Temperature

2019-03-13T00:00:00-04:00

Paper is being written and will be submitted shortly but below is some data which is expected to accompany the publication.

This paper will serve as an application of the model outlined in the Log-Normal Barrier Distribution paper. The dataset is made up of IV and CV data taken from Ru/GaN Schottky diodes that were annealed in open air at different temperatures but on the same original GaN wafer. Originally, the data was going to be published as it was taken and analyzed using the Werner-Güttler method with multiple barrier height patches instead of just one. However, when really teasing the data I found that there were some inconsistencies related to the physical understanding of how inhomogeneous barriers behave and its application to these samples. Thus, I needed to go back and refine the model which will be presented in a previous paper.

Variably Annealed Ru/GaN Schottky IV-T

[In progress] Impact of increasing Ammonia on deep level defects in GaN grown by MOCVD

2019-03-13T00:00:00-04:00

Paper is being written and will be submitted shortly but below is some data which is expected to accompany the publication.

We’ve found that simple decreasing the free carrier concentration by lowering the silane, a point will exist where the film will simple become insulative. Ideally, the switchover concentration where this occurs would happen at very low magnitudes so that the free carrier concentration can be controlled over a large range. In reality this point depends on the growth conditions. In this study we vary the Ammonia flow during growth while keeping the growth rate and free carrier concentration constant so that the deep level traps can be studied. Below is the preliminary data taken from DLTS, SSPC, and DLOS measurements which will be presented in an upcoming journal article.

[SUBMITTED] Characterization of Inhomogeneous Ni/GaN Schottky Diode with a Modified Log-Normal Distribution of Barrier Heights

2019-03-12T00:00:00-04:00

PDF File Download Publication Location

This browser does not support PDFs. Please download the PDF to view it: Download PDF

LabVIEW Remote Compressor Control

2018-10-01T12:00:00-04:00

Problem:

Although I’ve accomplished the ability to run long DLTS, IVT, and CVT measurements autonomously, I was worried about running the compressor when I wasn’t there. The compressor is water cooled and if I were to forget to turn the supply on or if the building services were to turn it off without me knowing then it would thermal cycle over and over. This means the He compressor would heat up to its trip temperature, cool down, and then do it again until I was able to cut power.

Solution:

This solution was actually pretty simple but turned out there were some weird hiccups along the way. The hardware solution should look very familiar since I used a lot of the same hardware and software as the Ethernet Controlled ND Filter including the ENC28J60. I chose ethernet because I have a distrust of wireless connections and serial connections along and the fact that ethernet has an almost bullet-proof physical connection. I decided that simply having a dumb switch wouldn’t work so I added a microphone used as feedback to check whether or not the compressor was actually on. The hardware schematic is shown below.

To ensure that the relay could handle the voltage that the physical switch on the compressor could, I traced the wires and found that the 250V_AC input voltage was transformed down to ~20V_AC so that it could power the compressor contactor and the timing circuit used to turn the compressor back on during a thermal fault. This was perfect since I originally thought about trying to switch the 250V_AC at 10A which would require a beefier relay and additionally circuitry to controll it.

Once I hooked it up, it worked like a charm and I only needed to write some Arduino code and LabVIEW code to complete the work. The Arduino runs a TCP server on it where it receives plain text strings that tell it to do something at which point it complies and then responds with some data, like the current volume or the compressor relay state. The LabVIEW program simply runs a TCP client and sends and receives these text strings which is updated on the front panel shown below.

I decided, as a fail-safe, to make sure that if the Arduino ever lost power, it would go back to the same state as it was in prior to turning it off thus the need for EEPROM. Every time the relay changed its state I could simply save the new state into a reserved spot in the non-volatile memory of the Arduino so that when powered on it would look at the same spot and restore its state. Next, knowing that electronics can behave very strangely in noisy environments, I needed to make sure it didn’t hang. A watchdog time would be perfect for this and since I programmed the current state into the flash memory, restarting the Arduino programmatically wouldn’t be a problem. HOWEVER, as it turns out, my cheapness bit me and WDT doesn’t work on these eBay Arduino Nano’s due to an error in the bootloader. Whenever the WDT would fire it would put the Arduino into a boot-loop and it would never come back.

Luckily, this program is well documented and I simply just needed to flash the Nano with a new bootloader following the directions here. After frying a few other Arduinos trying to get it to work (hooked up ground and 5V backward), it flashed and my work was complete. I could now successfully remote desktop into the computer running my LabVIEW program and turn the compressor on and off from the confort of my own bed. And better yet, I programmed the functionality into the DLTS, IVT, and CVT programs so it could be turned off automatically. Check out the Arduino code below.

Arduino Code

Again, the code is long but pretty simple. I use the UIPEthernet library as my ENC28J60 controller and then the built-in libraries for EEPROM, and WDT. The microphone is connected to A7 and the relay is connected to D4 while the EEPROM locations for the On and Off voltage thresholds and the relay position are at 0x00, 0x02, and 0x04 respectively. Once the ethernet TCP server is established, the WDT is set, and the relay position is restored it just waits. Whenever it receives one of the two character ‘codes’, it will execute a set of functions. For example if the TCP server receives the “R0” command it will set the digital pin High (relay off), set the RelayPosition variable to 0, reset the thermal trip variable, save the current state of the relay position, check the volume, and then respond to the TCP client with a string of data. Check out the code for other commands and send me an email if you have questions.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247 #include <UIPEthernet.h>
#include <EEPROM.h>
#include <MemoryFree.h>
#include <avr/wdt.h>

EthernetServer server = EthernetServer(1010);

const int RELAY = 4;
const int MicroPhone = A7;
float Volume = 0;
unsigned long Timer = 0;
unsigned long Timer2 = 0;
int RelayPosition = 0;
int onThreshold = 20;
int offThreshold = 25;
unsigned long TimeLimit = 10000;
int thermalTrip = 0;

uint8_t mac[6] = {0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0x06};
IPAddress myIP(169, 254, 195, 139);

size_t size;
EthernetClient client;

String MessageStr = "";

void setup()
{
  wdt_disable();
  wdt_enable(WDTO_4S);
  

  pinMode(7,OUTPUT);
  digitalWrite(7,LOW);
  delay(10);
  pinMode(7, OUTPUT);
  delay(10);
  digitalWrite(7,HIGH);

  
  wdt_reset();
  Ethernet.begin(mac, myIP);

  server.begin();

  wdt_reset();

  onThreshold = EEPROM.read(0);
  offThreshold = EEPROM.read(2);
  RelayPosition = EEPROM.read(4);

  if(RelayPosition){
    digitalWrite(RELAY,LOW);
    pinMode(RELAY, OUTPUT);
    digitalWrite(RELAY,LOW);
    thermalTrip = 0;
    RelayPosition = 1;
    EEPROM.update(4,(int)RelayPosition);
  }else{
    digitalWrite(RELAY,HIGH);
    pinMode(RELAY, OUTPUT);
    digitalWrite(RELAY,HIGH);
    thermalTrip = 0;
    RelayPosition = 0;
    EEPROM.update(4,(int)RelayPosition);
  }

  Timer2 = millis();

}

void loop()
{
  wdt_reset();
  Ethernet.maintain();

  if (client = server.available())
  {
    while ((size = client.available()) > 0)
    {
      char* msg = (char*)malloc(size);
      size = client.read(msg, size);
      for(int i=0;i<size;i++){MessageStr = String(MessageStr + String(*(msg+i)));}
      free(msg);
    }
    Ethernet.maintain();

    ParseString();
    client.println(MessageStr);

    client.stop();
    MessageStr = "";
  }

Ethernet.maintain();
CheckThermalFault();

if(abs(millis()-Timer2)>15000){
  
  digitalWrite(7,LOW);
  delay(10);
  digitalWrite(7,HIGH);
  delay(10);
  
  Ethernet.begin(mac, myIP);
  server.begin();
  Timer2 = millis();

}


}

void ParseString(void){
  String Message = MessageStr;

  int StrLen = Message.length();
  String strType = Message.substring(0, 2);
  String strInfo;
  if(StrLen>3){strInfo=Message.substring(2, StrLen - 1);}else{strInfo=String("Null");}


  if (strType == "R0") {
    //R0 Stands for turning the relay off
    SetRelay(0);
    Volume = CheckVolume(250);
	MessageStr = String("R0" + String(Volume));
    return;
	
  } else if (strType == "R1") {
    //R1 stands for turning the relay on
    SetRelay(1);
    Volume = CheckVolume(250);
    MessageStr = String("R1" + String(Volume));
    return;
	
  } else if (strType == "VO") {
    //VO stands for the current volume
    Volume = CheckVolume(250);
    MessageStr = String("VO" + String(Volume));
    return;
	
  } else if (strType == "R?") {
    //R? stands for checking the relay
    if(RelayPosition){
      MessageStr = String("R1");
      }else{
        MessageStr = String("R0");        
      }
    return;
	
  }else if (strType == "CT") {
    //CT stands for calibrating the Thresholds
    CalibrateThresholds();
    MessageStr = String("CT"+String(onThreshold)+"-"+String(offThreshold));
    return;
	
  }else if (strType == "TT") {
    //TT Thermal Trip checking
    MessageStr = String("TT"+String(thermalTrip));
    return;
	
  }else if (strType == "ST") {
    //TT Thermal Trip checking
    Volume = CheckVolume(100);
    MessageStr = String("R"+String(RelayPosition)+"\nVO"+String(Volume)+"\nTT"+String(thermalTrip)+"\nCT"+String(onThreshold)+"-"+String(offThreshold));
    return;
	
  }
}

void SetRelay(int MODE) {
  if(MODE){
    digitalWrite(RELAY,LOW);
    thermalTrip = 0;
    RelayPosition = 1;
    EEPROM.update(4,(int)RelayPosition);
  }else{
    digitalWrite(RELAY,HIGH);
    RelayPosition = 0;
    EEPROM.update(4,(int)RelayPosition);
  }
  delay(250);
  return;
}


int CheckVolume(float HowLong){
  float Value = 0;
  for(int i = 0;i<HowLong;i++){
    Value = Value + abs(analogRead(MicroPhone)/1024.0);
    delay(1);
  }
  Value = Value/HowLong*100.0;
  return (int) Value;
}

int CheckThermalFault(void){
  Volume = CheckVolume(100);
  Ethernet.maintain();
  if((RelayPosition)&&(Volume < onThreshold)&&(Timer == 0)){
    thermalTrip = 1;
    Timer = millis();
  } else if((RelayPosition)&&(Volume < onThreshold)){
    if(abs(millis()-Timer)>TimeLimit){
      SetRelay(0);
      thermalTrip = 2;
      return 1;
    }
  }else{
    Timer = 0;
  }
  return 0;  
}

void CalibrateThresholds(void){
  float Helper=0;
  float Helper2=0;
  if(RelayPosition){

    SetRelay(0);
    Helper = CheckVolume(1000);

    SetRelay(1);
    Helper2 = CheckVolume(1000);

    Helper = abs((Helper2+Helper)/2);
    EEPROM.update(0,(int)Helper);
    EEPROM.update(2,(int)Helper);
  }else{

    SetRelay(1);
    Helper = CheckVolume(1000);
	
    SetRelay(0);
    Helper2 = CheckVolume(1000);

    Helper = abs((Helper2+Helper)/2);
    EEPROM.update(0,(int)Helper);
    EEPROM.update(2,(int)Helper);
  }
  
  onThreshold = EEPROM.read(0);
  offThreshold = EEPROM.read(2);

  return;
}

Ethernet Controlled Graduated ND Filter

2018-03-20T12:00:00-04:00

Problem:

So, after the excitement of fixing the shutter jitter mentioned in the ‘Reverse Engineering the D750 Shutter for Remote Control’ project, I was able to take a nice looking SSPC signal from 3 samples but I noticed something interesting. Ideally, the SSPC signal below should only show slope increases when the incident energy is enough to excite trapped charge into the conduction band or out of the valence band but it seemed that the signal could be perturbed by some of the peaks in my 350W mercury source. In order to publish the data this needs to be fixed so that I’m not trying to make conclusions based on faulty data.

Solution:

As always, I checked for an existing solution that may be within financial reach but once again found they were much too expensive. The only thing I needed to do was control how much light was able to pass into the end of a fiber optic and quickly found that Newport and ThorLabs sold a circular and rectangular graduated ND filter. If possible I would have liked to use the circular one since attaching it to the end of a stepper motor would have been very easy but they were VERY expensive (>$1K) compared to the rectangular ones (~$114). Since the optics had been selected I only needed to figure out how to slide it in front of the light path. Having read a lot about 3D printers and how open source they have become, I decided to invest in a cheap ($75) stepper controlled linear actuator which I could mount the rectangular ND filter on and then slide in front of the optical path. Below is the linear actuator with the ND filter mounted.

Once I had the ND filter mounted it was time to setup the hardware so that it could easily be controlled by a LabVIEW program I had running on our main characterization computer. To control the stepper motor I first tried to use a generic L298N board I bought from eBay but quickly learned that an H-bridge wasn’t the most efficient way to control a stepper mainly because there was no circuitry to limit the current through each of the stepper coils. This resulted in saturating the coils with a 12V supply when the motor wasn’t moving. After a little research the DRV8825 Polulu clone from Amazon would be the best solution as far as price and usability. An Arduino seemed like the most sensible choice for quick prototyping but I wasn’t comfortable running a long (>30ft) serial cable across the lab so I decided to acquire a generic ENC28J60 board for Ethernet communication. Below is the circuit I used to interface all three boards boards along with the stepper motor. NOTE: The ENC28J60 is 5V tolerant but requires its own 3.3V power supply. I used two Buck converters to transform the 12V/2A wall wart to 3.3V and 5V.

The Arduino was programmed to act like a TCP server (using the UIPethernet library) which could be connected to by a LabVIEW running a TCP client program. The client connects and sends a short string which the Arduino server would interpret and either move or return requested data (Arduino program attached at the end). The next step was to check the range of attenuation I could achieve with my new apparatus. I set the wavelength to 435nm (one of the larger peaks in an Hg lamp spectrum) and moved the ND filter while taking optical intensity measurements. The intensity vs. motor step is shown below.

Finally, I created the algorithm to calculate the motor steps away from the limit switch which would give the correct attenuation value and once again measured the spectrum of the Hg lamp. As you can see below the photon flux at each wavelength is much more consistent but a lot of light power is lost.

Arduino Code

The Arduino code is long but pretty simple. I decided that the speed of moving the ND filter did not matter as much as the resolution so I chose to micro-step at 1/32. The first piece of code I wrote was to reset the stage to a known location. To accomplish this I quickly stepped the motor until I hit the limit switch at which point I SLOWLY micro-stepped off of it until it was no longer depressed and set the current location to ZERO. Next, I manually moved the stage to a few steps prior to hitting the far side and then I would run the ResetMotor() function to check how many steps it would take and found that 138,000 steps was the maximum I could go before hitting the other side. When testing for backlash and motor slippage I found that if I moved the motor <500 steps at full speed it would miss a few so I wrote a check in the MoveSteps() function that would move the motor a little slower for small motor movements. As for the Ethernet code, I basically used the UIPEthernet TCPserver example to setup the ENC28J60 to receive TCP packets and parse the data portion into a String. From there I just setup a few command strings to be recognized (GT, CS, RS, and EN) and then parsed accordingly (ex. GT120000(CR) would go to step 120,000). NOTE: The only way I could get LabVIEW to connect to the ENC28J60 was if I gave it an IP address VERY close to the computer.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281 /* Definition of all of the Ethernet Code
 *  ***********************************************************************
*/
#include <UIPEthernet.h>

EthernetServer server = EthernetServer(1000);
/*
 *  ***********************************************************************
*/


/* Definition of all the Stepper Code

*/
const int SLEEP = 2;

const int MODE0 = 3;
const int MODE1 = 4;
const int MODE2 = 5;

const int DIR = 7;
const int STEP = 6;

const int LIMIT = 8;

int stepMode = 0;
long currentStep = 0;

long MaxStep = 138000;
long MinStep = 0;

/*
 *  ***********************************************************************
*/

String MessageStr = "";


void setup()
{
  Serial.begin(9600);
  /*
   *  ***********************************************************************
  */

  Serial.println("Serial Begin");
  uint8_t mac[6] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};
  IPAddress myIP(169, 254, 237, 145);

  Ethernet.begin(mac, myIP);
  Serial.print("localIP: ");
  Serial.println(Ethernet.localIP());
  Serial.print("subnetMask: ");
  Serial.println(Ethernet.subnetMask());
  Serial.print("gatewayIP: ");
  Serial.println(Ethernet.gatewayIP());
  Serial.print("dnsServerIP: ");
  Serial.println(Ethernet.dnsServerIP());
  server.begin();
  Serial.println("Server Begin");
  /*
   *  ***********************************************************************
  */
  pinMode(MODE0, OUTPUT);
  pinMode(MODE1, OUTPUT);
  pinMode(MODE2, OUTPUT);
  pinMode(DIR, OUTPUT);
  pinMode(STEP, OUTPUT);
  pinMode(LIMIT, INPUT);

  digitalWrite(DIR, LOW);
  digitalWrite(STEP, LOW);
  digitalWrite(SLEEP, HIGH);
  stepMode = 5; // 1/32 Steps
  SetMode(stepMode); // 1/32 Steps
  Serial.println("Starting Motor Control");
  ResetMotor();
  /*
   *  ***********************************************************************
  */


}

void loop()
{
  size_t size;
  String MessageStr2;

  if (EthernetClient client = server.available())
  {
    while ((size = client.available()) > 0)
    {
      char* msg = (char*)malloc(size);
      size = client.read(msg, size);
      for(int i=0;i<size;i++){MessageStr = String(MessageStr + String(*(msg+i)));}
      free(msg);
    }
    Serial.println("Going to Parser");
    Serial.println(MessageStr);
    ParseString();
    client.println(MessageStr);
    Serial.println(MessageStr);
    client.stop();
    MessageStr = "";
  }else if(Serial.available()!=0){
    MessageStr = Serial.readStringUntil('\n');
    ParseString();
    Serial.println(MessageStr);
    MessageStr = "";
  }

}

void ParseString(void) {
  String Message = MessageStr;
  //Serial.println("In Parser");
  //Serial.println(MessageStr);
  int StrLen = Message.length();
  String strType = Message.substring(0, 2);
  String strInfo;
  if(StrLen>3){strInfo=Message.substring(2, StrLen - 1);}else{strInfo=String("Null");}
  Serial.println(String("Input Length:"+String(StrLen)));
  Serial.println(String("Input Type:"+strType));
  Serial.println(String("Input Info:"+strInfo));

  if (strType == "GT") {
    //GT stands for GoTo step
    Serial.println("GoTo Step");
    currentStep = GotoStep(strInfo.toInt());
    //Serial.println(strInfo.toInt());
    MessageStr = String("CS" + String(currentStep));
    return;
  } else if (strType == "RS") {
    //RS stands for reset the motor position
    Serial.println("Resetting Motor");
    MessageStr = String("RS" + String(ResetMotor()));
    return;
  } else if (strType == "EN") {
    //EN Stands for enabling and disabling the motor
    Serial.println("Setting Motor Enable");
    if (strInfo.toInt()) {
      digitalWrite(SLEEP, HIGH);
      MessageStr = "ENABLED";
      return;
    } else {
      digitalWrite(SLEEP, LOW);
      MessageStr = "DISABLED";
      return;
    }
  } else if (strType == "CS") {
    Serial.println("Motor Position");
    //CS stands for current step
    MessageStr = String("CS" + String(currentStep));
    return;
  }else if (strType == "??") {
    MessageStr = String(F("\nList of Commands:\nGT------(CR) | goto step where '-' is a number between 0 and 138000\nRS(CR)       | Reset Motor [returns # of steps from previous location]\nEN-(CR)      | where '-' is 0 or 1 for disable or enable\nCS(CR)       | Returns the current step [CS------]"));
    return;
  }
}

/* All of the Code to run the stepper
 *  ***********************************************************************
*/

void SetMode(int MODE) {
  switch (MODE) {
    case 0:// Full Step
      digitalWrite(MODE0, LOW);
      digitalWrite(MODE1, LOW);
      digitalWrite(MODE2, LOW);
      break;
    case 1:// Half Step
      digitalWrite(MODE0, HIGH);
      digitalWrite(MODE1, LOW);
      digitalWrite(MODE2, LOW);
      break;
    case 2:// 1/4 Step
      digitalWrite(MODE0, LOW);
      digitalWrite(MODE1, HIGH);
      digitalWrite(MODE2, LOW);
      break;
    case 3:// 1/8 Step
      digitalWrite(MODE0, HIGH);
      digitalWrite(MODE1, HIGH);
      digitalWrite(MODE2, LOW);
      break;
    case 4:// 1/16 Step
      digitalWrite(MODE0, LOW);
      digitalWrite(MODE1, LOW);
      digitalWrite(MODE2, HIGH);
      break;
    case 5:// 1/32 Step
      digitalWrite(MODE0, HIGH);
      digitalWrite(MODE1, LOW);
      digitalWrite(MODE2, HIGH);
      break;
    default:// Full Step
      digitalWrite(MODE0, LOW);
      digitalWrite(MODE1, LOW);
      digitalWrite(MODE2, LOW);
  }
}//END SetMode

long ResetMotor(void) {
  Serial.println("Inside Motor Reset");
  long i = 0;
  digitalWrite(DIR, LOW);
  delay(500);
  while (digitalRead(LIMIT)) {
    digitalWrite(STEP, LOW);
    delayMicroseconds(3);
    digitalWrite(STEP, HIGH);
    delayMicroseconds(5);
    digitalWrite(STEP, LOW);
    delayMicroseconds(3);
    i++;
  }
  digitalWrite(DIR, HIGH);
  delay(500);
  while (!digitalRead(LIMIT)) {
    digitalWrite(STEP, LOW);
    delayMicroseconds(3);
    digitalWrite(STEP, HIGH);
    delayMicroseconds(5);
    digitalWrite(STEP, LOW);
    delayMicroseconds(3);
    delay(1);
    i--;
  }
  //Serial.print("BackFrom: "); Serial.println(i);
  currentStep = 0;
  return i;
}//End ResetMotor

void MoveSteps(long numSteps) {
  int Delay=0;
  if(abs(numSteps)>500){Delay=0;}
  else{Delay=2;}
  if (digitalRead(LIMIT) && (numSteps < 0)) {
    digitalWrite(DIR, LOW);
    for (long i = 0; i < abs(numSteps); i++) {
      digitalWrite(STEP, LOW);
      delayMicroseconds(3);
      digitalWrite(STEP, HIGH);
      delayMicroseconds(5);
      digitalWrite(STEP, LOW);
      delayMicroseconds(3);
      delay(Delay);
    }
  } else if ((numSteps >= 0)) {
    digitalWrite(DIR, HIGH);
    for (long i = 0; i < abs(numSteps); i++) {
      digitalWrite(STEP, LOW);
      delayMicroseconds(3);
      digitalWrite(STEP, HIGH);
      delayMicroseconds(5);
      digitalWrite(STEP, LOW);
      delayMicroseconds(3);
      delay(Delay);
    }
  } else {
    currentStep = 0;
    return;
  }
  delay(500);

}//End MoveSteps

long GotoStep(long Step) {
  if (Step > MaxStep) {
    Step = MaxStep;
  }
  if (Step < MinStep) {
    Step = MinStep;
  }

  MoveSteps(Step - currentStep);
  currentStep = Step;
  return Step;
}

Reverse Engineering the D750 Shutter for Remote Control

2018-03-20T12:00:00-04:00

Problem:

Ideally, to complement the DLTS system that our group owns we should also be able to excite electronic defects through and optical method to help understand the full extent of bandgap traps in GaN. A simple method known as Steady-State Photocapacitance measurements uses sudden exposures of single wavelength light to excite trapped charges out of deep states in a semiconductor and measures the response with a fast capacitance meter. In other words we put a shutter between a sample and the light source, let the sample sit in the dark for some time and then open the shutter and see what happens.

The problem I was facing was trying to time the exposure of light accurately with a safety shutter (Oriel 71445) and a digital signal from a LabVIEW program. Results can be seen below where I send the signal to open the shutter but the delay to open isn’t consistent which makes automation of detailed analysis almost impossible.

Solution:

The first idea was to buy something since “a simple shutter shouldn’t be expensive” but after looking I found that was not the case. The next idea (like most of mine are) was to try and make one. Since there didn’t seem to be ‘broken’ shutters on eBay I looked to try and score repair parts for a DSLR camera and reverse engineer the pins. Below is a picture of the D750 Shutter Blade Assembly Replacement I bought.

It took a little while to figure out how the shutter worked and in turn how to control it but it goes something like this. The light blocking method is accomplished with two shades which are tensioned with a spring. The motor will cock both of the shades until the metal core connector piece (connected to the shade) touches the electromagnet core. If power is running through the inductor, when the metal piece touches the core it will stick, thereby keeping the shade anchored. Once power to the inductor is stopped the spring tension pulls the shade back to the original position.

The final piece of the puzzle is the motor position. When the motor cocks the shutter blades it needs to keep moving so that the cocking arm isn’t in the way when the shades are ultimately relaxed to their original position. This is difficult because the shutter assembly uses a DC motor and has no feedback. This was solved by putting a few notches into one of the motor gears and sensing the notches with a couple photointerrupters. This is what is implemented on the D750 shutter assembly.

Now that we generally understand how the shutter works we need to setup a circuit and microcontroller to cock the shutter blades and then release them when ready. I decided to that the following circuits would be adequate to control the electromagnets and motor and then sense the position of the motor. The red outline indicates the circuit exists on the shutter assembly and the blue represents a circuit I need to implement.

With some probing around to discover the polarity of some of the circuits, below is the full interface diagram I implemented to control the shutter assembly. Notice that I’ve also added a voltage buffer (op-amp) for the input. I’m connecting a digital signal from the LabVIEW DAC over a long BNC cable and found that when connecting it directly to the gate of the MOSFET the voltage sagged (probably because of the 1K pull-down resistor) so I decided to add the opamp in series to increase the input impedance.

The code I used is below. Basically, the BNC input in the circuit above controls whether or not the OPEN electromagnet is holding the shutter blade and the Arduino is just checking whether or not the digital signal is high or low. After the BNC input indicates that it’s ready for the shutter to be reset the Arduino sends a full power PWM signal to the motor control MOSFET until its reset the shutter blades at which point it will cut the power down to 10% (duty cycle 20 of 255). Then it will wait until the motor position is at the correct point to turn the motor off. I found that if the program turned the motor off from 100%, the momentum would push it past the correct reset position and the blades would get stuck. Lowering the power while it was still moving gave it enought of a push to make it around again but not enough to cause the motor to drift when it was turned off.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74 unsigned long time;


void setup() {
  pinMode(2,INPUT); //Open Shutter Hold
  pinMode(3,OUTPUT); //Close Shutter Hold
  pinMode(6,OUTPUT); //Motor
  pinMode(13,OUTPUT); //Debug LED
  pinMode(7,INPUT); //Motor PhotoInterrupter 1
  pinMode(5,INPUT); //Motor PhotoInterrupter 2

}

void loop() {
  // put your main code here, to run repeatedly:
  
  while(digitalRead(2)){   //Wait until High-Low
    __asm__("nop\n\t"); 
    }
    
  digitalWrite(13,false); //Turn LED OFF 
  
  delay(5);               //Wait for Bounce
  
  while(!digitalRead(2)){ //Wait until Low-High
    __asm__("nop\n\t"); 
    }
    
  delay(5);               //Wait for bounce
  if(digitalRead(2)){    //Check actually high
    digitalWrite(3,false); //Close Shutter
    delay(150);             //Wait for close
    digitalWrite(13,true); //Turn LED ON
    digitalWrite(3,true);  //Engage Close Shutter Hold
    ResetMotor();
    }
   
}

void ResetMotor(){

  analogWrite(6,255);//Turn motor on to reset
  
  
  
  time = millis(); 
  while(!(digitalRead(7) == HIGH  && digitalRead(5) == HIGH)){ //Wait until motor out of correct position
    if((millis()-time)>500){analogWrite(6,0);return;}
  }

  time = millis();   
  while((digitalRead(7) == HIGH  && digitalRead(5) == HIGH)){ //Wait until motor out of correct position
    if((millis()-time)>500){analogWrite(6,0);return;}
  }

  analogWrite(6,20);//Turn motor on to reset

  time = millis();
  while(!(digitalRead(7) == HIGH  && digitalRead(5) == HIGH)){ //Wait until motor out of correct position
    if((millis()-time)>500){analogWrite(6,0);return;}
  }

  time = millis();
  while((digitalRead(7) == HIGH  && digitalRead(5) == HIGH)){ //Wait until motor out of correct position
    if((millis()-time)>500){analogWrite(6,0);return;}
  }

  time = millis();
  while(!(digitalRead(7) == LOW  && digitalRead(5) == LOW)){ //Wait until motor in correct position
    if((millis()-time)>500){analogWrite(6,0);return;}
  }
 
  analogWrite(6,0);  //Turn motor off   
}

Hg Probe Back Contact Piece

2017-08-01T12:00:00-04:00

Problem:

Being able to quickly and cheaply identify the free carrier concentration in a semiconductor layer can be helpful when slight changes to material growth parameters can increase or decrease contamination concentrations such as carbon. In GaN carbon has been shown to incorporate electrically as a deep-level trap near the mid-gap and decrease the overall carrier concentration. Thus when varying the carbon incorporation it would be good to know when your dopant atoms are compensated by contamination. A mercury probe system allows researchers to instantly make metal contacts on the top surface of a sample and run tests, such as measuring the free carrier concentration. However, the samples must be >1cm² to adequately cover a vacuum ring which pulls the mercury up onto the sample. We had a needed to measure small (<0.9cm²) samples and thus had to create an adapter.

Solution:

In order to measure these samples we only needed to keep pressure on the back while also sealing the sample so the vacuum could pull the mercury up onto the sample. This could have been done by laying a piece of flimsy rubber or tape on the back of the sample however, we also wanted to ability to make electrical contact to the back of the sample.

Hg Probe With Sample

Sample on Hg probe stage that is (left) large enough to fit over the vacuum ring and (right) too small to fit over the vacuum ring.

It was decided that because the Hg probe is made of acrylic that we could machine the adapter from the same material. We started with a 1.25” round, planarized the end, machined a recess for the sample to sit in, then dropped in two pogo pins, and finally glued the top pin to the adapter. The final product is shown below. The purpose of the pogo pins was to keep pressure on the sample while also making electrical contact to the back of it. Additionally, planarizing it helped seal the acrylic-acrylic interface so vacuum could be pulled in the sample recess.

Hg Probe With Adapter

Shown above is the 3D model assembly of the Hg probe adapter where you can see the sample (blue), an o-ring (black), the two pogo-pins (gold) and the machined acrylic adapter (grey).

Thin-film GaN Schottky diodes formed by epitaxial lift-off

2017-02-24T00:00:00-05:00

PDF File Download Publication Location

This browser does not support PDFs. Please download the PDF to view it: Download PDF

Cleanroom Fabricated Gallium Nitride PN Diodes

2016-11-01T12:00:00-04:00

Work:

Improving semiconductor power electronic material will have an affect felt throughout the power conversion industry mainly with improvements to breakdown field strength, conduction loss, and reliability. As part of a project with ARPA-E we were growing and fabricating PN diodes on Bulk GaN wafers which were commercially bought. Typically, MOCVD grown GaN is done on sapphire wafers but due to lattice mismatch and electrical conductivity problems, new work has begun trying to make growth on bulk GaN more attractive. My part in all of this is working with the material scientists in the group to create viable PN diode structures, taking the grown layers into a cleanroom environment to fabricate surface passivated and field-plated PN diodes, testing them in a probe station and finally analyzing the data.

The figure above is being used just to show the parts of the final device that would be hard to understand in a static image, it does not show the actual fabrication process. When putting the diode into forward bias you inject minority carriers into the respective regions (holes into n-type, electrons into p-type) which creates a situation where radiative recombination can occur. Depending on the transition that is made, different light will come out. The figure below shows this very phenomena however, in GaN if the transition is happening from the valence to conduction band it wouldn’t be visible (363nm - UV). This implies that the transition may be occuring at trap levels in the forbidden gap likely there due to impurities. Additionally, if you watch long enough you’ll see little arc’s from the high electric field in reverse bias.