All posts by kauz

RFD22301 (RFduino) breakout

I’ve been doing some projects with the RFD22301, also known as RFduino and therefore decided to make a breakout for it. It’s also the radio used on the OpenBCI v3 system for data transfer, communication and programming. This breakout board can also be used as an OpenBCI dongle and can be plugged directly on this CP2102-based USB to TTL UART converter. Of course any other converter will do as long as it has 3.3V logic level. Watch out for that!




RfduinoBreakout




RFduinoBreakout




The jumper sets the DTR pin of the USB to serial converter to either the reset of the RFduino or its GPIO6. If it’s on “reset”, the RFduino itself is programmed during code upload. On the other position it starts programming the microcontroller on the OpenBCI board, assuming the OpenBCI firmware is flashed on the RFduinos of both the “Host” and the “Device” side.




Eagle files:
RFduinoBreakout

Arduino Pro Mini – nRF24l01+ 1.27mm adapter

The Atmega328P and nRF24l01+ combo is also a quite common thing to use over and over again in wireless sensor nodes, remote controls and so on.
I’ve chosen to make an adapter for the Arduino Pro Mini (the 3.3V version) to be able to piggyback small SMD versions of the nRF24l01+ with 1.27mm pad pitch on it. This way you have a tiny board sandwich which is not much bigger than the Pro Mini without the need of wiring everything up over and over again.

nRF24l01+ProMiniAdapter

NRF24l01_promini_adapter

A quite uncommon soldering technique is required to connect the adapter and the pro mini: align the holes of the pads of the Pro Mini and the adapter and after heating up the top pad, let the solder reflow to the bottom pad through the top pad. Of course you can solder headers as well. There is room on the board for a 0805 capacitor (0.1µF-10µF are sometimes used to prevent power issues while transmitting). The VCC and GND as well as the optional IRQ pins of the radio are broken out on solder pads and have to be wired manually, since I didn’t want to make the adapter too big and still leave some flexibility.

Eagle files:
NRF24proMini

Attiny85 SMD breakout

I’m using the Attiny85 quite a lot, especially since it’s programmable via the Arduino IDE. I like programming the AVR chips over an ISP programmer (USBtinyISP or USBASP). That way there’s no need for messing around with bootloaders.




After building a pogo pin adapter for the standard Atmel 6-pin ICSP header I needed a handy and tiny breakout board for some chips because I was tired of building the same circuit again and again and so this project was born. It contains all the essentials to be able to handle the Attiny85 in a SOIC-8 package conveniantly, such as reset pullup resistor, decoupling capacitors and an LED on PB0 (PWM pin). It’s tiny and can be left in small projects or used on a breadboard.




Attiny85breakout




attiny85breakout




The eagle files can be found here:
Attiny85breakout

MKL05Z32VFM4 Breakout Board

Having a reflow oven is a fantastic thing! Out of a sudden you can solder annoying IC packages with ease. I’ve been looking for a small and cheap ARM board with a 12bit ADC and low power options and came across the FRDM-KL05Z within the mbed envionment. This board only costs 11€ and besides the actual microcontroller (MKL05Z32VFM4) it has a MK20-based OpenSDA Interface which can do SWD and USB->UART on board which is a versatile tool for other microcontroller projects, in particular programming those cheap KL05Z chips. The mbed library has some example projects to demonstrate some things you can do with the chip, namely using different timers, the I2C accelerometer, PWM, interrupts and (very interesting) the built-in capacitive touch interface, which can also implement a slider. In conclusion, it’s a very interesting 32bit 48Mhz replacement for the Atmega328P which is used very often in small projects.




I’ve designed a board in eagle 7 (KL05Z design files) and ordered 3 samples from freescale. The board I had fabricated by OSH Park. The QFN32 (0.5mm pitch) reflowed really well with lead-free solder paste. Apply a thin string across each row of tiny pads, it doesn’t matter that the pads are “bridged”. The solder stop layer of the board and surface tension and flux of the paste resolve that for you. If you have bridges between the pads after reflowing, just apply a droplet of flux and touch them with the soldering iron tip. This corrects solder bridges easily without the use of solder wick! Yes, tiny pitch sizes have their advantages as well.




KL05Z breakout reflowed




