They generally are sold as shipped in the USA and actually drop shipped from China. Takes about 7 days usually.

Very well packed, but as usual has that weird smell that everything we’ve bought has from China.  So dispose of the bubble wrap as quickly as possible.

Cursory glances the power supply has what sounds like a loose screw rattling around, the machine looks cheaper than the photographs,  but then again who expects to get a hamburger from McDonalds that even barely resembles the pictures on the advertising. You know what you’re signing up for when eBaying, Las Vegas rules here. To be fair to the Chinese companies though their advertising pictures are about 9000 times more accurate than the McDonalds ones though. It also looks smaller than it did on eBay, this is why size reference pictures need an apple.

Apparently it uses something called a ‘Parallel Port’  (I keed, I keed), well that won’t last for long.

Our LPKF is a lot nicer, (not as nice the AccurateCNC), but it is going under the chop too.

Well ok we might ARM a few.

So it been a while since my last update, my lil’ dog of 16 years had to be put down and I wasn’t feeling it, then family visited from so we stalled abit.

So quick updates for the tl;dr people :-

• Head rotation works, but have to add an encoder wheel since we ‘forgot’ about the tool home position inside the head tool pickup…
• Y axis is all upgraded, new stepper motor drivers are in 1/2 step is on.
• Switched to GRBL and StepDir, instead of, uhh, not stepdir.. Though using the
• OpenPNP base firmware revision, i didn’t realise it was different til after porting it.
• GUI is almost done, it can place one full board from feeders and trays
• Replaced hoses as the old ones burst, which only happens when you say right lets video this.
• Trapezoidal for the servos courtesy of Grbl.
• Still having some issues with the vacuum sensor, might be bad or low pressure or something else, turned it off for the moment.

Pickobear uncut.

So we’re able to pick up and place with the new Grbl firmware and the updated GUI, its all GCODE now. I’ve moved more of the functions into the GCODE vs individual move, drop , vacuum, since the communication is just serial rx/tx and serial is a PITA for this sort of thing, since its all ACK/re-ACK. With an M command its just e.g. M21 pickup part, M22 putdown part and the machine reports yes/no. FTDI’s are decent chips but they will break down comms after long datastreams, I’ve had a lot of problem with them and high speed streaming, as well as overlapped IO support is meh, events don’t work that well so multithreaded serial comms based on events is in theory great, but the practise doesn’t always work well. so its all software handshakery.

We’ve done a lot of changes since the last update.

Grbl

Grbl’s great, its easy to use and easy to add on too, we were already using the AtMega2560 anyway so lots of space, even with all the stuff I’ve added to it, we’re at maybe 17%of the  flash space. I had looked at it when we first started out, but it needed StepDIR and were using – + , our original drivers didn’t support StepDIR. Even luckier I’d put all the stepper controls on the same ports.

Changes for the 2560 are minor, just an interrupt rename and i don’t the sleep mode is working as it ought too, i assumed it was and then wondered how to handle the panel switches but turned out when i added the head movement ACK that it was, I was going to use timer3 to handle switches but then i noticed the main loop was executing constantly, some of the AVR’s have different sleep rules.

One thing i did do though is since the mega ICSP is under the shield and its on the machine, which is 3 metres away from desktop. I left the Arduino serial boot loader  on the chip, this way i can just script AVR Dude to load the firmware built in AVR Studio 4 to the mega over serial. so its a lot easier, the downside is that if you press a key too soon the boot loader seems to kick in, i haven’t checked this to be the reason for sure, but it seems like its that. Not a huge deal.

Running a test of the GUI

Pick and placing, it takes a lot to just do this seemingly simple thing.

Head rotation

Head motor, luckily we used a double ended shaft motor in case we needed an encoder, which it turns out we do. Look closely at the top of that shaft, see some thread? yeah we didn’t…. We CAD’d up a mount and fitted the motor.

The motor is 1,000 steps for a full 360 degree rotation, should be able to place the craziest of our boards, we like some gangsta lean in our part placements.

As a side note the magnetic sensor on top of the head, really don’t like the way they’re made or mounted, that wire takes a beating and it’ll fail again so we have to fix that too. You can see all our temporary fixes for the hoses that keep cracking, they’ve lasted 20 years though. The red line is the new one we’re using, which is way more high tech than what was available in those days, it should last longer than the tech is needed.

The rotation head needed a larger power supply, so that is now installed. Its the 24V power supply previously mentioned from all electronics.

Since we made the shield with the extended pins its easy to add things on to it. And now we’re on StepDir its just one wire to control the head ( Though we make a semi-fatal error at this step in choosing which direction the motor runs )

Setting up a test

After the rotation head was added to the software, i test placed two parts, they’re off, at this point i think its the solder paste or tape missing, so we add some. As you can see though the parts are rotated as they should be. We were uStreaming with the second camera so its all hanging off in space at the moment.

Krs adds some paste to the test pads. She’s the one who wants this thing finished the most as she builds most of our boards

I’m remotely moving the head with the camera view. First home, then moving to the PCB to register the location of the part, then going through the steps of the part placement.

So the mistake in the choice of direction for the head rotation is that the head can unscrew itself and drop down the tool, the sensor doesn’t know the head is down and the tool is now below the PCB holder and auto changer, so the head will gleefully zip around and bang it into whatever it can find, which bends the head, which is not good at all.  So we’ll reverse the direction of the motor and use lots of Loctite. This is why the test videos show the parts poorly placed.

Pity these lessons learnt cost us a head each time.. But we move on..

A trial run through all the parts ( using 1206 resistors since they’re like .00004 each) as you can see they placed perfectly.

Ok, maybe not what you’d call perfect but they did place in the right spots, the head down motion was a little too strong and there’s no paste to hold the parts in place so they’ll wander around every time a part is placed. Still the software is working.

The vacuum sensor needs to be set quite accurately or it’ll do things like this :-

The tool is sitting perfectly on the vacuum test pad, the head brought it down to see if was there, blocks the air coming through the tool, but since it wasn’t picked up correctly ( head wrong orientation ) it just left it there.

The head moves to the pad, goes down, the air comes on, there is a settle time, then the machine reads the vacuum sensor, if its not blocked there is no tool, if it is, then there is a tool.  That is how it decides if the tool needs to be picked up or put back.

Finally we place a board with paste and all !

So last night(this morning) we finally managed to run a real board. For some reason i decided to go through each of the components and rotate them 90 deg rather than change the rotation in the feeder…. derp… As we did this the vacuum test failed, so you can see me going in change the code ( incorrectly!) and re running, it the bit you might not see is the machine doing a loop of picking up a part… i fix that and we move on.. First run we do a step by step. I noticed a few bugs as we go along so there are some pauses as we fix those.

Stencil pasted a board, you can read about this in our Arduino Mega build blog entry. Its a CNC’d brass sheet.

I taped the board down to stop it moving around, probably not needed.

Some of our feeders need some love and i wasn’t super careful about where i was picking up the parts from so it was a little sloppy, however it was 2AM and i ended up having to leave and come back after one of the alarms at work went off

MMCA used one of his awesome swiss files to ‘fix’ one of the feeders that was catching

Here are some more GUI videos, they’re probably only interesting to those of thats like watching these things over and over..

Annotated some of the steps in the GUI.

One of the feeder pickups i didn’t setup properly, so it was placing them off!

Onto the hotplate, i wanted to see just how bad we could place parts and if they’d fix on the plate, all but one pulled onto the pads, the other worked but was right on the edge of a pad, it’d work fine. All we have to do is take more care when tell it where to pickup

Krs also has a bunch of videos of the machine placing that first board.

http://www.flickr.com/photos/krs_/6555389059/
http://www.flickr.com/photos/krs_/6555380305/in/photostream

