OCFreaks!

ASUS HD 7970 Matrix Platinum 3 GB review

Sumon Pathak — Sun, 28 Apr 2013 19:17:56 +0000

Introduction

Hey guys!
Hows it going? Finally got my hands on the HD 7970 Gigahertz Edition and i thought i should do a review for you. Now the sample i have today is the Matrix Platinum Version of HD 7970 from Asus which is a beast in its own right.

This card is clocked higher than any other 7970 Gigahertz Edition in the market and as such it competes directly with the 7970 Lighting as to the specs. Clocking in at 1100 MHz Core and 1650 MHz memory speed this THE fastest 7970 as of now.

Lets take a look what Asus have in their 7970 offerings and then we shall check out more about this card.

Model name	MATRIXHD7970P-3GD5(Platinum Edition)	MATRIXHD7970-3GD5
Graphics engine	AMD Radeon™ HD 7970 GHz Edition
Stream processors	2048
Bus standard	PCI Express® 3.0
OpenGL®	OpenGL 4.2
Video memory	3072MB GDDR5
Engine clock	1100MHz (boost clock)1050MHz (base clock)	1050MHz (boost clock)1000MHz (base clock)
Memory clock	6600MHz (1650MHz GDDR5)
Memory interface	384-bit
DVI max resolution	2560 x 1600
DVI output	1 x single link DVI1 x dual link DVI
HDMI output	1 x HDMI via adapter
HDCP compliant	Yes
DisplayPort	4 x native DisplayPort
Adapters/cables bundled	2 x 8-pin power cable, 1 x DVI to HDMI adapter,1 x extended CrossFire™ bridge, 1 x VRM heatsink for liquid nitrogen overclocking
Software bundled	ASUS utilities and driver GPU Tweak
Dimensions	11″ x 5.1″ x 2.1″ (2.6-slot)

Bioshock Infinite Review

Vivek Singh (Aka: Reaper) — Sun, 21 Apr 2013 15:01:22 +0000

Introduction

Developer:	Irrational Games
Publisher:	2K Games
Platforms:	PC, Xbox 360, PlayStation 3
Genre:	First Person Shooter
Engine:	Modified Unreal Engine 3

Bioshock Infinte is a First Person Shooter set in the early 20th Century America. You play as Booker DeWitt, a private Investigator and former Pinkerton Agent. Offered a chance to clear his debt by bringing in a girl “Elizabeth” you are escorted by a mysterious pair to a lighthouse , This is not a sequel to Bioshock in fact this takes place 5 decades before the events in Rapture, and you are flown to a beautiful floating air-city of Columbia, founded by and under the rule of Zachary Hale “Father” Comstock.

Comstock learns of your arrival and dispatches his troops after you, but you soon meet Elizabeth in a tower where she has been held captive for 20 years. Booker offers Elizabeth an escape to Paris and they team up against Comstock and fight their way through hordes of human and ‘automated’ enemies all the while discovering more about their connection with the city and the prophecy. Bioshock Infinite was announced in 2010, and has been on a pedestal since as Irrational claimed to be working on a different kind of Video Game experience. And now it’s time to confirm whether they were successful or not.

LPC2148 Timer Tutorial

Power_user_EX — Thu, 28 Mar 2013 07:18:58 +0000

The Basics
After writing the first blinky program using random delay , now its time to improvise and induce precise delay using timers! The real fun in embedded starts when you start playing with timers (& UARTs , PWM , etc.. ofcourse which we will see in my future posts). I’ll try to keep it simple and short so its easy to understand.

LPC2148 comes loaded with two 32-bit-Timer blocks. Each Timer block can be used as a ‘Timer’ (like for e.g. triggering an interrupt every ‘t’ microseconds) or as a ‘Counter’ and can be also used to demodulate PWM signals given as input.