KL05Z breakout




There are few other components on the board. 2 solder jumpers/0ohm resistors (the 0402 parts), 2x 1µF, 2x 100n (both 0603), 2x 10µF 0805, a 1k 0603 resistor, an 0603/0805 led at pin 11 (LED_RED in the mbed compiler), a voltage regulator and a watch crystal. Actually I didn’t quite feel the need of installing a reset button. You can hate me now for that………:-P But as there was plenty of room on the board, I built in a common AMS1117 3V3 regulator. Other voltages down to 1.8V can be dropped in as well. The footprint for the watch crystal allows a variety of different crystals to be intalled. No 22pf caps were installed in the FRDM board, so I left them out as well. The 10M resistor was included, but the circuit works fine without it. On the TOP side you have labels for pin numbers of the chips with their most common function within the mbed environment, while on the bottom side you find the port names of the pins. I haven’t included a 10-pin swd connector since the interface, besides power and ground, only consists of 3 pins (SWD_CLK, SWD_DIO and RST_TGTMCU) which you can connect with jumper wire just as easily. The wires for the three signals were soldered to J1 directly.




KL05Z breakout programming




Programming can be done with a hacked FRDM board via mbed compiler. I’m saying hacked because there is a bug on the board that has to be fixed by cutting a trace in order to be able to program an off-board chip. By cutting a trace I don’t mean cutting the trace below the J6 jumper as the manual states. This jumper is completely useless! It’s supposed to disconnent the onboard target KL05Z from the SWD_CLK but it does not!! Just leave it in place and cut the trace right next to the MCU, running from pin 30 of the KL05Z to the next via (see the orange circle in the pic below):




FRDM-KL05Z hack




Be very careful not to cut other traces. In case you’ll want to use the on board chip again, the solder mask on the trace will have to be exposed carefully an a tiny jumper will have to be inserted in some way. However at the moment I’m fine with my breakout boards.




Finally, a link to all relevant ducuments for the FRDM-KL05Z: FRDM-KL05Z freescale documentation page with schematics etc.




Update: improved and debugged version with a better voltage regulator:


KL05Z1.1


DIY SMD Vacuum Tool

Especially when you are dealing with 0603 and smaller components and solder paste, even fine tweezers can become annoying because of their magnetic properties. I’ve looked at professional suction pick and place tools and noticed that the main parts they consist of can be found in my medical parts tray. A friend has kindly donated me a tiny “single-use” 3V vacuum pump which is used in wound treatment and I’ve decided to use this thing in this project. Fortunately you can buy them on ebay.




Other parts you’ll need is a drip infusion set, a pen or small 6mm pipe and syringe needles with a diameter of your choice. The green and yellow ones work fine for 0603 and smaller. Also you’ll need 2 AA batteries or one 18650 cell with the appropriate holder and a momentary switch to power the pump. The assembly is fairly easy.




smt suction pen

electric suction pen




The needles are shortened with a dremel, bent to shape and filed flat at the tip with a fine diamond file. You can easily change tips for different component sizes. The device is meant for double-handed operation, since you could be too inprecise on your pick and place hand if you had a switch directly on the pen. So you have the enclosure in the other hand and the pick and place madness can begin. Because the tip is far from air tight the part falls off immediately after you release the trigger. Oftentimes the adhesion to the solder paste on the PCB is even stronger than the suction.




smt components, vacuum pen and lead-free paste




I like attaching the component belts to the bill of materials that I’ve printed out so everything is in perfect order and every step of the process is clear and quick. Errors can be avoided that way.

DIY Reflow Oven

