Work in progress,

First let me say that this is not a finished project, it is still very much under development. As such I want to use as much from this printer as possible, the only things I imagine having to buy is vitamins such as 10mm M4 hex nuts and some M4 bolts, maybe a few 20mm M4’s. I have a metric ton of M3’s laying around from previous builds so maybe I will use those as well, and I have a few ramps board with drivers, LCD’s etc etc. BUT, I will try to use as much from this printer as possible to make the conversion a cheap as possible.

I was given a Da Vinici Jr 1.0 as a mess around project. I tried to set it up and well.. either I got a crap unit or XYZ needs to rethink what they are doing. I could not for the life of me get this thing to print in any decent quality, not to mention the closed source firmware and software and to top it all off the closed source filament. Let me just say .. NOOOOOOOOOOO

Ok I may have gotten a bad unit who knows, all I know is that it sat for 2 years and did nothing but take up valuable space in my office. My Prusa I2 works circles around this thing. So what to do with a borked printer. Well what would any self respecting hacker/engineer/whatever you call yourself do? take it apart, see what parts it spits out and make something new.

So through this build log we are going to go through what it takes to make the Da Vinci Jr a good printer, and by that I mean what kind of printer can we build from its guts. From what I can piece together so far a fairly decent printer. So far I have modeled part of the frame using the existing Aluminum extrusions extracted from the unit and whipped up some parts that will need to be printed. Here is a list of the things I plan on using from the Da Vinci Jr.

• 2020 Aluminum extrusions, you get 5 x 376.009mm and 4 x 299.5mm enough to build a Prusa I3 style frame.
• 4 x Alu L brackets.
• 10mm Diameter Polished rods 2 x 296.05mm “Bed rails for our build”
• 10mm Diameter Polished rods 2 x 299.65mm “Z rails for our build”
• 8 x Brass? 10mm inner Diameter | 12mm outer Diameter bushings “They move so well”
• 2 x brass? 8mm diameter bushings from the x carriage.
• Z axis Stepper motor x 1
• Z axis coupler 5mm to 8mm x 1
• Z axis sudo ball screw, looks more like a fine pitch (0.75mm) single start lead screw.
• Z axis lead screw nut. “Slides ok, my 4 start lead screw is nicer.”
• X axis Stepper motor x 1 with plastic pulley “I’d recommend replacing with a GT2 style 20T pulley”
• Y axis Stepper motor x 1 with plastic pulley “Same as X axis pulley”
• Bowden style extruder x 1 “We may be using this.”
• Bowden style hot end x 1 “We may modify this to be used. I don’t like the quick release stuff.”
• A bunch of misc nut and bolts, screws etc. only the nuts and bolts used for the Alu extrusion will be used.
• There are some pulleys as well but they are cheap plastic ones, if they fit the GT2 belt may as well use them.

The other stuff is trash, the main board, the screen may be able to be used or used for another project. Other than that and needing another printer or a friend to print out the other parts we may vary well have a nice printer on our hands.

Starting out with the frame, we get some nice L brackets to use for our main Y axis, that not being enough for a rigid frame I whipped up some over engineered plastic bits for you guys to spew out of your printers.

The Y corners are made of 4 separate pieces all printable on my tiny MP select mini V2 printer.

• Alu L bracket, + 2 x 10mm bolts
• 1 x Top corner bracket + 7 x 10mm bolts
• 1 x L corner bracket + 7 x 10mm bolts “the fourth bolt closest to the foot is bolted directed into the threaded portion of the extrusion”
• 1 x Bottom foot bracket + 4 x 10mm bolts

wow all together that’s 20 x 10mm M4 nuts and bolts. That corner is not going anywhere, the only corner I have now for testing the printed bits is stupid strong at this point.

Next we have the Y rode holder, part also prints fine on my tiny printer.

The rods from the Da Vinci Jr are 10mm rods with 8mm end shafts. The Y rod holder bolts to the top and the back side of the front and back Alu extrusion profiles.

Next we have the Y bushings, they are super nice, way nicer than my LM8UU’s. But in order to use them we need something to capture them to a plate. This is what I came up with.

So far this works really well, these bits lock into place quite snug and won’t let go when bolted to a plate of some sort. We may find that we need to extend each side of the holder to allow for a longer bolt to stop twisting if there is any.

The final part I have tested, I still have to mount to the frame. Is the Z axis stepper mount, this printer will only have 1 x Z axis stepper but I think since the bushings have such a nice fit we can get away with only one.

This is a Prusa I3 style mount, as such that the Z axis smooth rod fits next to the stepper and the stepper bolts right to the frame with 7 x 10mm M4’s.