A timer has a Timer Counter(TC) and Prescale Register(PR) associated with it. When Timer is Reset and Enabled TC is set to 0 and incremented by 1 every ‘PR+1′ clock cycles. When it reached its maximum value it gets reset to 0 and hence restarts counting. Prescale Register is used to define the resolution of the timer. If PR=0 then TC is incremented every 1 clock cycle of the peripheral clock. If PR=1 then TC is incremented every 2 clock cycles of peripheral clock and so on. By setting an appropriate value in PR we can make timer increment or count : every peripheral clock cycle or 1 microsecond or 1 millisecond or 1 second and so on.

Each Timer has four 32-bit Match Registers and four 32-bit Capture Registers.

The Register Specifics

What is a Match Register anyways ?

Ans: A Match Register is a Register which contains a specific value set by the user. When the Timer starts – every time after TC is incremented the value in TC is compared with match register. If it matches then it can Reset the Timer or can generate an interrupt as defined by the user. We are only concerned with match registers in this tutorial.

Match Registers can be used to:

Stop Timer on Match(i.e when the value in count register is same as than in Match register) and trigger an optional interrupt.
Reset Timer on Match and trigger an optional interrupt.
To count continuously and trigger an interrupt on match.

What are Capture Registers ?

Ans: As the name suggests it is used to Capture Input signal. When a transition event occurs on a Capture pin , it can be used to copy the value of TC into any of the 4 Capture Register or to genreate an Interrupt. Hence these can be also used to demodulated PWM signals. We are not going to use them in this tutorial since we are only concerned with using Timer block as a ‘Timer’. We’ll see them in upcoming tutorial since it needs a dedicated tutorial.

Now lets see some of the important registers concerned mainly with timer operation.

1) PR : Prescale Register (32 bit) – Stores the maximum value of Prescale counter after which it is reset.

2) PC : Prescale Counter Register (32 bit) – This register increments on every PCLK(Peripheral clock). This register controls the resolution of the timer. When PR reaches the value in PC , PR is reset back to 0 and Timer Counter is incremented by 1. Hence if PR=0 then Timer Counter Increments on every 1 PCLK. If PR=9 then Timer Counter Increments on every 10th cycle of PCLK. Hence by selecting an appropriate prescale value we can control the resolution of the timer.

3) TC : Timer Counter Register (32 bit) – This is the main counting register. Timer Counter increments when PC reaches its maximum value as specified by PR. If timer is not reset explicitly(directly) or by using an interrupt then it will act as a free running counter which resets back to zero when it reaches its maximum value which is 0xFFFFFFFF.

4) TCR : Timer Control Register – This register is used to enable , disable and reset TC. When bit0 is 1 timer is enabled and when 0 it is disabled. When bit1 is set to 1 TC and PC are set to zero together in sync on the next positive edge of PCLK. Rest of the bits of TCR are reserved.

5) CTCR : Count Control register – Used to select Timer/Counter Mode. For our purpose we are always gonna use this in Timer Mode. When the value of the CTCR is set to 0×0 Timer Mode is selected.

6) MCR : Match Control register – This register is used to control which all operations can be done when the value in MR matches the value in TC. Bits 0,1,2 are for MR0 , Bits 3,4,5 for MR1 and so on.. Heres a quick table which shows the usage:

For MR0:

Bit 0 : Interrupt on MR0 i.e trigger an interrupt when MR0 matches TC. Interrupts are enabled when set to 1 and disabled when set to 0.

Bit 1 : Reset on MR0. When set to 1 , TC will be reset when it matched MR0. Disabled when set to 0.

Bit 2 : Stop on MR0. When set to 1 , TC & PC will stop when MR0 matches TC.

Similarly bits 3-5 , 6-8 , 9-11 are for MR1 , MR2 , MR3 respectively.

7) IR : Interrupt Register – It contains the interrupt flags for 4 match and 4 capture interrupts. Bit0 to bit3 are for MR0 to MR3 interrupts respectively. And similarly the next 4 for CR0-3 interrupts. when an interrupt is raised the corresponding bit in IR will be set to 1 and 0 otherwise. Writing a 1 to the corresponding bit location will reset the interrupt – which is used to acknowledge the completion of the corresponding ISR execution.