Nowadays anyone can order cheap professionally manufactured PCBs from one’s own designs, as well as Kapton stencils from OSH Park (https://www.oshstencils.com/). This inspired me to take my electronics skills to the next level by building a temperature-controlled reflow oven out of a small toaster oven after I’ve been into 3D printing for quite a while. I’ve been gathering parts slowly for some time and one day a 40A solid state relay (which is overkill for this particular project), a K type thermocouple with MAX6675 amplifier (which has been discontinued to be replaced with the MAX31855) and some standard components have united to form this lovely tool.




I’ve constructed my oven controller to be compatible with the Reflow Oven Controller Shield project by Rocketscream, since the algorithm is well-tested and versatile. A minimal Arduino configuration on a perfboard was built to fit into the PCB slots of a strapubox enclosure. A standard 16×2 LCD and a button form the user interface. The SSR has got a heatsink but doesn’t even get warm with the small oven which draws <2 Amps. The electronics is powered by a samsung phone charger which has been fitted into the small black enclosure for perfect insulation. It's a small switching power supply capable of delivering 5V @ 750mA. The red parts on the input/output power cable are self-designed and 3D printed strain reliefs for the thick cable




reflow oven controller arduino powered




The oven is the smallest and cheapest toaster oven I could find. It has got a top and a bottom 350W heating element (the ceramic white ones that are supposed to be better for reflow purposes) and cost about 19€ in Berlet.




relow oven model




The heating elements are covered with slotted sheet metal, which should avoid direct exposure of the foods/PCBs to the infrared/heat radiation I suppose. I’ve removed all the “guts” from the original oven and wired the two elements in parallel. The mains cable has been left in place. A hole for the thermocouple has been drilled on the side of the inside wall.




Reflow oven 2




First dry-run tests with the included baking tray resulted in the following temperature profile:




reflow oven temp profile




The software transmits the temperature value measured by the thermocouple via serial, which it does every second. I simply inserted a bluetooth module into the FTDI header, saved the values in a terminal program on a paired PC and plotted them with MATLAB. Attempts without baking tray resulted in quicker responses in measured temperature due to the lower thermal mass.




reflow oven temp profile without tray




I decided to solder my boards without tray to have more control over the temperature on the board, since the oven doesn’t have a convection fan. To have as little thermal mass under the board as possible I installed two heat-resistant insulation sleeves. The end of the thermocouple can be lowered to touch the PCB directly by moving its wire outsie of the oven. This gives you better measurements of the temperature that the parts and the board surface are exposed to. I removed the metal shell on the end of the thermocouple to further reduce its thermal mass.




reflow oven PCB thermal insulators




This is the setup that works best so far. The project is a full success. I’m very pleased with the rocketscream algorithm, my controller and the tiny oven. First results with lead-free solderpaste were close to perfect.

Plot Clock w/ DS1307 RTC






plot clock w/ RTC




plot clock




I’ve printed the parts for a Plot Clock in PLA and assembled it in a pretty much standard configuration, which worked great. Quite a bit of filing and sanding was necessary, but it was worth it, the final device was quite easy to calibrate. The only thing I found was missing is time keeping capability, so I added a DS1307 I2C real time clock module, which is a straightforward procedure. Learn how to set up the RTC HERE.
Before you run the sketch that sets the time on the RTC, make sure to remove the battery once to reset the DS1307. Put the battery back in and run the sketch. My modification on the Plot Clock code simply fetches the time once every time you power the arduino up. Further timekeeping is done by the ATmega.



// Plotclock
// cc - by Johannes Heberlein 2014
// v 1.01
// thingiverse.com/joo   wiki.fablab-nuernberg.de

// units: mm; microseconds; radians
// origin: bottom left of drawing surface

// time library see http://playground.arduino.cc/Code/time 

// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
     
    #include <Wire.h>
    #include "RTClib.h"
     
    RTC_DS1307 RTC;
    
// delete or mark the next line as comment when done with calibration  
//#define CALIBRATION

// When in calibration mode, adjust the following factor until the servos move exactly 90 degrees
#define SERVOFAKTOR 555

// Zero-position of left and right servo
// When in calibration mode, adjust the NULL-values so that the servo arms are at all times parallel
// either to the X or Y axis
#define SERVOLEFTNULL 2075
#define SERVORIGHTNULL 1065

#define SERVOPINLIFT  2
#define SERVOPINLEFT  3
#define SERVOPINRIGHT 4

// lift positions of lifting servo
#define LIFT0 1350 // on drawing surface
#define LIFT1 1180// between numbers
#define LIFT2 850  // going towards sweeper

// speed of liftimg arm, higher is slower
#define LIFTSPEED 1500

// length of arms
#define L1 35
#define L2 55.1
#define L3 13.2


// origin points of left and right servo 
#define O1X 22
#define O1Y -25
#define O2X 47
#define O2Y -25



#include <Time.h> // see http://playground.arduino.cc/Code/time 
#include <Servo.h>

int servoLift = 1500;

Servo servo1;  // 
Servo servo2;  // 
Servo servo3;  // 

volatile double lastX = 75;
volatile double lastY = 47.5;

int last_min = 0;

void setup() 
{ 
  
  Wire.begin();
  RTC.begin();
  DateTime now = RTC.now();
  // Set current time only the first to values, hh,mm are needed
  int rhour = now.hour();
  int rminute = now.minute();
  setTime(rhour,rminute,0,0,0,0);

  drawTo(75.2, 47);
  lift(0);
  servo1.attach(SERVOPINLIFT);  //  lifting servo
  servo2.attach(SERVOPINLEFT);  //  left servo
  servo3.attach(SERVOPINRIGHT);  //  right servo
  
  delay(1000);
  

} 

void loop() 
{ 

#ifdef CALIBRATION

  // Servohorns will have 90° between movements, parallel to x and y axis
  drawTo(-3, 29.2);
  delay(500);
  drawTo(74.1, 28);
  delay(500);

#else 
  //DateTime now = RTC.now();
  
  int i = 0;
  if (last_min != minute()) {

    if (!servo1.attached()) servo1.attach(SERVOPINLIFT);
    if (!servo2.attached()) servo2.attach(SERVOPINLEFT);
    if (!servo3.attached()) servo3.attach(SERVOPINRIGHT);

    lift(0);
    
    hour();
    
    
    while ((i+1)*10 <= hour())
    {
      i++;
    }

    number(3, 3, 111, 1);
    number(5, 25, i, 0.9);
    number(19, 25, (hour()-i*10), 0.9);
    number(28, 25, 11, 0.9);

    i=0;
    while ((i+1)*10 <= minute())
    {
      i++;
    }
    number(34, 25, i, 0.9);
    number(48, 25, (minute()-i*10), 0.9);
    lift(2);
    drawTo(74.2, 47.5);
    lift(1);
    last_min = minute();

    servo1.detach();
    servo2.detach();
    servo3.detach();
  }

#endif

} 

// Writing numeral with bx by being the bottom left originpoint. Scale 1 equals a 20 mm high font.
// The structure follows this principle: move to first startpoint of the numeral, lift down, draw numeral, lift up
void number(float bx, float by, int num, float scale) {

  switch (num) {

  case 0:
    drawTo(bx + 12 * scale, by + 6 * scale);
    lift(0);
    bogenGZS(bx + 7 * scale, by + 10 * scale, 10 * scale, -0.8, 6.7, 0.5);
    lift(1);
    break;
  case 1:

    drawTo(bx + 3 * scale, by + 15 * scale);
    lift(0);
    drawTo(bx + 10 * scale, by + 20 * scale);
    drawTo(bx + 10 * scale, by + 0 * scale);
    lift(1);
    break;
  case 2:
    drawTo(bx + 2 * scale, by + 12 * scale);
    lift(0);
    bogenUZS(bx + 8 * scale, by + 14 * scale, 6 * scale, 3, -0.8, 1);
    drawTo(bx + 1 * scale, by + 0 * scale);
    drawTo(bx + 12 * scale, by + 0 * scale);
    lift(1);
    break;
  case 3:
    drawTo(bx + 2 * scale, by + 17 * scale);
    lift(0);
    bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 3, -2, 1);
    bogenUZS(bx + 5 * scale, by + 5 * scale, 5 * scale, 1.57, -3, 1);
    lift(1);
    break;
  case 4:
    drawTo(bx + 10 * scale, by + 0 * scale);
    lift(0);
    drawTo(bx + 10 * scale, by + 20 * scale);
    drawTo(bx + 2 * scale, by + 6 * scale);
    drawTo(bx + 12 * scale, by + 6 * scale);
    lift(1);
    break;
  case 5:
    drawTo(bx + 2 * scale, by + 5 * scale);
    lift(0);
    bogenGZS(bx + 5 * scale, by + 6 * scale, 6 * scale, -2.5, 2, 1);
    drawTo(bx + 5 * scale, by + 20 * scale);
    drawTo(bx + 12 * scale, by + 20 * scale);
    lift(1);
    break;
  case 6:
    drawTo(bx + 2 * scale, by + 10 * scale);
    lift(0);
    bogenUZS(bx + 7 * scale, by + 6 * scale, 6 * scale, 2, -4.4, 1);
    drawTo(bx + 11 * scale, by + 20 * scale);
    lift(1);
    break;
  case 7:
    drawTo(bx + 2 * scale, by + 20 * scale);
    lift(0);
    drawTo(bx + 12 * scale, by + 20 * scale);
    drawTo(bx + 2 * scale, by + 0);
    lift(1);
    break;
  case 8:
    drawTo(bx + 5 * scale, by + 10 * scale);
    lift(0);
    bogenUZS(bx + 5 * scale, by + 15 * scale, 5 * scale, 4.7, -1.6, 1);
    bogenGZS(bx + 5 * scale, by + 5 * scale, 5 * scale, -4.7, 2, 1);
    lift(1);
    break;

  case 9:
    drawTo(bx + 9 * scale, by + 11 * scale);
    lift(0);
    bogenUZS(bx + 7 * scale, by + 15 * scale, 5 * scale, 4, -0.5, 1);
    drawTo(bx + 5 * scale, by + 0);
    lift(1);
    break;

  case 111:

    lift(0);
    drawTo(70, 46);
    drawTo(65, 43);

    drawTo(65, 49);
    drawTo(5, 49);
    drawTo(5, 45);
    drawTo(65, 45);
    drawTo(65, 40);

    drawTo(5, 40);
    drawTo(5, 35);
    drawTo(65, 35);
    drawTo(65, 30);

    drawTo(5, 30);
    drawTo(5, 25);
    drawTo(65, 25);
    drawTo(65, 20);

    drawTo(5, 20);
    drawTo(60, 44);

    drawTo(75.2, 47);
    lift(2);

    break;

  case 11:
    drawTo(bx + 5 * scale, by + 15 * scale);
    lift(0);
    bogenGZS(bx + 5 * scale, by + 15 * scale, 0.1 * scale, 1, -1, 1);
    lift(1);
    drawTo(bx + 5 * scale, by + 5 * scale);
    lift(0);
    bogenGZS(bx + 5 * scale, by + 5 * scale, 0.1 * scale, 1, -1, 1);
    lift(1);
    break;

  }
}