Anyway that is mostly it, we’re down to the tuning and bug fix stage so its been pretty fun.

But if you’ve got minerals help out the OpenPNP guys they’re doing good work, our stuff is available to everyone, but its reasonably specific to the Juki though it is GCODE.

Small update: Last night, I started adding the second USB port of the ADK to Grbl as well, its almost finished. I based it on the usb.cpp from ADK but i converted it to C  since the c++ generated a larger firmware and there is only one USB port, I want to keep the firmware tight.

BTW If you’re reading this and are on the yahoo zevatech list the moderator who’s apparently building a commercial retrofit for this machine is blocking our posts sharing this open source project. He said he wants credit for a CPU suggestion neither his or our project uses, a fix that wasn’t broken, and a camera solution we didn’t ask for advice on, or use.

cheers,
charliex
http://032.la

Miss you girl

• Rotation servo in the head
• Consistent speeds
• Addition of more checks

Adding more checks was straightforward, added code to determine if the machine picked up a part, with the small compressor we were using it’d start to loose vacuum so if it failed to pick up a part, the delay became longer. This  allowed the the compressor to catch up a little, as well as alert the user that something was amiss.  Next it checks to see if the part fell off during transport to the board. The machine has a vacuum sensor that knows if the top is being blocked. This lets the machine controller (Arduino) know a part is probably there.

The machine won’t move if the head is down, and the limit switches were put on interrupts. tool changers are tested and put down if they’re up for some reason.

The interrupt based limit switches are nice, anytime a change of the signal is recognised, either in limit or coming out of limit the routine is called and it reads the status of the pin again, and sets the out of home condition, so that machine controller knows the machine should be rehomed before continuing.  The code is simple and looks like this in the setup()

attachInterrupt(5, x1Limit, CHANGE );

void x1Limit( void )
{
  homed = false;
  xLimit1 = digitalRead( XL1 );
}

attachInterrupt takes the pin number , the function to call and type of signal to look for, HIGH, LOW, and CHANGE, i use  CHANGE so that the xLimit1 variable is always set properly, and rather than rely on software tracking I read the state back in.

I’ll probably change the digital read to actually just read the PORTx value directly, you want to minimise time spent in an ISR (interrupt service routine ) as much as possible. 5 is the pin that the XL1 limit switch is connected to on the shield, and homed/xLimit1 are volatile global variables that have the condition, they are set as volatile since they can be changed at unexpected times, either by the hardware directly or the ISR. volatile lets the compiler know not to cache the value or other trickery. This is often the case with things like memory mapped hardware clocks where you read a specific memory location to read a clock, so you’d do something like (clockVal would be set to the specific memory location by the linker or other directive)

const volatile unsigned long clockVal;

We’re not using const for the homed/xLimit1, since we are writing to it via software, a hardware clock changes outside of our code.

Ooops

Someone knocked one of the feeders slightly off (probably me) as it was being worked on, I didn’t notice and moved the head.

It caught the feeder pin ( bottom left) and bent badly enough that it wouldn’t go back down. So i pulled it apart and used a vice with cut outs and gently squeezed it back into shape, then mmca used his micro lathe to make it straight again. Luckily these are easy to make from scratch.

Servo Pulses

The servo pulse speeds are more of a pain, the Arduino has some fairly inconsistent timing and some of the functions you’d expect to be fast, aren’t, the delayMicroseconds has a lot of skew, digitalWrite takes a long long time. Once you know about them, they’re easy to deal with i replaced them with bitSet/bitClear and the __builtin_avr_delay_cycles feature in avr-gcc.  We captured the output of the servos from the Juki PC with a scope and my logic analyser. That allowed us to see the ramp up and down times to get the head moving at a decent clip. There is still some ripple in the software PWM though, so we’ve converted most of it over to just  AVR asm/C and setting the ports individually,the Arduino does what it is meant to do really well and that is be easy to use, but what’s uncommon about it is that it easily lets you drop in code that bypasses or override the built in libraries, in my experience that’s rare in other simplified dev kit software, its typically all or nothing.

Changing the digitalWrite is straightforward. Determine which port the pin you want to set is on and then use bitClear or bitSet instead.

digitalWrite(YCCW,HIGH) becomes #define YCCW_HIGH   bitSet(PORTF,3); YCCW is defined  as A3, which on the mega is on PORTF, bit 3. digitalWrite LOW is bitClear(PORTF,3)  going even further the PORTF can be manipulated directly with PORTF |= (1<<3) to set it, then you can combine them together with PORTF |= (1<<3)|(1<<2) etc to clear PORTF &= ~( (1<<3) | (1<<2 ) ) also there is a _BV() macro that does the (1<<n) shift. so

PORTF |= _BV( 3 )

Using |= and &= should output the closest ASM instructions that you can could in C.

Once we started to investigate the timing from the Arduino that is when I noticed the problems, even with interrupts disabled we were seeing inconsistent results. So I wrote some test code and hooked up the output to the LA and set about trying to make a micro second accurate delay. specs showed a 2uS rise , 5uS pulse and 2uS fall for the initial step pulse, the stepper IO controller is HIGH delay LOW delay HIGH . for the first delay about 8uS works well.

We captured the data with the logic analyser and pulled the data into Excel which is great for this sort of thing.

A quick couple of macros and copy/paste and we’ve got differences in Column F , you can see the length of the pulse in F3 and F4 has the off time length, which gives us our full duty cycle for that pulse.

In H its just the lengths of the off times since the on time is constant. Column I has the differences.

One of the next things excel can do is trend lines, I did this by hand and then arko showed it to me, I’d seen the equation solver before but not this.

First create a line chart with the off times (the part of the duty cycle that’s after the pulse)

Click on the data points in the line to select the line. then use the trendline option

Set the options like so :-

Which gives you this trend line (in black ) and the algorithm for it. I opted to use a table lookup since it has to be super fast for the Arduino.

Time Travel

Skipping back a little after the last blog post we did an 0603 repeatability test, used the layerOne speaker badge as a base, I exported the centroids from eagle for one side and ran test code. As well as just have the machine draw lines of 0603’s. with a logo-esq list of commands.

The left side has a little wobble, partly pickup, partly the slightly bent head ( we’re lucky that a generous person sent us a new head and feeders you rock Steven ! ) the right side is a similar test but its placing the 0603s on top of each other, that actually worked pretty well a few of them fell over. But given the bent head, no centering or machine vision its working better than we can hand place them. This picture is the version that just places the parts in lines. I also think our stop is a little aggressive in this test, and this is before we really got into the ramping.

The ramping is simply having the PWM have a longer off time, pulsing the servo, decreasing the off time, pulse it again and do that for N pulses until the motors are moving fast enough to get to the top speed, that’s what the Excel sheet is for. I’ll go into it in more detail in another post.

Someone from Russian TV decided to film it, Central TV i believe. Unfortunately all the airlines are now tight so i can’t remotely shoot air or disconnect hoses at him anymore.

Adding a camera

This is a Cognex 4100 machine vision camera, machine vision cameras are generally low noise, stable image sources. This one can determine angles, and so on and then send them out via Ethernet or serial. The 4100 has been dropped by Cognex it seems and the software needed to run it is an old version, which has a lot of compatibility errors with Windows 7, its been something I’ve seen before where the menu’s lockup for a long time. But we figured our way around it by using Windows XP inside 7 with its builtin Virtual PC and got it to see the rotation.  Think RoboRealm built into a camera.

Controller unit

Inside the camera, TI DSP and a Xilinx FPGA, very nice.

Camera head

We’re also using some webcams , a couple of them are microscopes, one is from think geek and it’s a wireless HView camera, the other was an eBay special pen microscope usb2. Oddly finding a 12mm drill bit to make a hole for the camera wasn’t so easy.