Now lets actually use a Timer and see it in action. We are gonna use Interrupts in one of our example. An article on using interrupts in lpc214x will be posted shortly.

Setting up & configuring Timers
To use timers we need to first configure them. We need to set appropriate values in TxCTCR , TxIR , TxPR and reset TxPC , TxTC. Finally we assign TxTCR = 0×01 which enables the timer.

I would like to encourage the readers to use the following sequence for Setting up Timers:

Set appropriate value in TxCTCR
Define the Prescale value in TxPR
Set Value(s) in Match Register(s) if required
Set appropriate value in TxMCR if using Match registers / Interrupts
Reset Timer – Which resets PR and TC
Set TxTCR to 0×01 to Enable the Timer when required
Reset TxTCR to 0×00 to Disable the Timer when required

Now lets implement to basic function required for Timer Operation:
1. void initTimer0(void);
2. void delayMS(unsigned int milliseconds);

#1) initTimer0(void); [Used in Example #1]

Attention Plz! : This function is used to setup and initialize the Timer block. Timer blocks use peripheral clock as their input and hence peripheral clock must be initialized before Timer is initialized. In our case it is assumed that LPC2148 is connected to 12Mhz XTAL and both CPU and Peripheral Clocks have been setup to tick at 60Mhz.

void initTimer0(void)
{
/*Assuming that PLL0 has been setup with CCLK = 60Mhz and PCLK also = 60Mhz.*/

T0CTCR = 0x0;
T0PR = PRESCALE-1; //(Value in Decimal!) - Increment T0TC at every 60000 clock cycles
//Count begins from zero hence subtracting 1
//60000 clock cycles @60Mhz = 1 mS

T0TCR = 0x02; //Reset Timer
}

Prescale (TxPR) Related Calculations:

The delay or time required for 1 clock cycle at ‘X’ MHz is given by :
(1 / X * (10^6)) Seconds

Hence in our case when PR=0 i.e TC increments at every PCLK the delay required for TC to increment by 1 is:
((0+1) / 60 * (10^6)) Seconds