void lift(char lift) {
  switch (lift) {
    // room to optimize  !

  case 0: //850

      if (servoLift >= LIFT0) {
      while (servoLift >= LIFT0) 
      {
        servoLift--;
        servo1.writeMicroseconds(servoLift);				
        delayMicroseconds(LIFTSPEED);
      }
    } 
    else {
      while (servoLift <= LIFT0) {
        servoLift++;
        servo1.writeMicroseconds(servoLift);
        delayMicroseconds(LIFTSPEED);

      }

    }

    break;

  case 1: //150

    if (servoLift >= LIFT1) {
      while (servoLift >= LIFT1) {
        servoLift--;
        servo1.writeMicroseconds(servoLift);
        delayMicroseconds(LIFTSPEED);

      }
    } 
    else {
      while (servoLift <= LIFT1) {
        servoLift++;
        servo1.writeMicroseconds(servoLift);
        delayMicroseconds(LIFTSPEED);
      }

    }

    break;

  case 2:

    if (servoLift >= LIFT2) {
      while (servoLift >= LIFT2) {
        servoLift--;
        servo1.writeMicroseconds(servoLift);
        delayMicroseconds(LIFTSPEED);
      }
    } 
    else {
      while (servoLift <= LIFT2) {
        servoLift++;
        servo1.writeMicroseconds(servoLift);				
        delayMicroseconds(LIFTSPEED);
      }
    }
    break;
  }
}