So far that’s where I will leave this post, at first I thought I was just going to scrap the Da Vinci Jr for parts and think nothing of if. I would have taken pictures of the tare down or a video had I thought about it. I am currently waiting on a load of M4 nuts and bolts from china to finish test fiting some stuff. I have also ordered 2M of 6mm GT2 belt a few GT2 20T pulleys and some idler bearings. I will put them in a bill of materials soon.

Please do share your thoughts and comments, I would like feedback on this project. I also want this to be something that people may be willing to take on if they have a borked unit sitting around. Until next time (soon hopefully)

I tend to like to power through designs but this time im forcing myself to take time and think it through.

This where I’m currently at in the design. I still have to assign the 64 pin package all of its nets but I think I can do everything in two layers 🙂

it’s funny to think that the cartridge will be x times more powerful than the hardware in witch it will sit. but I figured this would be the cheapest way and least component count to get a usb flash cart.

if I can swing it I may add uSD support… well see if I want to punish myself that bad with only two layers.

until next time.

I’ve decided to finish thus project finally. between work etc I have a little time to see if I can bring the project into the new age or more recent age and source readily available parts that don’t cost an arm and a leg.

so far I have the carts at a reasonable BOM price. 

The specs so far are:

• An MBCx simulated by a CPLD
• A 32Mbit (4MByte) flash ROM upgradable to 64Mbit.
• A 1Mbit (128KByte) Flash for non-volatile RAM
• Bi-Directional Voltage converters for the ROM since the only 5v chip is the RAM.
• LDO for the rest of the 3.3v logic.

I have also sourced clear green (non official) game boy cartridges to house the PCB.

The schematics are done and all the parts are ordered. I still have to route the board but will soon send for DV2 of the cartridge. 

if I have time or the patience I will try my hand at a bootstrap menu to take advantage of the 32Mbit/64Mbit space to allow for use as a multi cart.

until then. stay happy stay healthy and keep hackin.

In this tutorial we are going to get serial communication up and running. Having serial communication helps in that we can send human readable messages to a computer instead of decoding a blinking led, unless that’s your cup of tea go ahead and skip this tutorial 🙂

Getting started.

We are going to learn about header files as well here as I like to split my code up into files that have meaning, such as uart.h and uart.c having your functions etc in these files makes it easy for you to remember along with good function names where your function is. Incase the need arises to edit or change something in the function.

Adding files to our project.

First we need to add a few files to our project, board.h, uart.h, uart.c. board.h is where we will redefine all of our important pins, our clock, desired serial baud rate etc.

Uart.h and uart.c are going to house all of our important and reusable serial functions. One approach to creating new functions is to use main.c as a prototype area, define your function in main.c and test it out. If all goes well it can go into the library it was meant for.

So right-click on your project name go to add and add new. This will bring up a new window that allows you to pick and name a new file.

We will be adding two .h (header files) and one .c file to our project. Go ahead and create the required three files. Your file tree should look like this now.

In brief what is a header file? A header file contains the definitions for your desired library, this file is also included in your main program with the

#include

directive. This tells the Atmel studio you want this library and it’s functions compiled into your program. If you try to use a function from a library without including it the compiler will throw all kinds of errors some cryptic and won’t compile your project.

Board.h file contents.

So first we are going to redefine some pins define our clock and desired baud rate. I will comment the code so it’s well explained. I will go into further detail on registers when we do uart.c.

/*
  board.h
  Author OCybress
  Summery used to define easy to. remember names 
  and other board related defines.
*/

#ifndef BOARD_H_
#define BOARD_H_

//this will be used in calculating baud. 
//Its also defined in your compiler settings 
//so this may throw a warning F_CPU redefined.
#define F_CPU 16000000UL

//move led pin definition here
#define LED_PIN PB5

#endif /* BAORDS_H_ */

uart.h header file

the uart header file contains some uart specific re defines and function prototypes, uart_init, uart_write_byte, and uart_read_byte

#ifndef UART_H_
#define UART_H_

//uart related defines
#define UART_DATA_REG UDR0
//port D bit 0, TX (register UDRE0)
#define TX UDRE0
//port D bit 1, RX (register RXC0)
#define RX RXC0

//baudrate can be set to 115200 as well since we are 
//calculating the baud rate based off F_CPU
#define BAUD_RATE 9600

//Calculated baud rate basses on F_CPU
#define BAUD_PRESCALLER ((F_CPU/(BAUD_RATE * 16UL))-1)