Similarly when we set PR = 59999 the delay in this case will be:
((59999+1) / 60 * (10^6)) = (60000 / 60 * (10^6) = 1 / (10^3) Seconds

… which boils down to 1/1000 = 0.001 Seconds which is nothing but 1 Milli-Second i.e mS. Hence the delay required for TC to increment by 1 will be 1mS.

#2) delayMS(unsigned int milliseconds);

void delayMS(unsigned int milliseconds) //Using Timer0
{
T0TCR = 0x02; //Reset Timer

T0TCR = 0x01; //Enable timer

while(T0TC < milliseconds); //wait until timer counter reaches the desired delay

T0TCR = 0x00; //Disable timer
}

Some Real World Examples

Example #1) – Basic Blinky example using Timer

Now lets make a blinky program which flashes a LED every half a second. Since 0.5 second = 500 millisecond we will invoke ‘delayMS’ as delayMS(500).

/*
(C) Umang Gajera | Power_user_EX - www.ocfreaks.com 2011-13.
More Embedded tutorials @ www.ocfreaks.com/cat/embedded

LPC2148 Basic Timer example.
License : GPL.
*/
#include

#define PLOCK 0x00000400
#define PRESCALE 60000 //60000 PCLK clock cycles to increment TC by 1

void delayMS(unsigned int milliseconds);
void initClocks(void);
void initTimer0(void);
void setupPLL0(void);
void feedSeq(void);
void connectPLL0(void);

int main(void)
{
initClocks(); //Initialize CPU and Peripheral Clocks @ 60Mhz
initTimer0(); //Initialize Timer0
IO0DIR = 0xFFFFFFFF; //Configure all pins on Port 0 as Output

while(1)
{
IO0SET = 0xFFFFFFFF; //Turn on LEDs
delayMS(500); //0.5 Second(s) Delay
IO0CLR = 0xFFFFFFFF; //Turn them off
delayMS(500);
}
//return 0; //normally this wont execute ever :P

}

void initTimer0(void)
{
/*Assuming that PLL0 has been setup with CCLK = 60Mhz and PCLK also = 60Mhz.*/

T0CTCR = 0x0;
T0PR = PRESCALE-1; //(Value in Decimal!) - Increment T0TC at every 60000 clock cycles
//Count begins from zero hence subtracting 1
//60000 clock cycles @60Mhz = 1 mS

T0TCR = 0x02; //Reset Timer
}

void delayMS(unsigned int milliseconds) //Using Timer0
{
T0TCR = 0x02; //Reset Timer

T0TCR = 0x01; //Enable timer

while(T0TC < milliseconds); //wait until timer counter reaches the desired delay

T0TCR = 0x00; //Disable timer
}

void initClocks(void)
{
setupPLL0();
feedSeq(); //sequence for locking PLL to desired freq.
connectPLL0();
feedSeq(); //sequence for connecting the PLL as system clock

//SysClock is now ticking @ 60Mhz!

VPBDIV = 0x01; // PCLK is same as CCLK i.e 60Mhz

//Using PLL settings as shown in : http://www.ocfreaks.com/lpc214x-pll-tutorial-for-cpu-and-peripheral-clock/
//PLL0 Now configured!
}

//---------PLL Related Functions :---------------

void setupPLL0(void)
{
//Note : Assuming 12Mhz Xtal is connected to LPC2148.

PLL0CON = 0x01; // PPLE=1 & PPLC=0 so it will be enabled
// but not connected after FEED sequence
PLL0CFG = 0x24; // set the multipler to 5 (i.e actually 4)
// i.e 12x5 = 60 Mhz (M - 1 = 4)!!!
// Set P=2 since we want FCCO in range!!!
// So , Assign PSEL =01 in PLL0CFG as per the table.
}

void feedSeq(void)
{
PLL0FEED = 0xAA;
PLL0FEED = 0x55;
}

void connectPLL0(void)
{
// check whether PLL has locked on to the desired freq by reading the lock bit
// in the PPL0STAT register

while( !( PLL0STAT & PLOCK ));

// now enable(again) and connect
PLL0CON = 0x03;
}

Download Project Source for Example #1 @ OCFreaks.com_LPC214x_Timer_Tutorial.zip [Successfully tested on Keil UV4.70a]

Example #2) – Blinky example using Timer with Interrupt

Attention Plz! : Please take your time to go through “initTimer0()” function. Here I’ve used Match Register 0(T0MR0) and Match Control Register(T0MCR) and setup Interrupt handler which gets triggered when value in TC equals the value in T0MR0. A detailed tutorial on using and configuring Interrupts on LPC214x will be online very shortly.

Also if you are using Keil Version4(or higher) you’ll need to edit Target Option settings and those Crossworks for ARM etc .. you need to manually enable global interrupts – A simple way to make interrupts working is @ Here

/*
(C) Umang Gajera | Power_user_EX - www.ocfreaks.com 2011-13.
More Embedded tutorials @ www.ocfreaks.com/cat/embedded

LPC2148 Timer example using Interrupt.
License : GPL.
*/

#include

#define PLOCK 0x00000400
#define MR0I (1<<0) //Interrupt When TC matches MR0
#define MR0R (1<<1) //Reset TC when TC matches MR0

#define DELAY_MS 500 //0.5 Seconds Delay
#define PRESCALE 60000 //60000 PCLK clock cycles to increment TC by 1

void delayMS(unsigned int milliseconds);
void initClocks(void);
void initTimer0(void);
__irq void T0ISR(void);

void setupPLL0(void);
void feedSeq(void);
void connectPLL0(void);

int main(void)
{
initClocks(); //Initialize CPU and Peripheral Clocks @ 60Mhz
initTimer0(); //Initialize Timer0

IO0DIR = 0xFFFFFFFF; //Configure all pins on Port 0 as Output
IO0PIN = 0xF;

T0TCR = 0x01; //Enable timer

while(1); //Infinite Idle Loop

//return 0; //normally this wont execute ever :P
}

void initTimer0(void)
{
/*Assuming that PLL0 has been setup with CCLK = 60Mhz and PCLK also = 60Mhz.*/

//----------Configure Timer0-------------

T0CTCR = 0x0;

T0PR = PRESCALE-1; //(Value in Decimal!) - Increment T0TC at every 60000 clock cycles
//Count begins from zero hence subtracting 1
//60000 clock cycles @60Mhz = 1 mS

T0MR0 = DELAY_MS-1; //(Value in Decimal!) Zero Indexed Count - hence subtracting 1

T0MCR = MR0I | MR0R; //Set bit0 & bit1 to High which is to : Interrupt & Reset TC on MR0

//----------Setup Timer0 Interrupt-------------

VICVectAddr4 = (unsigned )T0ISR; //Pointer Interrupt Function (ISR)

VICVectCntl4 = 0x20 | 4; //0x20 (i.e bit5 = 1) -> to enable Vectored IRQ slot
//0x4 (bit[4:0]) -> this the source number - here its timer0 which has VIC channel mask # as 4
//You can get the VIC Channel number from Lpc214x manual R2 - pg 58 / sec 5.5

VICIntEnable = 0x10; //Enable timer0 int

T0TCR = 0x02; //Reset Timer
}

__irq void T0ISR(void)
{
long int regVal;
regVal = T0IR; //Read current IR value

IO0PIN = ~IO0PIN; //Toggle the state of the Pins

T0IR = regVal; //Write back to IR to clear Interrupt Flag
VICVectAddr = 0x0; //This is to signal end of interrupt execution
}

void initClocks(void)
{
setupPLL0();
feedSeq(); //sequence for locking PLL to desired freq.
connectPLL0();
feedSeq(); //sequence for connecting the PLL as system clock

//SysClock is now ticking @ 60Mhz!

VPBDIV = 0x01; // PCLK is same as CCLK i.e 60Mhz

//PLL0 Now configured!
}

//---------PLL Related Functions :---------------

//Using PLL settings as shown in : http://www.ocfreaks.com/lpc214x-pll-tutorial-for-cpu-and-peripheral-clock/

void setupPLL0(void)
{
//Note : Assuming 12Mhz Xtal is connected to LPC2148.

PLL0CON = 0x01; // PPLE=1 & PPLC=0 so it will be enabled
// but not connected after FEED sequence

PLL0CFG = 0x24; // set the multipler to 5 (i.e actually 4)
// i.e 12x5 = 60 Mhz (M - 1 = 4)!!!
// Set P=2 since we want FCCO in range!!!
// So , Assign PSEL =01 in PLL0CFG as per the table.
}

void feedSeq(void)
{
PLL0FEED = 0xAA;
PLL0FEED = 0x55;
}

void connectPLL0(void)
{
// check whether PLL has locked on to the desired freq by reading the lock bit
// in the PPL0STAT register

while( !( PLL0STAT & PLOCK ));

// now enable(again) and connect
PLL0CON = 0x03;
}

Download Project Source for Example #2 @ OCFreaks.com_LPC214x_TimerIRQ_Tutorial.zip [Successfully tested on Keil UV4.70a]

LPC2148 Interrupt Problem and Issue fix

Power_user_EX — Thu, 28 Mar 2013 06:19:08 +0000

Many guys including me have been facing a problem with KEIL4 where the Interrupts or IRQs wont execute even if the code is correct .. but now I’ve found a simple trick to make the interrupts work. Even I have wasted a long time trying to figure out what the heck was going wrong with KEIL4. This problem was not there with KEIL3 and the code would work flawless.

To make your interrupts fire in KEIL4 .. all you need to do is : ‘Check’ a Checkbox in Target options Under the Linker Tab and you are Done! I don’t know why .. but KEIL4 doesn’t do this automatically when you create new project.

Step 1 – Click Target Options which will open a new Window. Next click on the ‘Linker’ Tab:

Step 2 – Check the very first checkbox called “Use Memory layout from Target Dialog”:

Now , rebuild your target and run the simulation. Interrupts must fire now.

For those having similar problem on Crossworks for ARM / Yagarto or any other GNU based ARM toolchain a fix is @ Here

Whether this helped you or not please let me know in your comments.

ADATA DashDrive HE 720 USB 3.0 Portable hard disk review

Sumon Pathak — Sun, 24 Mar 2013 17:32:14 +0000

Howdy folks! hows it going out there?
Today for you guys i have something from ADATA.
Something from their range of portable HDD’s.

but first a few words about the company

ADATA Technology Co., Ltd. is a Taiwanese memory and storage manufacturer, founded in May 2001 by Simon Chen.Its main product line consists of DRAM modules, USB drives, USBhard drives and memory cards in CompactFlash and Secure digital formats. ADATA has also explored other markets, such as digital frames, solid-state drives, and Express Cards.

Now that’s out-of-the-way,lets see what we have in our hands today.
Presenting the Adata DashDrive HE 720

Main feature

8.9mm Slimmest Profile
Stainless Steel Enclosure with 9H Scratch Resistance
One-Touch Backup Button Allowing Easy Backup Process,
SuperSpeed USB 3.0 (backward compatible with USB 2.0)

DIY CNC Router / Mill

Power_user_EX — Thu, 21 Mar 2013 07:02:11 +0000

Project Bootstrap – (Yet another xD) DIY 3 Axis CNC

Project Bootstrap is OCFreaks’ 2nd Official Project which is – a Homemade DIY CNC Routing and Milling Machine.

For those guys who are new to CNC and related stuff lemme give you a formal introduction to ‘CNC Machine’ :

CNC stands for ‘Computer Numerical Control’ and that might confuse you even more. In its simplest form a CNC is an automated cutting-n-drilling machine. It can be used to cut, engrave, carve, mill,.. metal or wood or plastic , etc.. in the way you want. You design your 3D-solid using a CAD software. Then you convert that design into a format called ‘G-Code’ which a CNC controller software(CAM) understands. This CNC Controller software controls the Stepper motors on each Axes. The cutting head can be anything from a router(spindle), Laser cutting head to a Water Jet cutting head and also an extruder too which prints objects i.e your CNC becomes a 3D-Printer! To cut 3D-solids a CNC needs to have at least 3 Axis. Adding more Axes to a CNC enables you to cut more complex objects which is not possible using a 3-Axis CNC.

Link to CNC on wiki : http://en.wikipedia.org/wiki/Numerical_control

It all started when I entered into Robotics & Embedded – Somewhere around in late 2009. Back then I was working on a Hexapod Robot project. I had made a new design for my hexapod and then was faced with a challenge. How do I cut the design ? I had to do it manually or get it fabricated. Pro fabricators wont accept such sample quantity jobs. So I had to manually cut the parts for my hexapod .. Damn! During that time a random thought came in my mind – Why not make a CNC router and cut parts for robotics projects at home? I was like .. hmmmmm .. but making a CNC is tough ask. For months I was still like .. hmmmmm .. can I make it? can I really make it? Finally in April 2012 somewhere around my birthday I decided – Enough of this ‘can I make it? crap’ , Lets start freaking buildin’ it. After my exams in June 2012 I started researching on DIY CNCs seriously .. I mean damn seriously .. endlessly going through CNC related stuff for hours n hours n hours. My CNC story starts from here! My CNC project is divided into Intervals – each interval has its own story to say.

Interval 1 : INCEPTION (& Research)

Interval 2 : Part Selection and Sourcing

Interval 2A : Lead Screw , Lead Nut and Bearings Selection
Interval 2B : LM Bearings , Couplings & Motor Selection

Interval 3 : The Design**

Interval 4 : Ze Assembly & Electronics

Interval 4A : Ze Assembly Phase**
Interval 4B : Ze Custom Electronics

Interval 5 : Final Calibration**

Interval 6 : PCB Engraving Test**

Interval 7 : …In Progress…**

Note : ‘**’ => Post has not been uploaded yet. It will be online soon.

Here is Quick Video of Interval 6 : Here I’ve used the CNC to engrave text on PCB Copper Clads:

So .. What next in pipeline? : 2nd Version of the current CNC and a 3D-Printer!

The CNC Build in a Nutshell(sort-of)

6mm Thick Wooden Plates cut as per Design:

Drilled Sandwiched plates with effective thickness of 12mm:

Base aluminum frame:

Anti-backlash Lead Nuts , Regular ball-Bearings , Thrust Bearings & Couplings , Shaft and Lead Screw end support blocks:

Cut & Drilled Aluminum Angles of thickness 2mm:

Open and Closed type Linear Motion Bearings for Linear Motion:

Nema-23 18.9Kgcm Stepper Motors:

20mm Shafts , M10x1.5 Mild-steel & Stainless-steel Lead Screws:

Fasteners:

1st Prototype of Opto-Isolated Parallel Breakout Board – Sadly this prototype failed and didn’t make it ): [2nd Prototype in Progress (:]

2nd Prototype of DRV8825 based stepper motor driver – This too didn’t make it since it had a few bugs ): [3rd Prototype in Progress (:]

5mm Thick Aluminum Angles for reinforcement:

Anti-backlash Lead Nut Housing:

Lead Nut where it should be: When the Lead Screw rotates the Lead Nut moves back-n-forth i.e it converts the rotational motion of stepper motors into linear motion.

X-axis Base on which Z-axis base is mounted:

Y-axis Base:

Z-axis Base :

Z-axis Lead Screw Assembly:

Thrust Bearings to secure Lead Screws in place:

Z-axis Assembly:

Z-axis Stepper Motor:

Y-axis Stepper Motor:

X-axis Stepper Motor:

Y-axis Limit/Home Switches:

X-axis Limit/Home Switches:

Z-axis Limit/Home Switches:

CNC Base assembly:

The Gantry:

CNC almost complete! :

CNC on Wheels! :

The final setup for Test Runs:

Test Print(after calibration) Result:

And its Made in India. (:

DIY CNC – LM Bearings, Motor & Coupling Selection

Power_user_EX — Sun, 17 Mar 2013 13:36:59 +0000

This is DIY CNC Interval 2B – Linear Motion Bearings, Motor & Coupling Selection.

Linear Motion Bearings , Shafts and Support Blocks
For linear translation support I decided to go with 20mmm (dia.) Linear Motion Ball Bearings mounted on 20mm chrome shafts. Per axis 4 Linear Motion Bearings will be used.

Open Type Linear Motion Bearing:

Closed Type Linear Motion Bearing:

The Linear Motion Bearing Stock:

To support shafts I have got some Shaft End support blocks:

Shaft End Support Stock:

20mm Chrome Shafts:

Stepper Motors

I’ve also purchased 3x Nema-23 18.9 Kg-cm Torque Stepper motors which provides enough torque to mill metals like Aluminum given a proper lead screw is used.

Couplings
A Nema 23 Standard Stepper motor shaft has a diameter of 1/4″ i.e 6.35mm. On the other hand my Lead Screws are 10mm in diameter. Hence I wanted a coupling which can couple the 10mm lead screw with 6.35mm stepper shaft. Once such type of coupling was available on Ebay – HongKong but then I found a fabricator who could flexible shaft couplings at almost the same price. Within 5 days I got it fabricated from Excella electronics – Ghatkopar , Mumbai.

Misc

Also got a sample of pillow block bearing which I had originally thought of using as end support for Lead Screw. This might or might not go into the actual CNC.

Interval 1 Post is @ Here
Interval 2A Post is @ Here

DIY Lead Screw End support for CNC

Power_user_EX — Sun, 17 Mar 2013 12:08:35 +0000

Introduction
Hey Folks! Lets make our own Lead Screw End support for our DIY CNCs! I’ll let images do all the talking since therez nothing much to write about xD.

So this was my situation : I was having Bearings with ID=10mm , OD=19mm and same kind Flange type bearing with Flange dia=21mm along with a 20mm Shaft End Support. Using those bearings one could easily convert a ‘Shaft End Support’ into a ‘Lead Screw End Support’. Lets see how.

Parts required:
1) 20mm Shaft End Support Block :

2) Normal + Flange type Bearings :