Adding the camera needs two pins for the servo CW/CCW, three pins for the camera, TX/RX and trigger. The shield has three pins left!, Though I did cheat and use two of the pins as a via since I didn’t’ really want to deal with the LPKF via rivets even though its only a few of them. We do really only need RX though.  The trigger just tells the camera to only operate while, or after the trigger is set. The final board will not use the cheats of course, but before I remill a new one we have to

Software testing

This is our test bed software Pickobear it allows us to test OpenCV (though we have a Cognex camera), the eagle script output CSV is imported into Pickobear and then the machine knows how to place it.

One of the problems with test software is you often leave it in a state where it was testing something specific, and you forgot to remove it , case in point, I had one extra YCW pulse that caused a problem when we were doing a tool change test. After 4 changes it’d refuse to put down the changer, we checked air pressure, offsets, tool head distance and all that, eventually did test code that moved home, then to 0,0, 1000,1000, back to 0,0 and saw it was one Y off each time. A quick check of the firmware and the extra pulse was spotted. But it did allow us to get the numbers needed to exactly place the adjustment for the pickup head.

Next we’re testing out different cameras, I milled out a quick holder from PCB material and the epic blue painters tape. This is a nice’ish USB 2.0 camera that’s setup as a microscope, it came with a nice metal holder and was about $80 from eBay. M4 nuts and bolts seem to be rare around us, never mind the M2.5’s we were looking for locally last week. So zip tie to the rescue temporarily, it does allow a little yaw though but it is ok for testing the software until the bracket arrives.

To make this I measured the hole sizes, the distance apart and picked a distance for the camera, then guessed the size. I then added two drill holes with the hole command, set the size to 4mm for the larger 12mm hole I used the milling layer, draw a circle with the circle command, and set the width (right click circle and choose properties or type change width ) to a very small number, if you use 0.0 as the width eagle will fill in the whole circle and doesn’t cut anything, a width of 0.0 works for milling wires, but not circles. Then milled it out on our AccurateCNC 560H.

Now we fit the new holder, has a nice set screw to hold the camera in place.

Next is adding camera movement and offsetting the board. I did this by adding a mouse click even to the custom control, it then determines the center of the image and a difference calculation, then depending on the direction it needs to go it moves that amount, I still have to calibrate what the relationship of the camera image is to actual axis steps, but its close enough to use right now.

I’m using videoInput with OpenCV and OpenGL to display the data from the cameras, the crosshairs and circles are drawn into the OpenCV image using their primitives.

cvLine(img1,  xyF, xyT, CV_RGB(0,0,200),2);
cvCircle(img1,xy,100,CV_RGB(0,0,200),2);

Camera setup is straightforward

int numDevices = VI.listDevices();

m_camera = DeviceID;

VI.setupDevice(m_camera);

img1 = cvCreateImage(cvSize(VI.getWidth(m_camera),VI.getHeight(m_camera) ),IPL_DEPTH_8U,3);
assert(img1);

img2 = cvCreateImage(cvSize(VI.getWidth(m_camera),VI.getHeight(m_camera) ),IPL_DEPTH_8U,3);
assert(img2);

There is a nice simple class I’ve used for rendering OpenGL into an MFC custom control for a while.

http://www.codeguru.com/cpp/cpp/cpp_mfc/tutorials/print.php/c10975__2/

Head servo rotation

The rotation head is the next thing we’ll get fully operational. We decided to upgrade the 24V power supply since the little servo can draw more amps than it could safely handle. All electronics has suitable 24V 6.5A deals.

http://www.allelectronics.com/make-a-store/item/PS-24150/24-VDC-6.5A-150W-POWER-SUPPLY/1.html

$26 at the time of writing.

A custom CNC’d bracket was designed by mmca and laid out  in solidworks by arko, the motor, pulley etc are all added. This allows us to switch from the simple 90o rotation to full a 360o’s so we can place the part turn 360’s and moonwalk away from it. There is some play in the rotation shaft because of the set screw, so that is being remade so there is no backlash., even though its a tiny amount and the software can correct it. The machine is able to do more than 90o in steps of 90o by simply changing which side the feeder is mounted too, but we want 45o’s for those gangsta leans.

The top bracket/reed switch isn’t mounted or screwed down, that is why its tilted.

New standoffs added and rest of head mounted.

So here is a short video showing the setting of the PCB offset, I home the machine, pick the part I want to use a registration. Then move to the location where it really is and press the OFFSET button., then I move around to other components just to check its working, again the blue lines are OpenCV doing stuff.

Pickobear!

Motor Drive Upgrade

The Y motor driver and motor aren’t that great, so we changed it out for this controller

First removing all the old wiring and converting it to the style connectors, it’s a shame to do this as the wiring is just so nice compared to modern equipment. Its not often you see this level of attention anymore.

New controller in place of the old one, it fits pretty well its longer than the old one but luckily there was lots of room, we just have to extend the AC lines a little.

Removing the plastic conduit covers and rerouting the wiring.

Almost there, I’m heading out early tonight and we apparently don’t have crimpers at NSL so rather than botch it, I’ll pick up some tomorrow or bring mine in from home

A new motor was fitted too.

Dirty fans!

Close up of the belts and cogs etc.

New vexta motor

Machine powered up and homed ok ! sweet..

I’m not sure how detailed or long to make each of these posts, since from reading the comments and emails, its obvious a lot of people skim or don’t read the text and look at the pictures, but I want to make sure we give enough details ( plus the wiki/svn ) so that people can recreate it. We are at the point we can pick and place our boards, surpassing the original software in some ways, a few things are left to be done to make it 100% of the original features sets, mostly to do with feeders. But we’re waaay beyond what it could do in some ways.

So here we are with part two of the build. We’ve figured out most of it, started the build of the arm board and so on, then on Friday night late I have one of those, hmmm, moments and say wait we have a lot of ADK mega arduino boards lying around (because we made a tonne of them for defcon 19). So a quick count of the IO pins needed vs the mega and we find it can be done. 

We test fire the MOSFETs with our ADK arduino, using one of the ATC( tool changer) pneumatic switches. That works just fine, the modern MOSFETs are amazing even though we need no where near the level of current this thing can handle.

We wired up a quick test.

Breakout board for the TUMT6 MOSFET

Just as ping is the ubiquitous test on the internet, blink.pde is on the arduino.

Success, yes the tool did go flying off but that’s ok! We simply connected up pin 13 of the mega to the electro switches in the top left, the board is bypassed since it does a BCD decode and select.

Blink does it’s thing.

So time to build up the new interface card, a quick search through some of the old machines we find the right floppy pin cable for the board, and the old 50 pin scsi type.. thanks petty!..

So  next step is to CNC up a header quick board, its an extremely simple board. Bust out eagle and start making the board, the Juki has one oddness that the connectors run 1-2-3-4-5-6… etc vs 1.3.5.7.9.. so I had to build a custom part in eagle..

So I start off modifying our ARM board by sticking an arduino mega shield in the middle with the idea of wiring it upto all the mosfets etc.

But then I think, wait a second why do that? Lets just leave the IO board and make a shield that plugs into the Juki’s existing IO connectors. So another project in eagle and its even simpler this time.

Yeah that’s slightly less complicated. So  basically we’re just mapping each of the IO’s to the arduino, I’m not much of an arduino person myself I prefer ARM for embedded, but we had lots of parts lying around and it was super simple form factor which is the point of the arduino and we sold out of all our arm based arduinos at defcon. So I ended up using the tx/rx as  an that has to be rerouted later, but luckily I mapped it to the down switch for the teaching panel, which we no longer need. However that’s not how we do things at NSL so it’ll be remade and milled.

Now add the headers, this is a real chore they’re simple to obtain, but so cheap but a bitch to solder onto a board that’s not plated…

Also someone missed some pads..