void bogenUZS(float bx, float by, float radius, int start, int ende, float sqee) {
  float inkr = -0.05;
  float count = 0;

  do {
    drawTo(sqee * radius * cos(start + count) + bx,
    radius * sin(start + count) + by);
    count += inkr;
  } 
  while ((start + count) > ende);

}

void bogenGZS(float bx, float by, float radius, int start, int ende, float sqee) {
  float inkr = 0.05;
  float count = 0;

  do {
    drawTo(sqee * radius * cos(start + count) + bx,
    radius * sin(start + count) + by);
    count += inkr;
  } 
  while ((start + count) <= ende);
}


void drawTo(double pX, double pY) {
  double dx, dy, c;
  int i;

  // dx dy of new point
  dx = pX - lastX;
  dy = pY - lastY;
  //path lenght in mm, times 4 equals 4 steps per mm
  c = floor(4 * sqrt(dx * dx + dy * dy));

  if (c < 1) c = 1;

  for (i = 0; i <= c; i++) {
    // draw line point by point
    set_XY(lastX + (i * dx / c), lastY + (i * dy / c));

  }

  lastX = pX;
  lastY = pY;
}

double return_angle(double a, double b, double c) {
  // cosine rule for angle between c and a
  return acos((a * a + c * c - b * b) / (2 * a * c));
}