3) Paper Tape :

4) Small Hammer

Building Steps:
Step 1 : Stack the normal bearing over the flange type bearing. Start ‘rolling’ the paper tape over it. Keep on checking the Outer diameter after each full/half revolution. It must not go beyond the Shaft end support’s ID which is 20mm in our case.

Step 2 : Once the Outer diameter barely reaches 20mm its time to cut the tape. Trim the excess tape.

Step 3 : Its time to put the bearing stack into Shaft end support’s 20mm slot. Apply pressure using thumbs to force it in. When its mid-way inside u’ll need a small hammer to force it completely in. If it still wont go inside then a peel of a small section of the paper tape and try again. When its completely inside the slot lock it using Shaft end support’s lock screws.

And thats it! We’r Done!

Devil May Cry Review

Abhisek Sethi ( Aka : groovypanda ) — Wed, 20 Feb 2013 06:59:02 +0000

Introduction

Hack and Slash is the only genre in which PC is deprived of quality games. Consoles have some excellent hack and slash titles like God of war, bayonetta, Ninja Gaiden , Heavenly swords, Onimusha etc. But when it comes to PC the only worth mentioning title till date is – Devil May Cry (and Darksiders too but still for me DMC3 > Darksiders). Though the 1st 2 games of the title were also console exclusive and the third title was a bad port still many PC gamers have loved and enjoyed the game as well as being in the boots of the protag DANTE and are playing it till date (me being one of them). DMC3 was very messy on a controller and keyboard controls weren’t great either but still many gamers loving it is the proof enough for a good game. DMC4 was a mild disappointment for many but still much better on PC with a full and proper controller support.