Whoohoo perfect, (well sort of)

Now for a test fit onto the machines IO board.

Check continuity etc. Make sure that GND is mapped…

Getting ready to fire it up

Plugged into into the ADK arduino

Lets test fire one of the air lines…. Power up the compressor, write a quick bit of arduino code and !

One of the lines we ‘repaired’ pops off and attacks KRS and mmca, But it works ! We haven’t replaced all the airlines yet and they’re hard to get locally it seems. We test the switches here too, things are looking good.

We skipped a little ahead above, the test code required some simple though into it.

First set all the pins to input
Next set the individual output pins to output

Which wasn’t enough to make anything read.. So a quick poke around and some head scratching and the answers simple, we have to make the pins  for input set to HIGH first, so a quick change and off it goes.

All the defaults for out pins are set HIGH too.

So now it’s a case of mapping all the IOs in arduino and writing bits of code.

we decide to decode the ATC (toolchanger) first, it uses a select + 3 lines of BCD. 4 lines are assigned to the ardunio and then we figure out which bit controls which tool changer.

Obviously the smart thing to do is make it do this :-

with more gusto!

this is more fun that the pnp itself

So next the motors themselves , this is just a case of doing a train of pulses __–__–_–_– etc http://www.flickr.com/photos/krs_/6117717455/

We have to determine the length of the pulses, its moving very slowly in the video because we’re at the +ms speed, eventually we move to microseconds.

Adding the limit switches, and this is why i spent $600 on a compressor for airbrushing btw

Now we’ve done a better job of finding a good speed for the motors, so a quick walk test. This is just doing a limit, change direction test.

On the motor front now all we have to do is convert pulses to mm and then we can do a gotoxy() function! Which is pretty much all we need

The X and Y home sensors still aren’t working yet, so while i’m writing this blog and uploading all of our videos to flickr ( since google+ doesn’t seem to have an easy way of embedding videos) I’m working out why the XY home doesn’t work. I’m adjusting the walk function to print out the XHM and YHM sensors after each pulse to see if it only does home when the rotary encoder hit and the home sensor are both on. And we just did a quick test and that indeed is the answer woo!!

So now to write a quick home function, i’ll have the machine do a bottom left limit find,, move back a little bit up to the right and then slowly move back til it finds home..

be right back!!

and now krs is filming me,,, awkard…

Ok so the home function is now working, the machine goes to top right/back quickly, then left,front quickly, steps back to the right 100 pulses, and back 100 pulses so its definitely not at home, then slowly scans left to find x home, then slowly scans hither to find y home.

Next steps are to convert the pulses to actual distances so we can do x,y instead of pulses. I also want to do some repeatability tests, in other words go to home, go to position, go to home, go back to position and see if its always the same place. So lets home it, center it, switch on the spot light mark it, and repeat, or use a sharpie

The spot light had a broken wire in the middle, it’d been poorly repaired once before so we stripped it off and resoldered it.

We used a ruler to calculate the pulses to mm, using 100 and 500 pulses to see the distance travelled in each X and Y ( the same amount )

Seeing how far it goes.

I added the home switch, teach switch as the spot light toggle and the cursor pads to move the head. the down button is mapped to RX on the arduino mega so I cheated and used FAST button, we’ll remill a new board tonight with a different layout

We’re pretty close to getting the full functionality of what we had before with the factory software. Just tool changer positions etc, which is all just finding the spots.

The speed of the machine has been pedestrian so far, so looking at the original specs the pulses are ramped (since physics) and it moves much faster. So next lets try to match that.

Scope/LabView looks like this for the original.

The X and Y’s have different stepper controllers, so it has different max speeds. The idea is now to add ramps to the move functions, i threw together a quick ramp into the limit finder test code, of course this means it has a nasty bump as it stops for the limiter. Once we’ve got a good speed going, the new gotoxy() function will do a /~~~~~\ ramp, slow to fast to slow.

Various speed tests

Goes wrong! We can play a mean mario with this

Yeah! we’ve got a decent speed now. Its hitting the limiter rather than slowing down as it should. The arduino starts off ramping up but since its looking for the limiter it bangs to a  stop, we’re going to calculate the number of pulses needed to get to just before the limits. That way the machine knows how far it can go, even though during most of its working life it’ll never go to the limits.

[Null Space Labs] like most hackerspaces is very srs bizness indeed.

So next I wrote a piece of test code that moves each of the axis slowly, limit to limit for  a few passes the Y result was this :-

Found Y+ limit = 4202
Found Y- limit = 10597
Found Y+ limit = 10597
Found Y+ limit = 0 (oddity!)
Found Y- limit = 10597
Found Y+ limit = 10597
Found Y- limit = 10597
Found Y+ limit = 10597

At faster speeds in the X axis, it deviates but interestingly settles after a few :-

Found x left limit = 7433
Found X right limit = 7447
Found x left limit = 7276
Found X right limit = 7446
Found x left limit = 7266
Found X right limit = 7446
Found x left limit = 7266
Found X right limit = 7446
Found x left limit = 7266
Found X right limit = 7446
Found x left limit = 7266
Found X right limit = 7446
Found x left limit = 7266
Found X right limit = 7446

Running the X at a slower speed gives us this :-

Found X right limit = 7432
Found x left limit = 7432
Found X right limit = 7432
Found x left limit = 7432
Found X right limit = 7432
Found x left limit = 7432
Found X right limit = 7432

Which is great, since as it should be its very consistent.

Our ruler based figurin’ from before gave us the following info :-

500 pulses = 25mm
100 pulses = 5mm

So using that info from above we get

431 pulses X axis (left to right limit to limit) = 370mm
10597 pulses for the Y axis(limit to limit ) = 529.85mm

This is good since it means our speed is workable, and we can now write a function that can start off slow, speed up and slow down, as the machine knows how many pulses it can do before hitting a limit, but we first have to calculate the distance from home to limit for each X and Y axis.  Though most of the time the machine will not be attempting to get to the limit.

The machines minimum step size is .05mm or 1.9mil’s but we are going to improve to .025mm or 0.984251969 mil! Which is 0.000984251969 inches.

So now we have converted it to double the resolution of the original equipment we get

Found x left limit = 14867
Found X right limit = 14864
Found x left limit = 14863
Found X right limit = 14863

Found Y- limit = 21174
Found Y+ limit = 21173
Found Y- limit = 21172
Found Y+ limit = 21172
Found Y- limit = 21172
Found Y+ limit = 21172
Found Y- limit = 21173

It’s now 1000 steps per 25mm or 1 step is 0.025mm!

Awwh yeah!!! Our machine is now able to do smaller parts and greater resolution  than the original!

So far for this post, it is about 11:00PM west coast time and its been a busy few days, we’ve put about 6 nights work into this and progress has been pretty good. We’ve saved ourselves a lot of money, since a machine that’s not got as good specs would cost us nearly 20K. The machines minimum step size was .05mm or 1.9mil’s but we have improved it to .025mm or 0.984251969 mil! Which is 0.000984251969 inches..

To recap

Built arduino shield
Wrote arduino code
All pneumatics working
Repaired reed switch
Fixed all the broken mechanicals in the head.
All input switches working on the panel (except down as it was wired to RX oops)
Limit switches working
Home sensor working, home written
Figured out how to ramp up and down the speeds to get the the machine moving quickly
Automatic Tool Changer all works
Head down, head up
Vacuum on and off
Teach light repaired and working, controllable
Rotation and centering arms working
Reed sensor on head up
Verified our code and board homes the machine to the exact place the original did.
Calculated travel pulse speed and size of board, machine can gotoxy without a problem
Doubled the resolution!

We’ve still got to replace all the hoses as they’re really in bad shape but that’s easy. The next step is software to do the pick and placing, that’s easy too. I’ve already written a gui and added opencv.