//usart baud rate register high byte
#define USART_BAUD_REG_HB UBRROH
//usart baud rate register low byte
#define USART_BAUD_REG_LB UBRR0L
//tx/rx en bits
#define TX_ENABLE TXEN0
#define RX_ENABLE RXEN0

//Uart Control and Status Registers
#define UART_CTRL_STS_REG_A UCSR0A
#define UART_CTRL_STS_REG_B UCSR0B
#define UART_CTRL_STS_REG_C UCSR0C

//critical uart functions
void usart_init (void);

/*********************************/
/*Useful uart function prototypes*/
/*********************************/
uint8_t uart_read_byte();
void uart_write_byte(uint8_t data);

#endif /* UART_H_ */

uart.c

If you wish to use the bare registers instead of the redefined names feel free, it will work the same. Note they are already defined so you do not have to define the register names. For example if you wanted to use UDR0 instead of UART_DATA_REG that will not effect the code in any way. In fact I urge you to use the registers instead of redefining them for the first few times you write your uart functions. Once you are comfortable with the register names then you can rename as you see fit.

#include "board.h"
#include "uart.h"

/*************************/
/*Critical uart functions*/
/*************************/
void usart_init ()
{
    USART_BAUD_REG_HB = (uint8_t(BAUD_PRESCALLER>>8);
    USART_BAUD_REG_LB = (uint8_t)(BAUD_PRESCALLER);
    UART_CTRL_STS_REG_B = (1<<RX_ENABLE )|(1<<TX_ENABLE);
    //Data flow settings.
    //data bits = 8, parity = none, stop bit = 1
    UART_CTRL_STS_REG_C=(3<<ucsz00);
}

/***********************/
/*useful uart functions*/
/***********************/

/*Read one byte to the UDR0 register*/
uint8_t uart_read_byte()
{
	//wait until the port is ready to read.
	while((UART_CTRL_STS_REG_A &(1<<RX))==0){}
	//return received data
	return UART_DATA_REG;
}

/*Write one byte to the UDR0 register*/
void uart_write_byte(uint8_t data)
{
	// wait until the port is ready to write.
	while((UART_CTRL_STS_REG_A & (1<<TX)) == 0){}
	
	//write data to port
	UART_DATA_REG = data;
}

Putting it all together.

Now that we have everything setup, and our uart library is ready to go. Lets get main.c ready to spit some text to our terminal.

#include <avr/io.h>
//include our library files.
#include "boart.h"
#include "uart.h"

//Test message to send over uart.
const char aTestMsg[] = {"hello world"}

//example of a prototype function in main.c to later
//move into uart.c
void uart_write_string(char *s)
{
	unsigned int i=0;
	while(s[i] != 0x00)
	{
		uart_write_byte(s[i++]);
	}
}

void main(void)
{
	/*setup uart for 9600baud*/
	usart_init();
	
	//send byte with uart example Hello World
	uart_write_byte("H");
	uart_write_byte("e");
	uart_write_byte("l");
	uart_write_byte("l");
	uart_write_byte("o");
	uart_write_byte(" ");
	uart_write_byte("W");
	uart_write_byte("o");
	uart_write_byte("r");
	uart_write_byte("l");
	uart_write_byte("d");
	uart_write_byte("\n"); //new line

	//send a string 
	uart_write_string(aTestMsg);
	
	uint8_t u8_data;
	
	//example of sending a string without the array.
	uart_send_string("Send an option, h = hello, x = exit\r\n");
	//uart_read_byte example
	while(u8_data != 'x')
	{
		u8_data = uart_read_byte();
		if(u8_data == 'h')
		{
			uart_write_string("hello\r\n");
		}
		if(u8_data == 'x')
		{
			uart_write_string("Exiting menu.\r\n");
			u8_data = 'x';
		}
	}/* end while */

	uart_write_string("End Example..\r\n");
	
}/* end main */

Once everything is in order. Compile the project and upload it to the avr (atmega328 series), load up a terminal such as cool term and you should be ready to go. Be sure to go to options and set your connection settings to 9600 baud, the rest should be the default settings.

I’ll post a terminal picture soon.

Going forward.
Now that we know how to toggle some bits, and use the uart to extract useful information from our microcontroller. We can do a lot more experimentation and still know whats going on inside the micro if anything goes wrong.

Next time or later on we may look at implementing Uart functions in ASM just for the hell of it 😉

Whats next?
I think the ADC is a good place to start next, as this allows us to input real world data into the micro , such as a 4×3 keyboard, analog sensors etc. Or we may do something with SPI flash… If you have any comments, questions, or corrections feel free to drop a comment or email me.