void set_XY(double Tx, double Ty) 
{
  delay(1);
  double dx, dy, c, a1, a2, Hx, Hy;

  // calculate triangle between pen, servoLeft and arm joint
  // cartesian dx/dy
  dx = Tx - O1X;
  dy = Ty - O1Y;

  // polar lemgth (c) and angle (a1)
  c = sqrt(dx * dx + dy * dy); // 
  a1 = atan2(dy, dx); //
  a2 = return_angle(L1, L2, c);

  servo2.writeMicroseconds(floor(((a2 + a1 - M_PI) * SERVOFAKTOR) + SERVOLEFTNULL));

  // calculate joinr arm point for triangle of the right servo arm
  a2 = return_angle(L2, L1, c);
  Hx = Tx + L3 * cos((a1 - a2 + 0.621) + M_PI); //36,5°
  Hy = Ty + L3 * sin((a1 - a2 + 0.621) + M_PI);

  // calculate triangle between pen joint, servoRight and arm joint
  dx = Hx - O2X;
  dy = Hy - O2Y;

  c = sqrt(dx * dx + dy * dy);
  a1 = atan2(dy, dx);
  a2 = return_angle(L1, (L2 - L3), c);

  servo3.writeMicroseconds(floor(((a1 - a2) * SERVOFAKTOR) + SERVORIGHTNULL));

}

RAMPS 1.4 on the Velleman K8200

After sending my original Velleman K8200 control board to circuit board heaven where it probably met up with the other A4988 chips I’ve burned in the past, I finally received a RAMPS 1.4 shield, a set of new stepper drivers (which already carried small heatsinks), the RepRapDiscount Full Graphic Smart Controller and an Arduino Mega.




RAMPS 1.4 and GLCD




20141121_123215




The boards I got were manufactured, sold and labeled by a company called Sintron and are very high quality boards I have to say. Now the journey of resuscitating my 3D printer could finally continue.




Fist of all some adapter cables have to be made. The RAMPS 1.4 shield has got terminal blocks for the heatbed, extruder and fan. You have to select in firmware, which configuration you want to have for your shield. One pair of blocks is fused with a 11 Ampère fuse and is meant to power the heatbed, the other two can be configured. Use large wires and 4 2.54mm header pins, 2 for + and 2 for minus because the currents are pretty high here. One bridge cable is needed between the 5A and the 11A positive terminal if you want to use the Velleman power supply. Adapter cables are also needed for the endstop switches. I simply used male-female extension jumper wires and attached them so that they pull to GND when pressed. The Velleman female connectors for the stepper motors and thermistors that were there already fit on the RAMPS 1.4 directly and do not reqire adapter cables. After flashing a raw standard vesion of Marlin it turned out that the stepper motors for X, Z and the extruder were reversed. Out of liziness I swapped the red and green wire on the connectors for those and didn’t have to change anything in Marlin. The crimped connectors can be pulled out of the plastic enclosure by pressing down the tiny hook on them with a small nail. There is a nice connection diagram on the RAMPS 1.4 page.
You can remove the driver for the second extruder if you’re not using it and keep it as a replacement part.