This is log of the current work we’re doing at NSL http://032.la

Rather than hand build all the badges for our  socal security conference layerOne again, http://www.layerone.org/ we’ve gone to a pick and place machine.

Gleep found us a Juki(Zevatech) Placemat 360 (that seems to  have been upgraded to a 460 ) pick and place machine. It was sold as ‘working’, the sellers definition was, if I’m completely honest a stretch (outright lie).

This is actually our second pick and place machine, we don’t mention the other one

We’re also interested in acquiring a Zevatech/Juki 460 if you have one for a decent price.

Basically he demo’d everything that didn’t need a compressor, that all worked. Of course everything that needed a compressor as we found out later, didn’t work! Still $1,200 isn’t bad.

I used my supersilent 20a as a temporary compressor, it only has a small  < 1 gallon tank, but its actually quiet, we used the 8 gallon compressor at null space which is deafening, so i found a 3 gallon temporary one at harbour freight for cheap in their recent sale. its too small though, so we’ll need shop air at some point. The supersilent was causing the pickup head to fail to work after a few passes, so this caused as a few false starts, the machine needs a solid air supply to function , even in testing.

The existing filter and pressure regulator was a mess, so off to home depot to come back with the best we could find there, which isn’t that great.

This is the old one, remember sold as working. No filter, and all these bits were just lying around inside it.

The machine itself is based on the PC-8801 Z80 4mhz CP/M which I recognised straight away as my old job had me doing game conversions in Japan for the PC-9801.

Dusty

The whole machine works pretty much on the principal of that if the CNC software said do this, do that, that it executed perfectly. Only limit, head, home and the tool changer have checks.