Then after 2 years of the release of DMC4 came the announcement of Devil May Cry aka DmC. The promo thus released on E3 didnt only irk many of the old and hardcore fans but also earned Ninja Theory lot of hatred from the lifelong fans of the series. Facing all of that the 1st thing Ninja Theory did was to change the face model of the new Dante and release interviews which talked about how this game was nt a sequel but more of a prequel/origin game. Undoubtedly Ninja Theory & DmC was surrounded with loads of critcism throughout the year since the day the new game’s trailer was released to the day the game released and somewhat even after that. No doubts its the most controversial and yet 1st major game release of the year 2013 on PC. The game released for consoles on 15th of January and as a common practice now 10 days later for the PC.

Now before i begin the review i would just like to share that i am a HUGE fan of the series and the protag DANTE and in the following review i wont only elaborate about the new game but also compare it to the older games of the franchise.

GSkill Phoenix III SSD review

Sumon Pathak — Thu, 14 Feb 2013 18:23:58 +0000

Introduction

Among all PC components none gives more sense of performance than the SSD.The general snappiness of the system brings a smile and satisfaction to anyone.

Today we have such a component on the test bench.presenting the Phoenix III SSD from the stable of Gskill.

The SSD was on my radar for a long time and finally i got it in my hands to play..so lets see how good it is..