Next, the stepper motor current has to be set. The drivers I got didn’t seem to have the exposed via to measure motor voltage and so I did it the good ol’way: by listening and turning the pot. The louder the hissing of the motor, the higher the current. What’s interesting is that sometimes you seem to receive radio stations on the stepper motor driver 😀 Presumably it’s AM radio. Fascinating! What I’ve also done is removed the small heat sinks from the X,Y,Z and E drivers and covering the entire PCB of the motor drivers with a strip of Kapton tape and cut out the outline of the A4988 chip with a sharpie knife. Then I reattached the heat sinks. I noticed that that they tend to sink down when you mount the board horizontally upright. That’s why the’re called heat sinks.. Haha. The Kapton just prevents the header pins of the drivers from being shorted out by the heat sink at some point, since the printer vibrates during operation.
I’ve attached a small heatsink to the bottom of the Arduino Mega board right beneath the linear regulator, since it has to drop 15V down to 5V and therefore produces an immense amount of heat. With the heatsink it seems to be fine so far.



20141122_193906




20141122_214441




Pretty much everything else has to be adjusted in the Configuation.h file in Marlin. Here is my Configuration.h file. The main changes I have made are:
1. selecting the proper board with the extruder-fan-heatbed configuration
2. inverting the endstops
3. selecting the RepRapDiscount Full Graphic Smart Controller
4. enabling SD card support
5. changing the baud rate to 115200 in order to connect a bluetooth module
6. setting the right steps per mm for all axes
7. lowering accelerations. That’s right. I wanted to try accelerations of 500mm/s^2 and observe their impact on print quality, since the K8200/3DRAG is built in X-Y-Table configuration and the motors (especially X) have to accelerate a larger mass than in other printers. Also, I will try printing with lower speeds in the future.
8. Is this it?




EDIT: download my complete Marlin version here: Marlin_K8200_GLCDmod




Of course you need to download and install the u8glib Arduino Library prior to uploading. I used version 1.5.




All in all I’m very pleased with the RAMPS 1.4 upgrade. The controller offers you the the possibility to adjust print speed on the fly (among many other settings) and print from the SD card without any problems. The system is almost plug and play and can be further extended. For example a wireless option can be added. I’ve attached a Bluetooth Mate Silver right now, which has level shifters on the TR and RX lines and is therefore 5v-compatible. You can print from RepetierHost directly over the air or control the printer over an Android device both without any problems. There’s an app around already and I’m thinking about writing my own…Also I’m considering testing Xbee for a longer range.

More mods on the Velleman k8200 3D Printer

k8200




After using the Printer for some weeks, some weaknesses became apparent and I finally had the motivation to fix them and add some robustness to the system and increase precision.




1. Add a dirt catcher under the extruder gears to prevent the dirty particles composed of ABS debris and oil from dropping on the printing bed.




20141022_145746




2. replace the X-Axis pulley with a printed one, since the original one was out of round, which impairs printing quality!




pulley (1)




3. Add robust and precise homing system for the Z axis.




z homing system




4. Extend the Z- Axis with a second spindle. I’m using another M8 stainless steel threaded rod with a flex shaft coupler and 2 regular hex nuts with anti-backlash spring. The motor mount and 608Z ball bearing holder are 3D-printed, as well as the arm extension. I’m not sure how this will affect print quality, but adding another spindle prevents the other one from wearing quickly. Also, like many other people, I have observed stronger vibration of the Z arm than on the frame itself. Eliminating it is not that hard and I had another NEMA 17 stepper and all the other parts lying around here anyway. My design can be found here.




k8200 dual z axis




bearing holder z-axis




motor mount side view




motor mount z-axis




printed z axis arm extension and nut box




second z axis complete assembly




anti-backlash nut assembly




k8200 (3)




5: rebuild the left Z axis with more rigid parts:




Left Z axis anti-backlash and more rigid mount




Z-axis Backlash eliminator




K8200 rod guide piecesholder STL can be found here




6. Mount a proper filament guide with a ball bearing on top of the LED light. This is supposed to have a very interesting function: since my printer lives in the attic, the filament tends to break, especially PLA is affected, during printing and when the filament spool is almost empty. The reasons are 1. low temperature and 2. tension in the filament as it unwinds from a smaller radius (the windings near to the core of the spool have a smaller radius). Before I begin printing something, I will turn on the nice 12W LED lamp which produces a lot of heat as a by-product. Since the filament makes its sharpest turn on its way into the extruder right where the heatsink of the LEDs is located, this is exactly the place where heat is needed. I hope that this will make filament shattering more unlikely in the future.