We fired it up , Krs and Gleep got it picking and placing a few resistors (though they somehow managed to get the tape removal part completely wrong and it was throwing resistors all over the place. Then mmca got it placing QFP parts correctly. The lamp spot system was off, the 90′o rotation was off, the tubes were old and cracking. Compressor filter was non existent and rusted out. We’ve also discovered the whole thing is covered in parts from the previous owners, we’ve scored a few 100 0805s and some IC’s.

Free Parts!

The reed sensor was the first thing we found that was broken, a quick trip to eBay and a few days later we had replacements. Luckily Juki is in heavy use, and they use a lot of off the shelf components. Apparently the later 5xx machines do switch to a proprietary drive system.

The reed switch detects if the head is up or down. Its one of the few sensors in this machine. The bend has caused the wiring to break down internally over the years. so the machine gets confused about being up or down, and the software doesn’t cope well with that, it basically needs a full reset afterwards.

The new sensors , $9 from eBay.

I also bought a CPLD based floppy emulator from Poland, it hasn’t arrived yet and we’ll probably be done with the new system before it gets here, and we’ve discovered the speed stays the same but floppy drives won’t last so the SD is still a good replacement.

Placing QFPS (AT90CAN128)

Fashioned a quick tray for the IC placements. We use these great little boxes, also from eBay, for holding SMD components, they double up as handy platforms too.

Feeders

The feeder is controlled by the head, it moves over the spring loaded pin and pushes it down, this releases air and the notched wheel on the right moves the component reel tape one step, at the same time the protective covering tape is peeled away, allowing the machine to come back and pick the part up. This time, they’re correctly threaded, previously the protective tape was wrapped around the pin in the middle.

Side view of feeders, you can see the reel of components on the left, and the pneumatics underneath. Its important to choose a pick and place with a widely available  range of cheap feeders, all too often people buy a cheap pick and place then find out it has none, and it’ll cost $1000’s to get them, if at all.

Feeder with pneumatic assembly

The expansion board

This is the board inside the machine, it is a couple of 8255s which are the defacto standard for PC parallel IO, almost every PC has had one or more of these, they’ve since moved into the ASIC’s but the principle is the same. It memory maps each of the input/outputs of the machine so that host PC can see them. I pulled off the floppy image, copied the files to my PC and reverse engineered the controller code with IDA.

I found an IMG of the floppy online, this was MFM encoded . So i converted that to a raw binary file, and then used cpmtools to copy the files from it. I was hoping to find some of the saved files so we could reverse the format and write a quick tool to do the placement. Once the files were copied off i tried a few of the different PC-8801 emulators, M88 etc, but had no joy in getting it running. So finally I just pulled apart the CP/M COM files in IDA and see what we could find.

The teaching process is tedious, so reversing the format would have been worthwhile.

Interface board

This board takes the IO from the PC, buffers 74LS240 it and uses power darlingtons FT5723M to switch the 24V signals for the pneumatics.  As well as read the various sensors and the + / – for the motors. The motors and stepper drivers are off the shelf, but very nice, we even have newer versions of the motors and controllers at NSL.I’ve removed the bottom connector to make it easier to take pictures.

The grey cable that has been added later is the automatic tool changer, this is soldered directly in the spare connections , 5V and 24V VDC. The 5V powers the small adapter board in the ATC and the 24V is for the pneumatic switches.

The remaining signals are multiplexed IO that are demuxed by a 74Ls138 on the ATC board, which deviates from the way the rest of the board works as the rest are all controlled by the darlingtons directly.

Each function of the machine is basically <control> – <buffer> — <pc> – <memory map>

So if you want the head to go down, you flip a bit in the PC’s memory. Its all digital IO, nothing fancy at all. The only extra part is the 5V TTL to 24VDC for the pneumatic switches.

Stepper drivers and power supplies.

The stepper drivers are on the bottom, the other one is to the right under the tray. the two power supplies are just visible at the top right, one is a 5V the other a 24V. The power filter is in the lower left.

Power supply

Stepper motor driver

XY gantry

Since the machine was in bad need of service, we stripped it down, here the XY belts are visible. The top side has the the driver motor and the bottom side gets its power from a rod under the bed on the right side, so both belts are moved in unison. The ATC is in the top right and the frame in the middle is what is left of the PCB holder.

Tearing it down.

The head

mmca stripped the head down. here it is removed from the gantry. mainly because there is a piece of string visible , and we can’t figure out what its for.

Shims, we don’t think these are factory shims.

The strange piece of string inside the head… What could it be for?

Bottom view of the tool pickup and the 90’o rotation.

These 4 arms are moved towards the part and clamp it gently, this straightens the part for placement, it can also rotate the part by 90’o ( which sucks for us because i always like to put parts at 45’o)

The laser, focused lamp (this machine continues to surprise us ) which is used to position the head in teaching mode.

We’re removing the lamp and replacing it with machine vision, so some measurements are taken.

The hoses are removed and marked with a letter , the corresponding connector is also marked with the same letter.

This is how the previous owners repaired the 90’o rotation arms….. so that explains the string. this was removed and repaired correctly. The 90’o does just that, it rotates a part by 90’o that’s all this machine can do, so we’re going to change that to it can do arbitrary rotations.

This hose had cracked, a few others did too. I found a few temporary replacements at the auto parts store 4mm ID, 8mm OD  fuel priming line.  The plan is to replace all the hose.

Stripped machine screw in the head. Replace from grainger, M3x8mm 0.4mm thread 5.5mm head size.

And some missing set screws

Spent some time measuring all the screws and what not. The machine is old enough that it came from proper manuals with circuit diagrams.

We’re replacing the IO board, the plan is to throw in a TI Stellaris ARM lm3s9b96 chip instead, (TI were good enough to send us a bunch a while ago, thanks TI!)

This board is a dumb board, it just marshals the I/O and does the switching of the 24VDC with darlington’s.

Here we’re removing and verifying the connector sizes and function  (the manual had some errors) so its good to do that. It also gives us good insight into what’s going on.

Checking how the machine works with my trusty fluke.

I threw together the connector layout in eagle and printed it out to verify it,  early revision.

Measure the hole size and distance. Our board is exactly the same size so its a drop in replacement, we’ll just lose the two larger connectors and change it to USB.

Here we were figuring out how the ATC worked, at first it was though to drive it directly , but there weren’t enough wires. So its 24V, 5V and control signals, the small interface board at the front is a  74LS138 decoder/demultiplexer with a few buffers and more darlington drivers , it switches the 24V on and off based on the 4 control signals coming in.

Automatic Tool Changer

The tool wanted is lifted up when the machine wants to change it, on the right are the pneumatic switches that are controlled by a 24V signal.

We’re using Power MOSFETs to control the 24V instead, a 6 pin ROHM US6K1DKR in a TUMT6 package ( time to create a new device in eagle again !) I ordered 100 from Digikey yesterday and should have the board layout finished today. Then we can mill out a test PCB and see how it works. (parts arrived a few minutes ago!)

You might be amazed, I was , about just how simple this machine is, you could run the whole thing from a set of on/off switches, albeit very slowly. But that is great for us though as it makes it very easy to replace the PC software.

The next big thing is going to be testing the new power MOSFET and building the new PCB.  The chips will be here today have arrived.

So new eagle package

Cut out a few to test.

Apparently I goofed on the measurements, I did change it around a tad after the first revision. Teeny part.

Soldered it anyway

So the next step is adding cameras etc.

mmca explaining the new part to be cnc’d out for the camera

mockup of the mount

The head has to be recalibrated so the bottom of the tool is 62.5mm from the table, with a .1mm accuracy, so we as usual went overboard and used grade B gauge blocks.

69.5mm to .00005 inches accurate.

Gauge blocks are fascinating, they stick together like magnets if you put them together by making surer there is no air between them, but if you just stick them together they won’t. Super flat. these aren’t grade a or better, but they’re nice. mmca has the coolest stuff.

Starting to rebuild it

Machine vision tests

This is work in progress, testing RoboRealm/OpenCV and teaching it components, it works well!

Using a panda board a HP HD Webcam for testing the vision.

Software

Playing around with layouts for a quick test tool. two grey areas are for the cameras.

Well that is it so far, my Motorola Atrix decided that the fingerprint reader would become burning hot to the touch. So I pulled it apart and removed it, but somehow managed to make it do a full hard reset (or a docwho76 as we call it ) and it deleted a bunch of my pictures. google+ had failed to sync them. But we’ll keep documenting the project,

Yesterday I was rewriting code for Null Space Labs ‘Cylon III’, a blinky toy thing we make and use for people to have soldering practice, it spawned from the EMSL Cylon and then through a few iterations from a simple 9 LED thing to a charlieplexed circle.

Cylon I

Cylon II (with an IR LED to mimic a tv-b-gone)

Cylon III

We use the ATTiny2313 which a lot of people complain has no legs ( the MU package ), I think its great but it can be  a challenge especially with the milled versions of the PCB to fix and replace the chip.

Anyway I was playing around with different clock speeds in AVR Studio with the Atmel Dragon. The dragon is a terrible piece of hardware when it doesn’t work right, which is  often. It has a design flaw that causes a couple of chips to blow up regularly, so regularly in fact we keep a stock of the chips at Null Space Labs. My dragon has been repaired three times so far.

Then there is the software itself, the way it interacts with the USB has it disconnect and reconnecting after using the AVR Studio programming interface, sometimes it’ll hang and you’ll hear the USB connect/disconnect cycle until you unplug it ( which increases the chance of the chip blowing up issue  ) and exit AVR Studio 4, which is really annoying especially during debugging.

So I select the <4Mhz option and AVR Studio warns me that I won’t be able to program the chip if i set it this low, I say no and put it back on the internal 4Mhz. However I fail to take into account that CKDIV8 is set ( clock divide by  8). At this speed the Dragon is having problems reading and flashing the chip, even at 51khz which is the lowest speed. It’ll read the chip id once, or read fuses once, then require me to exit the programming software, and reload it.

So i think, ok reset the fuses since it’ll let me do one operation. But in AVR Studio you have to read the fuses then set them, you can’t set them by hand then program, this uses my one attempt before the Dragon fails to communicate.  It reads the fuses, but then fails to set them.. I try every variant, unplug the dragon, nope, this fails since it looses the USB setup or whatever AVR studio is doing, reset the target board, disconnect the target board. Nope, the only thing that works is exit the programming interface in AVR studio, let it reset the Dragon and back in again, at which point it reads the fuses again and then I can’t do anything with it, since it no longer communicates with the chip.

Anyway at this point I’m thinking its time just to replace the chip, but then I remember about our AVR programmer which is a smaller , simplified version of the USBAsp, we call it the Kraken.

Prototype

Final version

We only use the ICSP mode and have our own SIL 6 pin programming header. The pogo pin version is much nicer than my hack.

Prototype version.

Krs pulls one out of the back and builds it in less than 20 minutes, it’s programmed and ready to go. I  setup AVRDUDE and read the chip id, that works, read it again, still works.. So i try just to set the LFUSE so that the clock is set back to 8Mhz, and bingo it works straight away.

USBASP/Kraken 1, Atmel AVR Dragon 0

Atmel sells the Dragon for $49 http://store.atmel.com/PartDetail.aspx?q=p:10500053 it comes with no case (which doesn’t help the chip destroying problem either ). I personally think they should rev it, or sell it with a box,or at least a warning. Using it with a USB Hub will help alleviate the chip killing problem.

Here is the web page that lead us to keeping a stock of chips, we’ve fixed about 6 of them in the last few months, so far its always the same issue. http://www.aplomb.nl/TechStuff/Dragon/Dragon.html

But why it can’t flash the ATTiny2313 when the USBAsp/Kraken can just seems like a software problem. Now if only we had access to DebugWire I could do without the Dragon altogether.

Still after you’ve seen a few of them with holes burnt through the chip and sometimes even into the PCB, you’ll know why Atmel calls it the Dragon. It’s funny how the people who make the chips can’t get their programmer to work well, when one guy in germany can.

I’d like to say no Dragons were harmed during this process, but one of our members ( who coincidentally named the Kraken project) blew his up while I was working on this problem ).

Since this blog was written around 8/22.. We’ve blown up another three dragons..

Links

http://www.fischl.de/usbasp/ USBAsp home page
http://wiki.032.la/nsl/AVR_Programmer Null Space Labs Version of the USBAsp
http://www.aplomb.nl/TechStuff/Dragon/Dragon.html How to fix the Dragon (and add some improvements)

A couple of weeks ago we decided to redo the Android ADK board from Google and the Circuits@Home/Seeedstudio Arduino board, improving on some aspects of the design but mainly getting it ready for Defcon 19. After doing some rework in Eagle and CNC’ing the boards at Null Space Labs, we sent them off for manufacturing at Silver Circuits ( Who’re also doing a tutorial based on one of the techniques we used for the board, so that’s cool ).

Oddly a project I’d been working/reworking in my last blog post was also from Circuits@Home, I had no idea til today that Oleg had been the originator of this project, he’s getting apparently not getting much love for it. http://www.circuitsathome.com/ I have a couple of his USB Isolators too.

On the Demo board we added IR Send and Receive so we can make them into TV B Gone’s, changed out the RGB LED’s for better ones than Google used, made some of the parts bigger to make them easier to build, added the double header row 2×18 for the mega,  and changed the logo for a ninja/pirate droid.

We also gold plated the demo board, which turned out pretty nice!

The Arduino board stayed mostly the same, just moving things around though after our first build we’re going to change a few small things that we’ve noticed are problematic in the process.

A simple pan and tilt was built in Eagle to test the servos, milled out a few interlocking parts and attached a couple of servos.

