Google Summer of Code Ideas
| Implement a PCB autorouter |
Besides circuit simulation, one of the major goals of the
Agar-EDA
project is an efficient, tightly-integrated PCB design system.
Component models in Agar-EDA can be associated with physical packages.
A comprehensive library of accurate 3D models for various packages and
connectors is necessary to achieve this goal, and we are working on a
simple sketch-based CAD editor which we will bundle with Agar-EDA, allowing
users who are not necessarily familiar with 3D design tools to create new
packages easily.
This project consists of implementing the most crucial component of the
PCB design tool, the autorouter. The autorouter looks at the topology of
the circuit and generates the copper traces which will connect the components.
Generating optimal traces is an intractable problem, so approximation
algorithms must be used, and the structure of the input is restricted
(for instance, the traces must fit onto a grid of a user-specified size).
An optional goal of this project would be an autoplacer, which would also
use approximation algorithms to generate some placement of the components
for a given grid and board size. The user could mark the position of
certain components as variable, allowing the autorouter to change the
position of those components to improve its chances of finding a solution.
- Language: C / C++ / Objective C
- Related API: Agar (for GUI)
- Related API: Agar-EDA
|
| Implement 3D assemblies in sketch-based CAD system |
FreeSG (scene graph / math / computational
geometry library) is well-suited for use in CAD applications since it
implements features such as dimensioned 2D sketching and the solving of
geometrical constraint systems, which is probably the most critical
component of modern CAD applications.
Besides being a new area of research in itself, geometrical constraint
solving is a fascinating topic for students interested in computational
geometry.
The immediate project would focus mainly on basic capabilities as required
for modeling, for example, mechanical parts, using sketch-based techniques.
cadtools already implements
most of the GUI code involved, and FreeSG already implements 2D sketching.
An important aspect of this project would be the generalization of the
constraint solving system in 3D to accomodate assemblies of parts. This
involves graph theory, computational geometry, numerical analysis and a
bit of user-interface design.
Note that FreeSG uses feature-based boundary representation (BREP) modeling.
Students who are more comfortable with the CSG approach may be interested in
BRL-CAD (who is also participating in GSoC).
- Language: C, C++, Objective C, others
- Related API: FreeSG
- Related API: Agar
|
| Extend a mixed-signal circuit simulator to support non-linear devices |
An easy-to-use open-source simulator fast enough to work in real-time to
a reasonable accuracy.
A few years ago we've started a project we temporarily called
Agar-EDA (as it uses the
Agar GUI).
It provides a graphical electronic circuit editor and a simulator written
entirely from scratch (not based on SPICE). It is designed in such a way that
it can be combined with other packages in order to simulate complete systems.
Unfortunately we lacked the resources to continue the project and it is
currently mostly unmaintained.
The circuit editor and the GUI are already complete for the most part. Some
very simple models and a virtual oscilloscope are already implemented.
At this time, the simulator implements the basic
Modified Nodal Analysis (MNA),
and does not yet support non-linear devices such as diodes and transistors.
This would be an interesting project for students in electrical engineering,
numerical analysis and linear algebra (e.g., solving of large,
sparse matrices is involved).
To achieve this goal, knowledge of numerical integration techniques is
probably more important than electrical engineering skills, but experience
with electronics is always a plus.
Within the scope of GSoC, our (admittedly ambitious) goal would be to end
up with a working simulation model for the 555 timer (ignoring parasitic
effects), since the complexity of the 555 circuit provides an excellent
benchmark for a circuit simulator.
- Language: C / C++ / Objective C
- Related API: Agar (for GUI)
|
| Improve motion control system |
machctl is a control system
for servo motors and steppers. It can be used to control
machine-tools and robots by generating "step" and "direction" signals.
It is similar in functionality to
EMC/Linux,
but it uses a very different design involving kernel code in order to
achieve much higher frequencies using cheaper, more compact hardware (e.g.,
Soekris boards provide an ideal
platform for machctl).
Currently, machctl only understands its own program format. It would be
useful to implement a GCODE (RS274D) interpreter into machctld (the
user-land part of the daemon).
Students interested in Computer-Aided Manufacturing might also find
it interesting to improve other aspects of machctl, such as adding new
interpolation modes and finding ways to reduce program sizes.
Another feature lacking in machctl is the ability to alter speeds and
programs in real-time (but due to the design of machctl, that requires a
part hardware solution, which is more of an electrical engineering problem).
- Language: C
- Userland part of the software is standalone
- Working on kernel part of the software involves some knowledge
in kernel programming. Currently, only an implementation for
BSD-style kernels (OpenBSD,
NetBSD,
FreeBSD) exists.
A port to Linux would be an interesting project as well.
|
| Port constraint-solving sketcher to touch screen devices |
Engineers and machinists constantly have to work with technical drawings,
and it can be inconvenient (especially when dimensioning existing parts)
to use an ordinary workstation.
The 2D sketcher
FreeSG uses the
Agar GUI, which would be portable to touch
screen devices (such as the iPod touch, for which the SDK has been released
recently).
Constraint-solving sketchers are designed to reduce the amount of input
device manipulations to a minimum and so would be suitable for use on
touch-screen devices.
- Language: C / C++ / Objective C
- Related API: Agar
- Related API: FreeSG
|
| Implement global file system event notifications in *BSD |
This is for students interested in kernel hacking, more specifically
filesystems.
Currently, there is no equivalent of the Linux
Inotify
mechanism under FreeBSD/NetBSD/OpenBSD.
These systems provide the kqueue(3) mechanism, but it is designed to
monitor specific vnodes, not an entire filesystem.
One major problem associated with deploying redundant, replicated arrays of
*BSD servers is the replication of filesystems where the pattern of
file creation and deletion is unpredictable. Currently, the only solution
to this problem is a complete filesystem scan.
The most efficient solution to this problem is a system to catch filesystem
events.
This system has to be
implemented in the kernel side, and it could be made to communicate the
changes to a user-land process (e.g., using a character-special device).
This process could then perform the actual replication based on this
data, either in real time or periodically using a queue.
|
|
Students retain copyright of their own code. All sources files should include
license information. Our preferences are the new BSD license, the ISC license
or the MIT license.
|
|
You can contact us using this form or by e-mail at
gsoc at hypertriton.com.
We have a small
mailing list
for general developer discussion, and
there are also mailing lists specific to our different projects.
Some of us also lurk on the irc.freenode.net channel
#agar, and the SILC channel csoft-tech on silc.csoft.net.
There is a web interface to the IRC channel
here.
If you connect to Freenode for the first time,
register and identify your nickname.
|
|