7. Add belt tensioners to the X and Y axis belts. these are simply springs from standard plastic clothespins that are bent to a proper shape, attached to the belts and secured with small zip ties. Watch out that the belts do not touch each other.




belt tensioners




8. Add a filament spool holder with ball bearings. Maybe this will take off strain from the filament as well and prevent it from breaking due to the spool spinning unevenly.
here’s the thing



To do in the near future:




9. Update the firmware




10. Add an SD card holder, rotary encoder and a 20×4 LCD




11. make an enclocure for the elctronics




12. attach little heatsinks to the stepper driver chips




parts for the autonomous board (k8200/3drag)




After realizing that a 20×4 character lcd, a (micro) SD card adapter with level shifter, a rotary encoder, 2×10 male & female pin headers and a ribbon cable is all that’s needed for transforming the printer into an autonomous device, I could finally start hacking again, because I had most parts lying around here anyway. What seemed to be a simple task, quickly turned out to become a little life lesson.
Since the K8200 Velleman kit is derived from an open source, RepRap-inspired project named 3DRAG by www.open-electronics.org, all schematics are freely accessible and its hardware as well as software are quite universal. Here’s the page with the schematics for the “autonomous board” that connects to the 2×9 pin header on the k8200/3DRAG control board. The schematics are quite simple, albeit not quite readable. Nontheless I soldered some pins onto the main board and started soldering up the LCD/SD/encoder board on a perfboard, which can sometimes take some hours if you wat a clean assembly.




2x9 header pins soldered on the k8200/3drag control board




The excitement of getting the system to work as quickly as possible and improving the project forced me to overcome tiredness and hypoglycemia and in the end led to me swapping some dangerous wires, to be exact the motor supply voltage pin with some other port pin of the Atmega2560 microcontroller. Well, you can imagine what happened as the chip got 15 Volts on on of its GPIO pins! It died immediately. Before it died, I managed to do a firmware update though, which worked without any problems. Just short the “JPROG” pins together with a jumper and treat the thing like a regular Arduino Mega (with power supply connected, else it won’t upload). So this is what I ended up with:




control board and motherboard k8200 3drag




control board bottom (1)




I’m hoping that the FTDI chip and the stepper motor drivers have survived this terrible accident. The FTDI chip is at least recognized by the PC as a serial port device, I haven’t tested the stepper drivers yet. As for now I’ve removed the broken microcontroller chip and will try to replace it to see if the main board can be resuscitated. Having to de-solder re-solder a TQFP100 package is god’s punishment for being impatient and not taking a break during my build.
If replacing the microcontroller, flashing the Arduino Mega bootloader and Marlin v2 firmware doesn’t bring the main board back to life, I will probably have to install a RAMPS 1.4 electronics. This is basically the same electronics as the Original K8200/3DRAG mainboard, but a little more versatile, albeit a little less compact. They are available on eb** in various combinations. You have the possibility to connect a 128×64 graphics lcd and even a bluetooth module to the RAMPS 1.4 board, so this little crisis can even bring some new options as the ancient chinese saying states 🙂
Right now, I’ve corrected the bug in the wiring of the LCD/SD/encoder board and keep waiting for replacement parts.




Update: ok, so replacing the microcontroller didn’t resuscitate the board. I suspect that the stepper drivers and something else got fried as well. Actually not that surprising, as far as I have reconstructed the scenario correctly, 15VDC with reversed polarity might have hit the logic supply rails. After soldering the Atmega2560 I was not even able to flash the bootloader. Despite using plenty of flux and producing neat-looking solder joints nothing seemed to work. The chip was supposed to have the wrong signature according to avrdude. I tried overriding that error and doing the upload anyway, but that didn’t yield any results at all. Not even the fuse and lock bits could be configured. After touching all pins with the soldering iron once again to make sure that there are no “cold” solder joints and removing all stepper drivers, a different error was displayed. “Device doesn’t answer…” After a while I gave up and ordered a complete RAMPS kit with a RepRapDiscount Full Graphic Smart Controller and a complete set of new stepper drivers. Maybe I’ll try tracing down the error, but not right now 🙂 I’ll open up a new blogpost on the RAMPS setup on the k8200.