The Google API uses their USB class software, but it only works on 2.3.4 onwards, and to be honest it doesn’t work on a lot of the 2.3.4 devices either, I couldn’t get my Atrix or Iconia A500 which is 3.1 ( even after I rewrote the code to use the new 3.1 API’s ) So today we took the baseline Seeedstudio APK test and extended it to work with the demo board, I ported all the functions, i2c joystick, RGB Leds and so on to work with MicroBridge instead.

Most of the time was actually setting up eclipse and the ADK , there are some issues with the version I downloaded of the Google API 10 which wouldn’t let me compile the DemoBoard APK, it turned out that Rev-2 Was named 10-1 and the SDK was using 10 so the usb.jar was missing, renaming it worked. Eclipse is probably the worst IDE I’ve ever used, though its neck and neck with xTunes 4.

Using the I2C joystick to control the pan/tilt, the temperature and light sensor is on the android tablet, and it also controls the relays from the phone.

Testing different devices, being a hacker space we have a lot of android phones, not so much of the fruity ones. Here it’s a Samsung Galaxy S2 and an Acer Iconia A500.

The Board running from a cheap Coby android 2.1 tablet thing from Frys Electronics, it was about $150 USD.

Doing some things with the Coby, actually about the only thing, it doesn’t even play Angry Birds properly.

KRS Splitting up resistors to kit for our mini production line.

Arko is our manual pick and place, ours doesn’t get here for 6 weeks, so we did what most starting civilisations did and relied on ‘free’ labour as its called these days.

Totally awesome NSL tShirt created by [NSL] top bloke and hacker, frank^2.

Yes even child labour, tsk tsk those evil hacker types, get back to work.

Part of the assembly line, even the food table isn’t sacred.

Final assemble stage, CPU’s and chips are installed here

Modified Arduino boards with a few of the jellybeans installed

CNC’d version of the top demo board.

Stack of boards we did in the last couple of days…. The pick and place can’t arrive soon enough!!!

Some of the microscopes we didn’t use. These are on their way to the Defcon 19 HHV which we’re lending a hand in.

The demo board running a pan/tilt servo setup.

Walk thru of the solder paste application process. (sorry a bit quiet on the audio). I said 5mil for the brass sheet, the original one we tried was 5mil but was too thick, so it’s actually a 3mil sheet, we get them from ace hardware.

Going from the solder paste to component layout, (Sorry low audio quality).

mmca soldering in the headers.

Hot Plating.

Quick pan of Null Space labs, tis a mess.

CNC room, low quality, short.

All the code and changes are available on our wiki , and we’ll have a box of the boards at Defcon too.

Some of the other things we did this last couple of weeks.

Our remix of the RFID Arduino shield (PN532), made this into a mega shield, it’s the microbuilder.eu board.

As well as our usual blinky toys.

Cylon I

Cylon II

Our Logic analyser that fits in an egg

Getting the hot plates machined so we can bring them to defcon, ebay FTW.

Thermal epoxy

Before

After

See you at Defcon 19 !!

I found a USB isolator from circuits@home, had BatchPCB make a few of the PCB’s ( Not recommended as they are too expensive and their customer support is non existent, try Silver Circuits instead )

After krs built and I tested the USB Isolator it seemed to work pretty well, so the next step is to adapt it for an NSL project. In this case I went back to the chip itself and decided to start from scratch. We’re using the Analog Devices ADuM4160 USB Isolator.

Step 1 – Find Chip, datasheet and Design

Find the datasheet, and another other points the OEM has, Analog are generally really good at this.

http://www.analog.com/static/imported-files/data_sheets/ADuM4160.pdf

Easy enough , a neat chip and its used in the Circuits@home, we looked at the http://www.analog.com/en/interface/digital-isolators/adum3160/products/product.html but its 4-5V and only does 2.5KV of protection.

Even better a whole article discussing the chip, problems and sample designs, it also has a design for the ADuM5000 Isolated power supply.

http://www.analog.com/library/analogdialogue/archives/43-06/USB_isolator.html

So the above shows an isolated hub design. That would make a good project and its different enough from the Circuits@home to make it worthwhile.

Evaluation

http://www.newark.com/analog-devices/eval-adum4160ebz/usb-digital-isolator-eval-board/dp/10R6464?in_merch=true&MER=ACC_N_L5_SemiconductorsIntegratedCircuits_None

Another neat link is http://wcm-prod-edn.cancom.com/article/465019-Isolating_USB.php?gotourl=http://wcm-prod-edn.cancom.com/article/465019-Isolating_USB.php

Step 2 – Find availability of the chips.

So this is probably one of the most frustrating aspects of design, sourcing the chips. We’ve decided to look for the ADuM4160, the ADuM5000 and the Atmel AT43301 chip… Uh oh  its my nemesis, Atmel… Almost every design I’ve ever done that’s relied on Atmel has either met out of stock for months, or discontinued..  Ok so off to findchips.com to do a quick survey of the land.

Ok good, a spread of stock over different suppliers with a decent quantity for a project of this size. Prices as usual vary widely. Newark often come in the lowest, $9.78 vs $12.23 at digikey and oddly $19.41 at element14. Even odder given Farnell/Newark/element14 are  basically the same place.

Also I notice there is a eval board, so we’ll note this part number and look up the datasheet for that too, it’ll more than likely give us the schematic to work from, as well as layout tips. The chip datasheet covers local layout aspects for the PCB for the chip itself, but the evaluation board gives you it all usually.

Ok the ADum5000 ( which we may not use in the hub since a hub potentially requires more power )

It is in stock, but a low count/spread if I were doing a commercial production run I’d look into it further. Again Newark has beaten Digikey pricing (Newark also ship everything in separate white envelopes inside the bag with markings on the outside vs digikeys plastic baggies )

On to the Atmel….

What a shocker! no stock… no spread.  Ok so time to head over to Atmel, and see what’s up with the chip. Ok –AC version is non ROHS, so it is gone. Its a few years old so its not surprising its been EOL’d

Over to http://www.atmel.com/dyn/quality/quality_prod_obsl_result.asp and lets see if it is on there.

AT43301-AC AT43301 5/20/2008 11/20/2008 No replacement, same for the -au… Well that tales the biscuit, obsoleted, no replacement.  checking eBay turns up no results, and its too difficult to deal with the part finders on Google to source a chip. So we’ll have to start looking for a different chip. So far my Atmel experience is staying true.

Step 3 – Find a replacement chip or design.

I’ve had mostly good luck with TI , I like the Stellaris series they bought, though the chip i used wasn’t in mass production last time i checked. Poking around we get the TUSB2046B its available in LQFP32 too

Data Sheet –: http://focus.ti.com/lit/ds/symlink/tusb2046b.pdf

Newark :- http://www.newark.com/jsp/search/productdetail.jsp?SKU=77C1805&CMP=AFC-SF-T11

3.3V, which isn’t uncommon. Hugely available pretty much everywhere, ( 56,779 in stock for one sku ) slightly more complex to implement.

Someone from redbull just dropped off a hacker thing at our space [ NSL ] in dtla. I put it together, just a couple of RCA’s, 3.5mm speaker and a NES controller port. The board is covered in flux so needs a good cleaning.

It’s a NES controller, composite video/audio on an Atmel644  with some AD devices and a code on it

This is written on it U2V0ZWMgQXN0cm9ub215 / Setec Astronomy / Sneakers / Too Many Secrets(frank^2)

Chip is USB drive host, so plugging it in gives some files. Encrypted zip file and a bunch of MAC OSX resource forks, no shock there. There is a google gmail attachment url in the resource fork, but not much you can do with it probably

I pulled off the hex file etc,

Pictures http://www.flickr.com/photos/51925658@N08/5552112502/

Firmware, files from the usb drive etc.

its basically this http://belogic.com/uzebox/

