My logbook
Friday, 17 June 2011
I found out after testing that 2 stepper drivers don't work anymore. One worked until I pull the connector to the stepper motor from the stepper driver, and it burned in front of my eyes.
I milled 2 more boards and stuffed one stepper driver, and Marina stuffed the other one. I tested them and they worked. We ordered more components to make one more stepper driver.
The Arduino MC-NOVE from Fablab Amsterdam does not work anymore, so we ordered a replacement.
After damaging 3 stepper drivers and one Arduino board I made a procedure for testing:
- connect first the stepper motor to the stepper driver
- then connect the stepper driver to the power supply
- then connect the ground first, then dir and step connections to Arduino board (already connected to computer via USB cable)
- then run the program gctrl
Still a few extra notes:
- stop always the program (gctrl) before disconnecting any connection, especially the stepper motor's connector
- double check that the power supply connector is connected correctly to the stepper driver (not to the other connector for the stepper motor)
- disconnect connections to the Arduino first, before disconnect anything else
Wednesday, 15 June 2011
I connected the power supply to the power outlet without realizing that it came from US. It blew up because the select switch was set to 110V. I bought another one with the same spec and that one works (I made sure that the select switch was set to 220V before connecting it to the power outlet).
Somehow I couldn't reproduce the test I did on Friday with gctrl. Probably the output ports of the Arduino board (MC-NOVE) were damaged last Friday when I by accident swapped the connectors of the stepper driver (connector of the stepper motor to the input and output connector and vice versa). After I tried to changed the output ports of the stepper from PORT B & PORT A, I couldn't use Arduino environtment anymore to program the board.
Friday, 10 June 2011
Together with Marina, I tested the stepper driver boards. First we uploaded grbl to Arduino Dumienolove from Fablab Amsterdam. Then with gctrl, a Processing sketch, we tested the the stepper driver one by one. Two stepper driver boards and two motors work as expected.
Wednesday, 8 June 2011
Assembled MTM Snap together with Marina. We had to remake 3 parts because the first time we milled them about a month ago, we didn't drill holes and made pocket in them. After making the profiles for drilling, pocketing, and cutting (inside and outside) with Partworks, we milled the 3 parts.
After that we assembled all the HDPA parts and mounting the 3 stepper motors. We hadn't figured out how to fix the steel bars yet.
Wednesday, 25 May 2011
- I made a rubber mold for plastic lense I needed for my final project.
There were several guest speakers:
Derek ... from Ponoko
- laser-cutting
- 3D printing
- ... (?)
- shopbotting
- distributed networking system
- personal factory application
Dhananjay Gadre (COEP Fablab)
- Tiny AVR Microcontroller Projecs for Evil Genius
Mark ... (Makershed)
... (Fablab Manchester) over Sustainability
... on Patent
Peter on business platform, Bas on Open Design & MakeMe platform
Pete from Shapeways
Venture Financing
- elinemedia.com
- venturehacks.com/angel.com
- Found a webpage of a Fablab Academy 2009-2010 student from Providence
Monday, 23 May 2011
- Milled PCB for APA IO and APA gateway
Friday, 6 May 2011
I stuffed the hello bus boards (one bridge and 2 nodes). After I programmed it succesfully with FabISP (change node 0 in the code for the bridge, node 1 and 2 for the other nodes) I found I didn't get any response from the bridge and the nodes until I realized that Neil had modified term.py, so I should type on the GUI screen and not on the terminal. The nodes blink the LEDs when a character is typed on the keyboard, and when I type 0 the bridge would blink twice, while the other nodes blink once. And similarly when I type 1 or 2 the corresponding node would blink twice, while the rest blink only once.
I milled 3 stepper driver boards for MTM Snap.
Wednesday, 13 April 2011
(Week 11: output devices)
I made a program with pygame library to show different 2 different images with the hello light sensor board. When the light sensor is covered a new moon image will be shown, and when the light sensor gets enough light it will show a sun image.
Neil told us about different output devices:
Safety:
- 1 mA is OK, 10 mA mucle contracts, 100 mA you can die (electricity inside body)
- higher frequence is dangerous for body surface, lower frequency is dangerous for internal organs
- use protection diode to control the direction of the electricity on the board [add schematic]
- use shroud header to overcome wrong connection (only one way to connect instead of four) [add illustration]
- pin 1 of the headers on Neil's board has a circle instead of box shape [add illustration]
Techniques:
- PWM: a frequency of 1 nano second, eyes can detect blinking up to 1 milli second
- microcontroller can sink and source up to 50mA
RGB LED:
- PWM with hardware (set a register with a value; works with a special pin)
- PWM with software with any pin (like the example program of the hello board)
LED array:
- current limiting resistor [add illustration]
- Charlie plexing for controlling more LEDs that number of output pins (remove diagonal LEDs)
LCD display:
- Hitachi's microcontroller has a complex protocol
Video output (Neil's favourite):
- use RS 170 (?)
- use DAC
- [add schematic]
- the microcontroller is busy doing the scanline, there is a bit for doing other thing during sync
speaker:
- not for high fidelity
[missed this part: ~16:05]
- N mosfet
- use PWM for changing amplitude
Note: DAC is not used for sound reproduction in common practice
Monday, 11 April 2011
Helped Marina troubleshoot her board. I found out that all the hello board sensors have a high voltage of 5V (except sound sensor board that has 3V of high voltage) and low voltage of 0V. Her board sends signal of high voltage of 5V and low voltage of 2.5V. Another difference is the smallest signal block width: all the hello sensor boards sends signal in blocks of 100 microseconds, from Marina's board: +/- 35 microseconds.
Rather than troubleshoot the light sensor board that does not work, I decided to make a new one: milled it, stuffed it, programmed it, and this time it works! I get data!
Friday, 8 April 2011
I tested the connection between the programs (Python scripts) and the hello sensor boards. All works except the light sensor, and I don't know why (I re-programmed that board to make sure, but it still does not work. I tested the Python script with other sensor boards, and it works too. It seems no data comes out from the board). It could be because I used different phototransistor for that board.
Later, Marina called Blair in Detroit. He told us to use rx.py program to check if the data is coming in from the boards and also on how to use osciloscope: black scope from channel 1 is connected to ground on the board, and the red scope to RX port of the FTDI serial and set the time division to around 25 micro seconds, and voltage to about 2V. I noticed with rx.py that the light sensor indeed sends data that probably the framing sequence. Marina's board does not send data at all to rx.py.
Notices that Goof was scanning a key using Roland Modela with Dr. Picza.
programming languages:
- The C book (gbdirect.co.uk))
- Java compiles bytecodes that run on JVM
- Flex (Flash derivatives)
- Processing does sound & graphics (export to Java), Wiring, Arduino
- LabView, Max, Pd (used for Fablab Amsterdam's soccer table), Scratch, Simulink
- Python
interfaces:
- RS 232, pySerial (Python binding)
- USART
- bit-banging / bit-bang(?) mode
- FTDI (Scottish company) makes chipset for USB (in the deepest level it is RS-232)
- libFTDI (other than serial) talks directly to the pins
- python-FTDI (Python binding)
- USB, pyUSB (python binding)
- V-USB: software implementation
- IrDA (infrared)
- GPIB
- VISA, pyVISA
Neil recommends bit-banging through FTDI
Note: FabISP implements In-Circuit Programming
user interface:
- TK (close related to Python), TKinter(?): for the same window look overall
- wxWidgets (looks native to platform used)
- Qt
- GTK
- Clutter (?)
3D graphics:
- OpenGL, GLUT(?), pyOpenGL (Python binding)
- Renderman, cykit (Python binding to graphics library including renderman)
- VTK(?)
multimedia:
- SDL
- PyGame (for making musical instrument)
- openFrameworks (?)
math:
- scipy, numpy, iPython(?)
- matploblib(?)
- R (statistics), Rpy
- SymPy (symbolic calculation)
Assignment:
- visualize & sonofy sensor data with so many possible ways
Note: octave is Matlab clone (Matlab is not a beautiful language/script)
Note from Tomas (Barcelona): pachube
Input Devices review:
Note from Neil:
- in case no data comes (as problem in Fablab Kenya): use osciloscope to measure the bit, then use OSCAR(?) register to calibrate the (internal) clock
- heartbeat sensor: using step sensor, use 20x gain multiplexer, set voltage to 1V --> the resolution is 1 microV
Neil against breadboard: a lot of capacitance in it, not good for sensitive sensor
I finished stuffing the boards (light, temperature & sound sensors) and programmed them with FabISP.
Monday, 4 April 2011
I stuffed the third FabISP I milled last Friday. It didn't work the first time I programmed it with another FabISP. But somehow after I programmed it with the firmware I downloaded, it works!
Note: I found out that the capacitor used (C1) is 1 micro F instead of 0.1 micro F in the schematic. But it works too!
I finished stuffing the step sensor board, and programmed it successfully. I milled the boards for the other sensors (light, temperature & sound).
Note: Alex gave me an idea to put the 4 sensor boards together on a piece of wood, and then made a switching mechanism to the FTDI serial cable.
Friday, 1 April 2011
The second FabISP does not work, so I milled the third one, and started stuffing it.
Wednesday, 30 March 2011
(Week 11: input devices)
I found out that part of the box I casted last week is ready. This time without bubble like the last one.
By following the instruction I found in Fablab tutorials, I tried to process the images I took last night. But it looks that ThreePhase, the Processing sketch I used, does not process the images correctly.
Neil explained various sensors:
- light sensor [add schematic sketch]
- synchronous detection for light sensor (?)
- temperature sensor: NTC (more sensitive, smaller range, not as well callibrated), RTD (more robust, wider range, better, calibrated) [add response ranges of NTC and RTD sensor]
- [add schematic to compare small differences in temperature sensor]
- step sensor (Neil's favorite sensor because you can make almost any sensor: position sensor/touchpad, tilt sensor, liquid/volume ensor, accelorometer)
Techniques for step sensor:
- undersampling [add schematic]: (1) sample on hold, (2) measure on different delays
- background subtraction
sound sensor: (not high fidelity)
- [add schematic for removing sound baseline]
- with op-am you can increase the gain 10-100x (built-in gain in microcontroller: 20x)
- sonar sensor: similar to sound sensor (40kHz and above)
- vibration sensor
- accelorometer
- motion sensor: warmth from body
- force sensor
- CMOS sensor ($10)
Assignment: design and make the sensor do something
Notes on previous week assignment:
- Zycor creates objects with bad sctructure property
- Tierney's FTM (or FDM?)
- Roland scanner
- Neil wants a low-cost 3D printer in fablab inventory that creates good structure like Dimension printer
- Tierney recommends CADspan
Neil's tip for making multilayer board:
- coper layer (with traces), then epoxy layer (with holes), solder tin on the whole, put another copper layer, and solder above the previous holes to melt the tin, and so on
- use gluegun to make base for the connectors
Friday, 25 March 2011
The cast was ready, and I got two parts of the box. The problem is one part had bubble in it, so I casted that part again (with the same mix like before, A:B = 1:1).
I got an inspiration from a known fractal object, Menger sponge. With Blender I made an inverse of the third iteration of Menger sponge, and sent the STL file to Tomas in Fablab Barcelona to be printed with the laser scanner there.
My FabISP fell to the floor last Wednesday, and since then it can not work again (the device is not detected by the computer), so I milled a PCB board for a new FabISP (I used 1/32" to cut the board, but the speed 1 was too fast, I got uneven edges), and stuffed the board (it was half finished when they closed the lab for the day).
The negative mold I casted last Monday is ready. The bottom part of the box is also ready, but I have problem with bubbles that makes the surface not smooth. I casted the two parts of the box again, this time with A:B = 1:1 (I expect a harder result).
I modified the program for hello serial board to switch between 5 different modes: (1) red, green & blue LEDs blinking together, (2) red LED blinking, (3) green LED blinking, (4) blue LED blinking, (5) turn off all LEDs.
Neil told us about
A. 3D scanning:
- 3D scanning --> point clouds --> triangulation (without holes)
- X-ray scanner (with tomography)
- 3D laser scanner (range finder)
- structured light (cheaper)
- Zycorp scanner with markers
- Zycam & Microsoft: Kinnect (phase shift modulation)
- Modela add-on scanner module
- manual scanning (important points)
- destructible scanning (?)
- milk scanning / swimming pool scan
Note: Neil recommended Python (a lot bindings to libraries, e.g. Numpy, pygame)
Assignment:
- 3D scan an object (extra credit: build 3D scanner)
B. 3D printing:
- FTM: ABS (low resolution)
- Tektronix: acrylic layer + wax layer (high resolution)
- Zycor: inkjet a binder layer, then inkjet water + glue. Messy process. But binder can be colored.
- Sintering (expensive): powder (polymer) is lasered
low cost:
- Chinese FTM 3D printer
- Makerbot
- reprap
- Fab@Home
- mtm.cba.mit.edu
- presentation assembly
- 3D circuits
- 1st generation: machine makes object
- 2nd generation: machine makes machine
- 3rd generation: digital material
- 4th generation: programmable material
Workflow:
- STL: ASCII (for debugging), binary. Normal is determined by right-hand rule. Simple and most common.
- OBJ
- 3DS
- VRML (color 3D object) & X3D
- volume/functional representation: CAD (python subset) --> MATH --> STL
Note: DXF is not recommended by Neil because: it is internal format from Autocad, originally for 2D, many many versions
Tools to see the 3D meshes:
- OpenSCAD = parametric
- MeshLAB: clean meshes before printing
- GLC
- VDK
Assignment:
- design object in centimeters & print it (send it until Friday to Tomas in Barcelona), extra credit for: scan --> edit --> print
Monday, 21 March 2011
The negative mold parts are ready, I took them out of the wax mold. And then mixed Smooth-On Clear Flex 50 (part B) with Smooth-On Crystal Clear Series (part A), A:B = 1:2, and put it in the negative mold. I made a mistake of letting the mix became to hard, and got some bubbles in the mold.
First I connected the FabISP programmer to the computer, and connected the hello board to the FabISP programmer. I then copied the hello.ftdi.44 C and assembler files, downloaded gavrasm and ran "make program-usbtiny" to compile/assemble the program and load it to the board. And with the hello board connected to the computer via USB FTDI serial cable (TTL-232R-5V) I borrowed from Bas, then tested it with minicom on Linux (I got the echo correctly from the board).
After that I copied the Makefile from hello FTDI (rename it to "Makefile", and changed the variable PROJECT to the name of my own project), and modified the C program I found (click on Microcontroller Programming) to the correct positions of LEDs and switch on my hello board.
Bas helped us, by explaining that:
- defining inputs and outputs in DDRA (or DDRB) register: 1 is output, 0 is input
- activate the pull-resistor in the microcontroller for input in PORTA (or PORTB) register (the input becomes 5V, otherwise it becomes a sort of antenna): 1 to activate
- reading input from PINA (or PINB) register: 0 if the switch is pressed, 1 otherwise.
- and sending output through PORTA (or PORTB) register: in my case, 1 is off and 0 is on.
- configure the board to use external crystal/resonator (20 MHz) instead of inaccurate internal crystal (8MHz) by first changing the fuse settings in the Makefile (in my case: "-U lfuse:w:0xee:m -U hfuse:w:0xdf:m -U efuse:w:0xff:m"), and then run "make program-usbtiny-fuse". The correct settings are found by using AVR Fuse calculator (choose: "Ext. Crystal Osc.: Frequency 8.0- MHz; Start-up time PWRDWN/RESET: 1K CK/14 CK + 0 ms; [CKSEL=1110 SUT=10]", and deactivate "Divide clock by 8 internally; [CKDIV8=0]", and then click "Apply feature settings").
Friday, 18 March 2011
I used Smooth-On PMC 121-30 Wet to cast the negative mold with the wax mold I milled last Wednesday. Alex referred me to the datasheet of this product which explains how to mix it (one part A for every part B, part B need to be pre-mixed first. Mixing part A & B for at least 3 minutes). I calculated how much mix I needed by calculating quickly the volume I needed to fill in (only the bounding box): 405 ml. At the end I used about 332 grams of the mix. The curing process needs about 16 hours to finish.
Note: For making the plastic object, I need first to spray the negative mold with Smooth-On Universal Mold Release (the datasheet), and then pour in the mix of Smooth-On Clear Flex 50 (datasheet) as part B and Smooth-On Crystal Clear Series (datasheet) as part A (A:B = 1:2). Alex said if I added more of part A I could make the material harder.
Then I spent sometime updating my webpages.
From Blender I exported the 3-D model I made to STL (the archief with Blender and STL files), then imported to PartWorks 3D. Here I documented all the settings I used with PartWorks 3D. I put the roughing and finishing toolpaths in the same file, and milled the mold parts with Shopbot (with 1/4" bottom).
Neil explained embedded programming to us. Some notes I made during the lecture:
- Harvard architecture (data & program are separate) which is used for embedded programming
- RISC processor that used for embedded programming
- 8-bit processor used for embedded programming
- Intel 8051, PIC, TI MSP (16-bit processor), ARM (32-bit), AVR
- AVR used because: (1) ..., (2) high performance, (3) low cost
- Octopart is the search engine for parts
- Parts can be bought at Digikey & Mouser
- AVR family processors have the same instruction set
- read AVR Tiny44 datasheet to understand how it works
- TQFP is the package of Tiny44
- clock ... [14:35]
- ISP = In System Programming, ICE = In Circuit Emulator(?)
- Edward Baafi made Arduino compatible board
- Firefly --> Grasshoper --> Rhino
- Modkit: Visual Programming (similar to Scratch)
- microcontroller: 100k - 1m transistors (common computer CPUs have billions transistors
Assignment:
- make the board does something in as many languages as possible
- (Extra) make Arduino board (Fabduino)
Last week assignment:
- hydrostone
- silicone rubber
- polyurethane + color + water
Monday, 14 March 2011
I finished the 3D model of the mold parts. Robert explained to me how I could import the STL with 3D model to PartWorks 3D and then mill the parts.
Note: Got information from Goof about the 3D scanner he wants to make. He used FreeFace to process the 3D images with structured lights, and then process the results with MeshLabs.
Friday, 11 March 2011
I drawed first the object I wanted to make (a small box with 2 parts), and the negative mold parts on paper. Then I drawed the 3-D model of the object parts and the negative mold with Blender.
- injection molding
- ...
- vacum forming
- ...
- silicone does not stick to plastic
- fiber fabric can be added as filler for strength
- food-safe rubber (for making candy, for example) can be ordered from Smoth-On
- hydrostone = fiber stone, fiber cement (10/15 minutes then it sets)
- wait a few minutes to let the bubbles up
- polyurethane & plastic: mix horizontally to avoid creating bubbles --> takes time until no structure is seen
- mixing until the liquid becomes like yoghurt
- MSDS safety
- Q: insertion what? (Mercedes)
- flat bottom for flat surface
- curve bottom for curvy vertical features
Generating toolpaths with:
- PartWorks (ShopBot)
- Modela Player (Modela)
- fab modules: (1) uses SVG with intensity for depth (black=bottom, white=top) then export as PNG, (2) use STL, (3) use .CAD (Neil's hardware description language)
composites: epoxy + carbon fiber (dangerous) [?]
- vacum bag (?)
Assignment:
- design a 3D mold (at least one part, two pars are better), make multiple copies, with polymer resin or hydrostone
Note:
- problem with Modela can be solved with StarTech USB to serial
Monday, 7 March 2011
Bas [add link] explained to me and Marina how to use Eagle for this module (electronics design). Things that I learned from him:
- A 45 degree trace turn is better than 90 degree one for high frequency circuit (that has something to do with electrons have difficulty turning on 90 degree bend.
- You could use a LED calculator for calculating the resistor needed for the LED.
- Use a grid of 0.025 inch for placing components and drawing traces on the board.
- Export the the board with traces in 500 dpi and monochrome.
- When GIMP is used, don't forget to flatten the image after moving it around (to create the edges for cutting the board).
I decided to change the LED with 3 LED's in one component [add part number and link], and found the schematic in fab.lbr.
I finished my electronics design.
Sunday, 6 March 2011
I found the hello board schematic, modified it by adding a LED and a switch, and did the routing manually. The schematic symbols I use are in ng.lbr and fab.lbr that I found at PCB design tutorial.
Friday, 4 March 2011
Saw the video of the last Wednesday's lecture and made some notes.
Marina [add link] told me about Rapid Prototyping expo in Veldhoven. We decided to skip the class, because we would like to learn more about 3D scanners from different vendors in the Expo (building a 3D scanner is our idea for final project).
Some interesting things I learned in the expo are: most 3D scanner products use structured lights. Some products (usually handheld or portable scanners) use circle patterns (that can be applied as stickers) as reference points. A handheld scanner uses differents specle patterns without reference points.
Besides 3D scanners, we also see 3D printers in the expo. Some use fluid (stereo lithography), other uses powder (metals or plastics) that is melted by laser. Other lies powder layer than glue after another.
Monday, 28 February 2011
I milled several joints to test if my design works. [Add photos]
Alex showed us how to use Shopbot.
Friday, 25 February 2011
I designed several joints and milled them to. [Add photos]
Robert, a trainee in the lab, showed me how to use Shopbot [Add the screen capture of Profile and Pocket settings of PartWorks].
At the end of the day I broke a mill head, because I forgot to turn on the spindle.
I finished soldering the FabISP programmer, tested all other programmers to program other FabISP programmers, and all work! Earlier, Nathan, a boy in the lab, found out why 3 out of 4 programmers didn't work. The resistor used was 1000 times bigger than in the design.
Neil told us how to mill with Shopbot.
Monday, 21 February 2011
Alex showed us how to solder the components to the PCB board.
Friday, 18 February 2011
Alex showed how to mill the PCB. I made one succesfully on first try!
- I used 1/64 for tracing, and 1/32 for cutting the board.
- PCB board used is 75 mm x 50 mm
cad.py settings for Modela: [add screenshot for clarity]
- z min: -0.010
- x min: 0.016, y min: 0.05
- speed: 4 (for tracing) and 0.5 (for cutting)
- tool diameter: 0.0156 (1/64 head), 0.0312 (1/32 head)
- Modela 10 mills, 1/1000 inch
- FR4 PCB: glass enforcement (destroy machines)
- FR1 is board type to use
- 17.5 micron = 0.5 ounce, 70 microns = 2 ounce
- advanced electonics: 4 layers (layers in the middle for ground & voltage)
- still: 6/7 layers
- 1.5
- soldering
- 700 F (what Neil uses)
- 1/5000 inch resolution
- David Willis' page [link to the page]
- fab modules: PNG to Modela/*.RML (traces in white, the rest in black)
- to other format: G-code
Vinyl cutter:
- 15/20 mills trace (similar resolution as milling machine)
fab modules:
- make use(?)
- make program
project assignment:
1. SJ1 & SJ2 connected to bootstrap the programmer
2. desolder SJ1 & SJ2.
500 ppi resolution for PCB milling
Sunday, 13 February 2011
I realized the problem I had with creating joints. Somehow Adobe Ilustrator (which I use to "print" drawings to laser cutter) cannot import Inkscape (which I use to create drawings) accurately. A 40 mm drawing is converted to 50 mm. Roberts told me to export to *.DFX from Inkscape and import it to Adobe Illustrator which preserves the original measurements.
I designed and cut a table (the first successful try!).
Notes:
- For 4 mm thick balsa wood I use speed=5 & power=100 for cutting, and speed=100 & power=50 for engraving (all with 400 ppi).
- I found out that text and inline features should be converted to path in Inkscape (otherwise you won't see it when you export it to *.DXF). The clone feature of Inkscape should also be disabled before an export to *.DXF.
Alex's suggestions:
- better joints (with chamfer)
- save materials by drawing the cuts next to each other without gaps [add illustration for clarity]
- roof for my castle construction kit
Friday, 11 February 2011
For the first time I used the laser cutter (a LaserPro Spirit GE). I designed two pieces for testing the press-fit connection. For 4mm triplex, a cut of 4 mm is way too big. Later on I tried 3.6 mm & 3.7 mm cuts and they are still too big.
Notes:
- Engraving uses black color, cutting uses red color
- With Adobe Illustrator, I set the width of the lines to 0.003 pt, and set the print to be at left top corner, then set the power to 100 and speed to 1.4 for cutting a 4 mm triplex, and start at relative position.
- Set the plastic holder for auto-focus, press "Auto-focus" on the menu, and turn-on ventilator (the handle on the righthand side to horizontal position).
References:
- Tutorial for using LaserPro Spirit GE
- The specifications of LaserPro Spirit GE
- LaserPro Spirit GE's manual
Vinyl cutter:
- copper paper
- knife: screw it as shallow as possible
- settings: depth of cut and how fast
- high accuracy: don't use roll
Laser cutter:
- press-fit: 1/5000 inch
- CO2 laser: 5 micron(?)
- 10 mills = beam size
- laser machine: Epilog
- 1 minute wait for venting after finishing with laser
- ICT44/heavy duty/shipment cardboard: bow nicely instead of kink
- no polycarbonate materials
- cut acrylic
- beware of shiny/reflective materials
- no PVC (laser releases chlorine): plastic that burns with color
- laser settings: power and speed
Sending work to cutting tools:
- AS220 rewriting printer drivers for laser cutter and vinyl cutter
- fab modules, cad.py
Input: PNG bitmaps
Inkscape:
- precise placement of objects
- alignments
- make a copy/clone: change the source --> change clones
Scribus:
- boolean operators
Resolution: 300 dpi / 500(?) dpi
Assignment:
1. play with workflow
2. make a joint
3. design the press-fit
Path for fab modules (on Linux): /usr/local/bin
cad.py:
- *.CAD = hardware description language = hierarchical parametric
- *.CAD --> *.PNG
Processing producing *.CAD?
Linux - USB - vinyl cutter: set printer as raw printer (for use with lpr)
Friday, 4 February 2011
I and Marina came to pay Matthijs van Henten a visit. [add link to Matthijs' website]. He had built an open source 3D scanner [add link to Matthijs' project].
Note: MeshLab & pylatscan [add links]
Neil gave lecture on computer-aided design, and the software tools.
Notes:
- function/volume representation vs boundary representation
- parameteric? hierarchical? declarative?
- MCU for video-conference, X-meeting, ConferenceMe
- MyPaint
- ODraw
- OCAD
- OpenSCAD
- FreeCAD
- Art of Illusion
- Grasshoper for Rhino
- Elmer
- COMSOL
(-PHUN)
(-Smultron)
Mercurial
- hgtk
- hg resolve
Friday, 28 January 2011
Updated my homepage.
Wednesday, 26 January 2011
(Week 2: project management)
This time, Neil, gave a lecture on project management. Dean Rose from Fablab Urbana wrote quite complete lecture notes on this one. [TODO: Add
link to the video].
Notes:
- unison
- clonezilla
- mercurial = git? (in earlier history)
- Andy's page
- Linux: tortoisehg
- seamonkey
- docuwiki
- ... wiki
- ... wiki
- sending application window as content channel (video conference)
- conferenceme + VNC server
- MCU? (video conference)
- Mythical Man Month
- web server on a coffee mug
- pico projector
- laser pointer cylindrical lense
- Open Source 3D scanner Matthijs van Hinten (Hentem?)
- BEAM 3D (with webcam)
Neil Gershenfeld started the
lecture by giving an introduction to personal fabrication. [TODO: add
link to the Power Point presentation]
Machine that make machines.
mtm?
SEED "On
the Future of Invention"
Back to my homepage
Last modified: Sat Jun 18 15:06:15 CEST 2011