What are some of the good versioning systems for hardware projects? Is there equivalents of Google Code, CVS and SVN? Are such version control systems suitable for hardware projects involving PCB files, schematics..(even firmware code)?
I've used Subversion with Altium before. It worked successfully, but at the time the lack of a diff tool made it less useful than version control is with code. I still think it was worth doing, even without diff capability.
For firmware, Subversion or Git are both great. If you haven't used Git before, try Subversion first (even though it will make learning Git later harder).
Altium has recently introduced a diff tool for schematics and PCBs, so I expect that Subversion would now be great, modulo the usual insanity that EDA vendors manage to build into their products.
I've been meaning to try this out with the new diff tool; if I do, I'll try to remember to post a link to the repo here as an example.
I tried this out, and I have to say that I'm a little underwhelmed with the Altium diff tool. It's functional, but the changes between board revs are substantial enough that it's not that useful, at least for me. Having seen this, I've decided to forget about the diff tool and just use Github. Here's the repo if you're interested: https://github.com/rascalmicro/pcb
I use Google Code to host Super OSD, an electronics project of mine.
I exclusively use the gEDA suite to manage my schematics and PCBs. Usefully, gEDA produces text files (which are mostly human readable, although it's difficult to interpret them) for the schematics, instead of binary blobs, like Eagle. For example, this is a diff between two schematics, one about 5 days old and one I just pushed. It's not particularly useful as you can't actually see much changes in text files, but it can show relative change - i.e. massive rework, vs. single component change - and it does let you go back to prior versions.
The trick is to use something that works well with binaries. If you are using binaries a lot and sharing with others, it might be beneficial to implement a locking mechanism on those binary files. We've run into lots of issues with using Subversion with binary files and sharing with others that arose due to a lack of locking semantics and over-writing/merging binary files together. Adding a locking mechanism on those files removes human error in communication on who edited/changed the binary file.
If you haven't used version control before, I recommend reading up on the different ways they work, and select one to meet your needs that you and/or your team can be comfortable with. Distributed version control systems provide many benefits over client-server systems, but tend to be more complicated to work with.
I've used Subversion with Altium before.
I do use SVN with Altium integration for schematic capture: it works well. I must say that the diff viewer is better than having nothing, because my SchDoc files are binary, ie impossible to compare otherwise! I use the SVN client integrated in Altium Designer in parallel with TortoiseSVN with no problem. Altium's client is a bit limited in terms of SVN features. I do my "tags" with Tortoise.
My opinion is based on Altium Designer 10 build 27009, and version 13.1 build 27559.
I was at the Maker Faire in San Mateo this past weekend and met some reps from a new (to me) company called Up-Verter. They are basically building an electrical CAD tool that runs in "the cloud" (i.e. in your browser) and is conceptually built around collaboration, so should deal with merge/diff and the usual versioning stuff.
I haven't tried it yet, and it looks a little bit green still (don't think you can actually do pcb layout yet, just schematics), but it's kind of intriguing. They claimed they could import Eagle files, which is a plus.
I also talked to the Eagle reps at the Element 14 tent, and they indicated that they are moving to an XML format, which is kind of a big step toward making versioning of schematics and layout more plausible... all interesting advancements on this front!
This is indeed a very good question. Since FPGAs fall into the category of "hardware", you might be interested in a version-control friendly project structure I propose for FPGA projects:
I think the ideas and concepts could easily be applies to other hardware projects, and in general. (Comments on this proposal are very welcome, btw.)
You should try Boar. It is designed ground-up to handle huge files and repositories. 100 GB or more of binary data is no problem.
I'd just like to add a link to HgInit, an excellent introduction to Mercurial if you decide to go that route. Personally I use Git, but they're very similar in terms of architecture (both are distributed version control systems). The distributed nature of them makes them great for working in well, "distributed" teams. :)
OpenPLM seems to offer some aspects of what you are looking for although it does not seem to be in active development (http://www.openplm.org/trac/discussion/topic/93).
Maybe take a look at https://discuss.erpnext.com/t/erpnext-git-github-for-open-source-hardware-call-for-beta-user-s/18006 ("ERPNext: Git / Github for Open Source Hardware – Call For Beta User(s)")
This is worth thinking about for any ascii descriptions of hardware. Once a human readable description for the hardware is adopted any modern revision control system (RCS) works pretty well. Circuit layouts are typically fully described by Gerber files, UML describes other parts, which are fully ascii descriptions. Less standard ascii formats exist for schematics, mechanical layout and so on (KiCAD for instance).
Adoption is more a practical issue, it requires a recognized requirement for good revision control, including a meaningful diff. Which also often means giving up Word, Excel, PowerPoint, etc. A very difficult argument against managers and MBAs, but arguably regulated industries like Medical Devices, Aviation and Military already require good revision control.
As others have pointed out, most modern RCS will revision control binary files, which is very useful for archiving and identifying versions - but any electronic document management system (EDMS), Agile for instance, can assign a revision number to an arbitrary binary. Boring.
Although it is not free, and is hardly bug free, Altium vault does a sterling job; I can roll back to any commit point easily (just as any VCS should do) very easily.
In this area, Altium is way ahead of the premium (Mentor and Cadence) tools.
I do not work for Altium but this tool, despite the current issues, make complete hardware versioning very simple.
For Firmware part I use git to manage versioning, and use git information in naming output hex file and as hard-coded variables also inside the code to show for users in startup messages though the debugging console. I wrote a blog post about it "How to Use GIT to Manage Firmware Versions"