WinstonChurchill –cnelson

OK, that was an easy one… but you’re not there just yet.

The riddle that ol’ Winston mentioned was Russia, but we’re talking about a different kind of puzzle altogether.

Somewhere in this box there is another password, this time for a website.

Poke, probe, and hack away at this circuit board… it’s an egg hunt.

When you find the url and the password… go tell us what else you’ve found along the way.

Good luck for real this time… you’ll need it!

I’d pulled this apart earlier, then realised it was an uzebox and didn’t bother

PEEL THE FOAMSUP, GOLDDIGGA?

CAN HAS RICKROLL?!?!.YOU FOUND SECRET ROOM!.REALLY?  THAT GREEDY, HUH?.OK.  NO MORE SECRET ROOM FOR YOU..SRSLY, NOTHING BETTER TO DO?.IM SORRY DAVE, I CANT DO THAT..BROOKLYN, NY   JULY 2011

…///../…/./..//././././/.././…/..///………./….//…../…../…../…../….///………///../…/…../…//…/…./…../////……..///../…/…../..///……/./…/..///………../….//…/./../../../////…./…../……../////./…../.

com.apple.quarantine……..T..%com.apple.metadata:kMDItemWhereFroms.0000;4d805291;Google\x20Chrome;855C7932-787D-45D1-BB3A-2AF1755A1540|com.google.Chromebplist00…_..

https://mail.google.com/mail" href="https://mail-attachment.googleusercontent.com/attachment?ui=2&ik=b914eefc8a&view=att&th=12ebd020e6396ab5&attid=0.1&disp=safe&zw&saduie=AG9B_P8Ttmz5UtLculmISrea7jWc&sadet=1300255397085&sads=hB_L1EgkB6A4_VqifTCQM0HhnDc&sadssc=1_.<https://mail.google.com/mail">https://mail-attachment.googleusercontent.com/attachment?ui=2&ik=b914eefc8a&view=att&th=12ebd020e6396ab5&attid=0.1&disp=safe&zw&saduie=AG9B_P8Ttmz5UtLculmISrea7jWc&sadet=1300255397085&sads=hB_L1EgkB6A4_VqifTCQM0HhnDc&sadssc=1_.<https://mail.google.com/mail

orly?

flip it

Uhh yeah sure it is.

Some overly masculine logo. I feel the need to drink energy drinks now

.

Thanks for the pacman game redbull…

hackers…..not makers….

Thusday, We decided to make a Evil Mad Science Lab’s Larson Scanner, but make it out of all surface mount and try to make it single sided PCB.

Using Camtasia  I recorded the screen for each part of the class, at just under 1900×1200, whoops, lessons learnt there, most projectors can’t handle that and it makes massive files. The create a part video was 78GBytes.

So lesson learned, check the native resolution of the projector and go from there! Most people probably don’t run 1900×1200 screens either.

I grabbed the PDF schematic from EVMSL, then drew it into the Eagle layout, Windell uses gEDA for his schematic.

The original schematic. Click for a bigger version.

The layout

So its always been difficult for me to source Atmel chips, I’m cursed. Digikey had the MLF package ATtiny2313, which is tiny and basically leadless. Since this is [NSL] that is how we do things.

Next step was to order up enough to make 50 boards, 75 CPUs, 50 switches, 5000 resistors, 5000 capacitors and 500 LEDs. Total cost came into to around $200, not bad for that many boards and we’ve now got some spare components for the next project.

A nice switch was found, and as a bonus it had no Eagle footprint I could find, so this was the perfect part to use for the ‘Make a Part’ video. Another lesson was about to be learnt, don’t concentrate too much on the video or what to say, and pay attention to the part you’re making, more on that later.

Friday, I laid out the board, managed to get it all single sided, and cut the board. Found a new feature of my PCB CNC , Black lines means that the distance is too small to cut, and they don’t cut even in force mode, so the first three boards had missing pads… Oh well it was enough to verify the design and the parts hadn’t arrived yet.

Without the GND polygon processed. you can see the trickiness employed to route the ICSP. But the VCC is missing, which I’d never have gotten in this way without a jumper

Saturday, the parts arrive from Digikey. I re-laid out the board, had a chat with Chris over at AccurateCNC who’s knowledge about his product and PCB making never fails to amaze me, we chat a bit about the errors of the pads, its interesting that in Eagle if you make a part and it looks the same, the slight math errors that creep can make the difference between an 8mil and a 6mil gap. You’d never see it in eagle without looking at the actual numbers. I’ve seen this a few times on different parts. One pad of an SMD 0603 resistor CNC’d the other didn’t. This is probably due in some part to floating point numbers.

The bad boards, notice the missing pad on the LED on the right, the 0603 resistor to the right of that and one of the ICSP is missing the isolation, which turns out to be the VCC(3V) too.

I make the first board, and the MLF package turns out to be really easy to reflow, i basically tinned each of the traces and pad in the middle, placed the part and hot plated it, no problem, except when i test the CPU no go.. Ok add the 3V to the ICSP that i forgot, still no good. And yep the chips in 90o off…. Pull the chip and place another one, this one also drops in easily its almost as if the parts want to sit in the right place, it wasn’t hard to align it at all.

After fiddling about with the AVR dragon a bit, setting the speed in ICSP mode I flash the chip with Wendell’s HEX file, flashes and verified !

Next is the addition of the resistors and LEDs, I dab a drop of leaded solder paste on each pad and add the components with tweezers, throw it on the hotplate and everything’s tickety boo. Add 3V and all the LED’s start their dance.

MMCA says hey try the switch, no go… hmm what up i think, bad joint. Investigate and that’s odd, the schematic said the switch part was lengthways right, nope, its the short side… and the PCB is cut in such a way that all three pads need to be modified. I use an exacto knife to cut the trace , then cut away at the ground plane to isolate all but one of the existing grounded switch pads. This is bringing me back to before I’d rotated the part design by 90o and so the schematic didn’t match the pads. Easily fixed but a pain. Of course I recorded the video and I’m watching myself create a schematic with an obvious short , but wasn’t paying attention to the diagram..

After much late night not enough coffee stuff, its all together and patched. Here is it with a 3V CR2032 cell as comparison.

The red wire is the patch to add 3V to the CPU.. which wasn’t routed in the original design… whoops. you can see the cutting of the copper around the switch to make it work too..

By Saturday morning i have the first pass done, the PCB cut and a working prototype, the changes are back into the board.

Sunday, I’m watching the video and thinking, have to redo the video in a lower resolution and write up a blog post about it, before i forgot half of what i did.  I’ve re-laid out the schematic, made it smaller, its now square, removed the second header, moved Opt1 and opt2 to opposite sides to allow chaining, added the 3V. Changed the ICSP 6 pin from 3×2 to 6×1 and also changed the order, since it was difficult to reroute the board single without  messy traces and 6mil widths. BatchPCB couldn’t cut the PCB as it was.

Here’s a video of it in ‘action’

And the switch works.

Hopefully on the 29th, a lot of people will have made theirs and add them to pumpkins all over.

Now to finish up work stuff and then cut the hopefully final PCB,  test a couple and then cut 50 PCB’s, i hope my new V90 bits last..

No thermals, and i rushed the rubout cut, so didn’t set the depth , but its fine. Only one warning this time and sure enough it had an issue at that corner but right side of the cpu, so i just have to move that trace ever so slightly, I’ll put the polygon thermals back on , as i think it’ll make it hard for people to solder. about 28mm square now. Shame i rushed the rubout as the cut itself was perfect.

After it’s made.

Programming with the non standard connector and pogo pins

Size compare with the previous revision

Hackerspacing up the battery, superglued onto the FR4, loop a wire around the outside of the battery, then another wire under duct tape. Soldering to coin cells is bad, i didn’t do that other one.