yeah, i like that red color alot.  i think it looks really nice.

what about a bright red color (similar to the background on the freeduino site) and white silkscreen.  i think that would look gorgeous.

The script itself is very basic.  Its just a bash script that calls eagle, ps2pdf, and povray if you set it up to do 3D rendering (i highly recommend this... if you haven't looked at the rendering, its AMAZING!) If eagle runs from the command line on Macs, then yes.  I think you might need to make a symbolic link from ps2pdf to pstopdf (dunno why they renamed it on osx)  I've been running it from Linux and it works great.

I am n00b to 3D rendering with Eagle.  Does it render povray for any component that you put in your board or you need some sort of 3D library?  I tried 3D rendering in KiCad, but the lack of 3D libraries is a limitation... it looks pretty amazing, though.

eagle3d comes with a large library of parts, and can substitute generic parts for chips with a standard housing.  it will even put your chip name on the generic housing.  its pretty neat actually.  it also allows you to add description data in the schematic that automates the process a little bit more.  eagle3d is actually really well developed and is very powerful.

it might require a little bit more work, but the image generated is pretty awesome looking.  the pictures in the zip files above are just the first run.  i opened my schematic, ran the ulp with default settings, then ran povray.  it missed a couple parts, but overall it did a great job.

I seriously hope you consider using this script.  Having the GERBER scripts built automatically reduces the potential for human error.  Even if it is only you ordering boards from those files, if it prevents you from accidentally wasting $100+ because you forgot one little step, then it would be worth it.

Using a beta (or alpha) software to generate production Gerber files?  Hmmm, you must be an excellent programmer  

look at it this way: how do you want your production files generated?

* by hand, where every time you generate them there is the potential for making a mistake?

or

* from a script, that has a set process, is repeatable, can be looked at and verified by others?

sure, the script might have a bug or two in it, but its easy to look at the gerber files and verify that they are correct.  also, the script is dead simple.  here is the part that generates gerbers and the drill file:  if you spot any errors, please let me know!

#create our gerber files!
echo "Creating Gerber Files..."
eagle -X -N -d GERBER_RS274X -o "$TO_DIR/gerber/ComponentTraces.pho" $BOARD/*.brd Top Pads Vias
eagle -X -N -d GERBER_RS274X -o "$TO_DIR/gerber/CopperTraces.pho" $BOARD/*.brd Bottom Pads Vias
eagle -X -N -d GERBER_RS274X -o "$TO_DIR/gerber/SolderMaskComponent.pho" $BOARD/*.brd tStop
eagle -X -N -d GERBER_RS274X -o "$TO_DIR/gerber/SolderMaskCopper.pho" $BOARD/*.brd bStop
eagle -X -N -d GERBER_RS274X -o "$TO_DIR/gerber/SilkScreen.pho" $BOARD/*.brd Dimension tPlace tDocu

# Drill data for NC drill st.
# warning : eagle takes path of -R option from input file directory.
eagle -X -N -d EXCELLON -E -0.02 -E 0.1 -R ${BOARD}.drl -o $TO_DIR/gerber/${BOARD}.drd ${BOARD}/*.brd Drills Holes
cp $BOARD/*.drl $TO_DIR/gerber

Your request is like asking Linus Torvald why he does not create a Linus Distro.  He doesn't have the time nor the monetary interest to do it.  I am sure he is pretty busy keeping an eye on the Kernel and its evolution.

Well, the Linux example is a bit of a stretch, but still fairly accurate.  However, note that the kernel source is also distributed with a makefile for building it.

Know you can enjoy free binary distribution of open software, because the platform is more uniform and there are a lot of people contributing to the open source projects.  In the beginning times of open source, you only had source distribution, and you put your effort to make it work, port it to different platforms, etc.  This is community work.

The Freeduino Team is working on designing an open Arduino compatible board, so anyone can enjoy it, as you probably enjoy Linux.  Their mission is not to make everybody's life easier, creating the Gerber files, like Linus does not work for the community creating the Linus Distro.  There are companies like RedHat, Suse and many others adding to the engineering and commercial side of the equation, as you should be contributing with new boards, generating and publishing the Gerber files, etc, if you really like Freeduino.  The team created gerber files so they can prototype the original Freeduino schematics, but the Team does not want to impose any particular board design.  With the contributions of many, we will get sooner to SuperFreeduino, don't you think?

Well, that is what i was trying to do here... contribute.  I wrote a script, and it works.  I use it as part of another open source project, and it has made my life easier.  I thought you guys might be interested in that as well.  I'd say I'm a part of the community here and I want to help!

Why isnt the mission to make peoples lives easier?  I mean if you really want to make this more confusing by having one place where you get the source and then another place to get the gerbers.  This is where the linux analogy breaks down.  While there are variants, the variants are really all about board layout.  Since you're distributing the board layout source, you might as well distribute the generated files from it.  Would you distribute the schematic but not the layout?  Since you guys aren't just doing the raw source (schematic) but the compiled object (real boards) then you are creating both source *and* variant.

The Freeduino team really enjoys CONTRIBUTIONS, like your comment about PDFs, as not everybody has access (and knowledge) to use Eagle.  But Gerber files?  How many Arduino users know what Gerber is?  Do they care?

Well, the type of people that are interested in the Eagle files for the Freeduino board, definitely!  Even if you do know how to make the Gerber files manually, why would you want to?  If there is a way to automate it, and get extra bonus features as well, why not do it?  You know you can manually type gcc in the command line, but why would you want to when there is make?  At the very least it would be nice to include the script in the distribution to automate creation of gerber files as a convenience.  Also, what if there is someone who doesn't know a whole lot about the eagle files, but would like to order 200 boards for his school.  Being able to take a zip file, email it to a manufacturer and have them make it would help that person tremendously.

I'm sorry if this is rubbing you guys the wrong way, but I seriously just want to help.  Please give the idea a couple days to sink in and maybe you'll come around to it.

Well, my gut feeling is that the production files, especially the exact GERBER files you used to get the boards manufactured should be released.  Having the source Eagle files is nice, but why not distribute the binaries as well?  In the time it takes you to reply to this, you could have this script up and running.  So there's one vote for distributing them.

Even if the boards are not easily made at home, it would still make sense to use the script to generate a PDF of the circuit schematic.  For someone who just wants to look at the circuit for whatever reasons, PDF is a much simpler option. Also, if there ever is a Freeduino that is designed for home etching, then generating these files automatically would be awesome.

As for running ULP's, there has to be a way.  I looked through the man page for Eagle, but I couldn't really find anything.  Adding that ability in would seriously up the potential for awesome on this build script.  Being able to run an arbitrary ULP would allow us to automate the Eagle3d stuff, drill aid, etc.  If anyone has experience and/or success with that... I'd love to hear from you.

I love what you're doing, and its nice to see the Arduino source files truly be opened up. Coming from a programming background, I know firsthand that there are real, useful reasons for a build system, and it definitely makes sense to apply them to electronic design tools if you can.  I seriously hope you consider using this script.  Having the GERBER scripts built automatically reduces the potential for human error.  Even if it is only you ordering boards from those files, if it prevents you from accidentally wasting $100+ because you forgot one little step, then it would be worth it.

Hmm.  You can take it or leave it, but it sure would seem weird if the Freeduino guys didn't want a simple solution for packaging up the files for release... isn't that the whole reason you forked?  I don't know about you, but working with open source projects that are source-only is a NIGHTMARE.

The script itself is very basic.  Its just a bash script that calls eagle, ps2pdf, and povray if you set it up to do 3D rendering (i highly recommend this... if you haven't looked at the rendering, its AMAZING!) If eagle runs from the command line on Macs, then yes.  I think you might need to make a symbolic link from ps2pdf to pstopdf (dunno why they renamed it on osx)  I've been running it from Linux and it works great.

As for generating the gerber files, its *very* simple to tweak what layers get printed.  I'm sort of a n00b when it comes to Eagle, so I don't fully understand which silkscreen layers are needed.  I think this is actually an argument *for* distributing a binary... ideally an expert will have configured the 'build' settings so you're getting a known good file.  Of course a disclaimer stating that you should double check with your manufacturer before ordering boards would be a fantastic, and common sense idea.

Personally, I don't think the gerbers are the main selling point of this script... rather the automatic generation of PDF files (including schematic), as well as a snazzy 3D rendering of the board make it a very nice way of generating files for a release.  You could also easily modify it to add in your README, documentation, license, etc. If you prefer to do all by hand, then be my guest.

Hey,

I love how you guys are releasing all the design files.  I feel that is truly the way open source should be.  After all, the electronic files *are* the source for the real, physical objects.

Since you guys are using Eagle, you should really check out this script I wrote for the RepRap eagle files: https://reprap.svn.sourceforge.net/svnroot/reprap/trunk/reprap/electronics/eagle_package_release

Its really handy for creating .zip files for release.  Here's a short list of what it does:

* automatically creates GERBER and Excellon drill files
* automatically creates PDF files of board + schematics
* copies in eagle source files
* will create a 3D rendering (and soon flyover movie) of your board using Eagle3D: http://www.matwei.de/doku.php?id=en:eagle3d:eagle3d
* zips all those files into a nice, tidy .zip file you can post wherever.  see an example here: http://www.rrrf.org/dump/reprap-freeduino-dual-motor-driver-2007-10-03.zip

You have to run the eagle3D ulp before the script if you've made a change to the board, but its a 30 second process.  i'm working on automating it, but i dont know if its possible to run a .ulp from the command line.

Other than that, the release process is totally automated.  You run a command like this: ./eagle_package_release freeduino 1.16 and it would create a file like freeduino-v1.16.zip containing all the gerbers, pdfs, renders, and source files.  It reduces the chance of error in creating various file, as well as saving you tons of time to work on innovation rather than doing mundane stuff.

Yay!

Hey Guys,

I'm the creator of the Sanguino, and I'd like to clarify a few things:

by 'compatible with arduino', we mean that the Sanguino is:

* programmable with the Arduino software
* implements all of the core arduino functionality (ie: everything on http://arduino.cc/en/Reference/HomePage)

it's my goal to keep the Sanguino as compatible as possible with non-official Arduino libraries, but as you may imagine it is quite a bit of work to ensure that they all stay synchronized.  i'll try to make a note of this on the sanguino website to avoid confusion.

the reason for creating the sanguino, as well as my day to day work is hacking on RepRap, which keeps me really busy.  i'll try and dig into the library code that is having a problem here and try to figure stuff out, but it may take me a little bit to get up to speed with the library and figure out whats wrong.

in the meantime, i'm sending mem a Sanguino kit in hopes that the creator of the library will be able to easily spot and fix the problem.

unfortunately, with low level hardware access happening, you tend to lose compatibility between different microcontrollers. all of the pin to port mappings are published:  you can either check out the schematic or look at the code in the sanguino 'core' folder.  Both are freely available.

good luck with the LCD, and I hope we get this fixed asap.

Hey rknaik,

just to clarify:  the computer is only needed to load your code on the arduino.  once you load it, you can use the Arduino without a computer.  so if you make a program for your Arduino that does the GPS + SMS stuff and then put it into a car alone, it should work just fine.  you'll need to supply it with power, but that is pretty easy.

It was definitely me being a n00b.  If anyone else has the same problem when working on a board, just remember to use the 'Board -> Layout' button in the top.  Otherwise it gets mad if you alt+tab, or whatnot.  luckily Eagle makes 400 backups, so it was pretty easy to recover from.

Hey All,

I'm designing a board in Eagle.  As I'm laying out the PCB, I realized I needed to make a couple small changes.  I made the changes in the schematic, but now the layout software says that the boards are different, and no 'back annotation' is possible.  I've used Kicad before, and it has this feature where you can re-read the netlist, and it will add any modules that are missing... then all you have to do is delete the old ones.

Is there a way to do something similar?  I really dont want to have to re-lay out the entire pcb every time i just want to make a change to the schematic.  For a 'professional grade' piece of software like Eagle, you'd think it would be smarter than this.  Even Kicad, which isn't exactly the best can handle this.

~Zach

i agree.  the board i suggested is pretty standard:  pwm connected to a TIP120.  its based on the circuit on tom igoes site.  of course you could probably use it as a digital on/off switch for dc current too.

this would be a perfect application for one of the boards we developed for the RepRap project: http://www.reprap.org/bin/view/Main/PWM_Driver_1_0

its a board that takes a PWM input, and powers an output.  to test it, i actually hooked it up to some little case fans (watch the video at the bottom of the page) as an added bonus, it gets its power from a hard drive power connector... quite simple if you already have a computer right there.  this board has separate channels on it... so you could control 3 different fans.

i'm also about ready to order a bunch of simple temp sensor boards, but they're not quite ready. temp sensing is pretty easy with a thermistor + a few components.

plus, the whole deal is cheap and open source.  yay!