diff --git a/docs/assignments/week05.md b/docs/assignments/week05.md
index dd0791a4d0d74deb34017e6a6bb5ddf1a41094fd..8e42dbe401e63df5d5e3dee7c44cddb050be35c7 100644
--- a/docs/assignments/week05.md
+++ b/docs/assignments/week05.md
@@ -27,7 +27,7 @@ I went through my sewing kit looking for some textile related hardware that migh
*Atmel ATtiny for programming*
-I would like to try building and programming the circuit using an Atmel ATtiny85 chip instead of the bulky Arduino UNO. I have all the materials for it and would like to practice being able to solder such a chip onto textile. I use [Sparkfun's TinyProgrammer](https://www.sparkfun.com/products/11801) that I use with a [Pomona Test Clip](https://nl.farnell.com/pomona/5250/test-clip-8-pos-1-27mm-soj-soic/dp/2406243?st=pomona%20testclip) for surface mount attiny's, or just plug the DIP chip into the programmer if it has legs. I can also use one of my handmade [FabISPs](https://fabacademy.org/archives/2015/eu/students/bogers.loes/04electronicsproduction.html).
+I would like to try building and programming the circuit using an Atmel ATtiny85 chip instead of the bulky Arduino UNO. I have all the materials for it and would like to practice being able to solder such a chip onto textile. I've seen the ATtiny chips used in a lot of wearable projects, so even though it's not part of the assignment, I figured it will come in handy to know how to do this later. I have a TinyProgrammer tick i can use: just plug the DIP chip's legs into the programmer. More below.
*Home-made and bought lilypad stuff lying around*
@@ -39,23 +39,30 @@ I previously used some of the [open source Lilypad designs](https://www.sparkfun
And I found [this page](http://toolswewant.at/category/tools/) via the Kobakant website where soft circuiteers imagine and share ideas for tools they'd like to have for their practice! Ohhhhh man that is so inspiring! Because I'm not a designer, but I do have maker skills and affinity with these kind of practices I've been thinking about the option of making tools during this course. On this page there are so many ideas! Some of them are built already, others are just sketches.
+*Screenshot of the Tools We Want website, 2019.*
+
I think I might be able to make a better contribution there because I enjoy solving problems, learning about technical stuff and working on concrete things. It gives me more grip on understanding *why* I'm doing something that makes me feel comfortable. This is my applied streak I suppose. I also love working with artists because they tend to make very weird problems to solve that I'd never come up with but that are very interesting to work on.
##Exploring conductive materials
###Understanding softpot basics
+*Softpot examples from Liza Stark's slides, 2019*
+
**Varying resistance across**
The basic idea of a (soft or hard) potentiometer is to align a very conductive material with one that has resistance, and designing a physical sliding connector that connects them across. The shape or design can be straight or round or even meandering as shown on this swatch from Kobakant:
-![]()*Embroidered potentiometer, screenshot from [Kobakant](https://www.kobakant.at/DIY/?p=2331)*
+*Embroidered potentiometer, screenshot from [Kobakant](https://www.kobakant.at/DIY/?p=2331)*
The sliding connector can be any conductive object or material. The further away you put the sliding connector - or: *conductive pointer finger* from the source, the more resistance there will be. If you know the the minimum resistance value and the maximum value, you can even map out pretty precise in-between states (as long as your resistive material increases in a linear way, not all materials behave like that).I started out with some conductive and some resistive thread and tried sewing some lines on my sewing machine. It has a lot of patterns preprogrammed and some of them are pretty nice! So I tried a few of those.
Liza Stark's slides made things very simple.
-![]()*Screenshots of Liza's slides for reference, 2019*
+*Basic circuit for a softpot, screenshot of Liza Stark's slide, 2019*
+*Basic circuit for a linear softpot/analog switch, screenshot of Liza Stark's slide, 2019*
+*Basic circuit for a circular softpot/analog switch, screenshot of Liza Stark's slide, 2019*
+
**Tension and test traces**
@@ -89,31 +96,138 @@ I found this metal bikini clip that I cut off a bikini once. It's really nice! M
###Using Arduino Uno
-Prototyping this with an Arduino was a breeze. I started with a Blink sketch, and then added the code from the Button example
+Prototyping this with an Arduino was a breeze. I started with a Blink sketch, and then added the code from the Button example that come with the standard install of the Arduino IDE under File >> Examples.
-**Tone() for my buzzer**
+**tone() and noTone()**
+Then I proceeded to try get some sounds from the buzzer. I looked up the [Lilypad Buzzer hookup guide on Sparkfun](https://learn.sparkfun.com/tutorials/lilypad-buzzer-hookup-guide/all) and learned about the tone() and noTone(functions). Copied the code, and added my blink and button code to the sketch. I found out later that these functions are not supported on ATtiny however. I has a sad.
```
-CODE CODE CODE
+LilyPad Buzzer Example, modified by Loes Bogers
+SparkFun Electronics
+
+This example code shows how to hook up a LilyPad Buzzer to play a simple song
+using the tone() function and setting variables for each note.
+
+Buzzer connections:
+ * + pin to 5
+ * - to -
+
+const int buttonPin = 8; // the number of the pushbutton pin
+const int ledPin = 10; // the number of the LED pin > has PWM
+const int buzzerPin = 5; // the number of the buzzer pin
+int delayTime = 100;
+int delayTime2 = 150;
+int delayTime3 = 200;
+
+
+// Notes and their frequencies
+const int C = 1046;
+const int D = 1175;
+const int E = 1319;
+const int F = 1397;
+const int G = 1568;
+const int A = 1760;
+const int B = 1976;
+const int C1 = 2093;
+const int D1 = 2349;
+
+int buttonState = 0; // variable for reading the pushbutton status
+
+void setup() {
+ // initialize the LED pin as an output:
+ pinMode(ledPin, OUTPUT);
+ // initialize the pushbutton pin as an input:
+ pinMode(buttonPin, INPUT);
+ // Set the buzzer pin as an OUTPUT
+ pinMode(buzzerPin, OUTPUT);
+}
+
+void loop() {
+ // read the state of the pushbutton value:
+ buttonState = digitalRead(buttonPin);
+
+ // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
+ if (buttonState == LOW) {
+
+ //To use LED uncomment sentence below
+ digitalWrite(ledPin, LOW);
+
+ //play notes (delayTime in this case is how long it's played)
+ tone(buzzerPin, C);
+ delay(delayTime);
+ tone(buzzerPin, E);
+ delay(delayTime2);
+// tone(buzzerPin, C);
+// delay(delayTime);
+// tone(buzzerPin, G);
+// delay(delayTime3);
+// tone(buzzerPin, F);
+// delay(delayTime);
+ }else{
+//stop sound
+ noTone(buzzerPin);
+ digitalWrite(ledPin, HIGH);
+ }
+}
```
-###Using an ATtiny85 DIP
+###Using an ATtiny85 DIP and Sparkfun TinyProgrammer
**Tools and instructions**
-1. Chips need programmers: FabISP and/or Sparkfun's TinyProgrammer
-1. Drivers and installs
-1. Choosing settings in the Arduino IDE
-1. Connecting and programming the chip (orientation matters)
-1. Breadboarding with a chip
-1. Using the programmer as a prototyping board
-1. Disconnect when uploading new code!
+*Chips need programmers: Sparkfun's TinyProgrammer stick [Sparkfun's TinyProgrammer](https://www.sparkfun.com/products/11801)*
+
+This simple IC is great because it's supported quite well by the Arduino community which means it's easy to program and prototype with. You do need another device to program it though. An Arduino board tends to have a programmer and a chip or IC (integrated circuit) on board, which means you can do the programming with one device. The ATtiny is just an IC so we use a separate programmer. I'm used to working with [Sparkfun's TinyProgrammer](https://www.sparkfun.com/products/11801), and the open-source FabISP. They work the same, just the wiring/connecting is a bit different. I'll document below and also how to connect if you use SMD Attiny chips. Mainly for my own reference for later but who knows it might be useful to others. It's easiest for me with the programmer stick, because you can just plug in the chip and even prototype on the programmer stick. So I'll use that this week.
+
+*Programming an ATtiny85 SOIC (SMD) with the TinyProgrammer*
+The chip used is a through-hole IC, but they also come in surface mount packages to be soldered onto a PCB. If you want to program those you can do it by using e.g. this [Pomona Test Clip with 8 contacts](https://nl.farnell.com/pomona/5250/test-clip-8-pos-1-27mm-soj-soic/dp/2406243?st=pomona%20testclip) for surface mount attiny's. Wire them us as pictured below:
+
+*How to wire the Pomona testclip to the programming stick, to program surface mount ATtiny chips (SOIC)*
+
+
+*FabISP Programmer*
+If you don't have a TinyProgrammer or are against buying hardware you can build, you might already have a FabISP or similar (or want to make one). I documented my learning process of making one [here](https://fabacademy.org/archives/2015/eu/students/bogers.loes/04electronicsproduction.html). If you are wiring this guy op to an ATtiny, wire it like this:
+
+*How to wire a FabISP to a testclip to program an SMD ATtiny85*
+
+*Programming an ATtiny with an Arduino-as-programmer*
+
+INSERT BIT FROM THE BOOK!
+
+
+**Drivers and installs**
+
+I bought mine from Sparkfun years ago, they still have it. [This tutorial](https://learn.sparkfun.com/tutorials/tiny-avr-programmer-hookup-guide/programming-in-arduino) explains well how to set everything up so you can start programming the chip in Arduino.
+
+**Choosing settings in the Arduino IDE**
+
+Like the tutorial explains, it's important to choose the right board, processor and clock when programming the ATtiny. In my case:
+
+* board: ATtiny
+* processor: ATtiny85
+* clock: 8 mHz (internal)
+
+The clock is how fast you let the chip run (the frequency or speed at which it cycles through the code). By default, this chip can run on 1 mHz or 8 mHz (it has internal crystals or "clock" devices for that built in). The 1 mHz is too slow so I go for 8, if your blinks are going slower than you set in your code, check if you left the clock on 1 mHz by accident. Don't use the 9, 16 or 20 mHz (external) clocks unless you are also adding a crystal/clock to your circuit with the same value. If you don't know what that means: you're on the safe side sticking to internal clocks, they work fine unless you want to do advanced communication between boards.
+
+**Disconnect everything before programming**
-**no Tone() for ATtiny - stealing some code**
+I got a lot of errors when trying to program the chip while keeping the rest of the circuitry connected. I just deconnected everything to be sure. It might have been that the buzzer was creating a short (see more on buzzer below).
-I was not getting any sounds from my ATtiny circuit. I double checked the wiring and code, but it seemed like it should work exactly the same. So I started using the Google and found [*Technoblogy* by David Johnson-Davies](http://www.technoblogy.com/show?20MO) who documents lots of experiments and projects using ATtiny chips, including one where he's found a way to use an ATtiny85 with a buzzer. Thank you David!
+**Connecting and programming the chip (orientation matters)**
+
+When moving the chip around always keep track of the orientation! There's a mark on the chip to tell you which side is up. See also Sparkfun tutorial.
+
+**Prototyping and breadboarding with the chip (and the programmer)**
+
+You can prototype small circuits diretly on the programmer stick, the headers next to the legs of the IC correspond to those pins and are marked conveniently as well. RST, 3, 4 and GND on the left, and VCC, 2, 1, 0 on the right. I needed to use the breadboard too so it was quite a wiry mess but I enjoy that, and it worked out fine.
+
+####Adapting the code to work with ATtiny
+
+**no Tone() for ATtiny: stealing some code**
+
+I was not getting any sounds from the circuit when I used the ATtiny as IC. I double checked the wiring and code, but it seemed like it should work exactly the same. So I started using the Google and found [*Technoblogy* by David Johnson-Davies](http://www.technoblogy.com/show?20MO) who documents lots of experiments and projects using ATtiny chips, including one where he's found a way to use an ATtiny85 with a buzzer. Thank you David!
This code is a bit lower level, programming the chip directly instead of using a library that obscures what is actually happening from the average user's view. I've been able to figure out what is happening in some parts, but will have to ask Emma to help interpreting the note() function he wrote. I was still able to use it though, so moving on....
@@ -122,10 +236,12 @@ This code is a bit lower level, programming the chip directly instead of using a
/*
Code from http://www.technoblogy.com/show?20MO
-
Playing Notes on the ATtiny85
31st January 2018
+Modified by Loes Bogers
+November 2019
+
This article describes a simple function for playing notes on the ATtiny85.
I've called this function note, and it can be used to play notes on the ATtiny85 pins 1 or 4.
@@ -177,10 +293,9 @@ void note (int n, int octave) {
}
```
-
**USB disabled: shorts shorts shorts**
-Computer kept complaining that the circuit is drawing too much power and the USB port had to be disabled. Oh craps. I had to do some debugging until I found the issues. Also the buzzer stopped buzzing and started behaving very erratically making shreeking sounds.
+My computer kept complaining that the circuit is drawing too much power and the USB port had to be disabled. Oh craps. I had to do some debugging until I found the issues. Also the buzzer stopped buzzing and started behaving very erratically making shreeking sounds.
*Potential problem #1:*
@@ -193,22 +308,23 @@ command. If it wasn't the issue then it's at least good practice.
*Potential problem #2:*
-Faulty wiring. I am shorting my circuit everything I connect the switch ends together because the switch is directly between VCC and GND. The + wire should be connected to VCC not directly, but via the 10K pullup resistor. Errrp my bad. This solved the issues though and I have a working circuit using the components I'd intended. Wahoo! Ready to start crafting it into a textile swatch.
+Faulty wiring. I am shorting my circuit everything I connect the switch ends together because the switch is directly between VCC and GND. The + wire should be connected to VCC not directly, but via the 10K pullup resistor. Errrp my bad. This solved the issues though and I have a working circuit using the components I'd intended. Wahoo! Ready to start crafting it into a textile swatch or project.
###Powering the circuit
Now, powering this stuff with a USB cable (5V) is usually fine, but will it blend with say, a 3V coin cell, is what I want to know. The Lilypad Buzzer datasheet says yes, as the operating voltage should be 2.5-4.5V. The ATtiny85 datasheet says 1.8-5.5V for the ATtiny85V and 2.7-5.5V for the ATtiny85. So let's take the latter to be on the safe side. ([ATtiny85 Datasheet](https://html.alldatasheet.com/html-pdf/175195/ATMEL/ATTINY85/151/1/ATTINY85.html), and the [datasheet of the buzzer used on the Lilypad Buzzer](http://cdn.sparkfun.com/datasheets/Components/General/CCV-084B16-CUI-datasheet-29139.pdf)). Ok now that I know this I will try power the buzzer and IC with a 3V coin cell. Went back to simple tone sketch I stole, and...Success!
-
```
/*
Code from http://www.technoblogy.com/show?20MO
-
Playing Notes on the ATtiny85
31st January 2018
+Modified by Loes Bogers
+November 2019
+
This article describes a simple function for playing notes on the ATtiny85.
I've called this function note, and it can be used to play notes on the ATtiny85 pins 1 or 4.
@@ -263,26 +379,184 @@ void note (int n, int octave) {
}
```
+###From schematic to soft circuit
+
+This is the schematic of the circuit I cobbled together. I ended up switching the buzzer from pin 1 to pin 4, which is located on the left side of the IC, because it allowed for an easier layout of the conductive traces. Translating a schematic into a working circuit with a breadboard and jumpers is known territory for me. Making a soft circuit on the other hand: super new! And really quite challenging that I had a lot of fun with and made sooooo many mistakes haha.
+
+
+###Concept? Who said anything about a concept?
+As I had to start thinking of the form factor I realized I really didn't have a concept to put these things together at all. I just wanted to work with these components I had lying around. But if you like a story: I made a pink choker that represents the way we use social media. We use it to present ourselves nicely and pretty to the world. It's clear for everyone that it's always passively watching us and capturing us in the background (the red light in the choker), but it's not until we try to take off this leash or try to leave social media that we get alarmed, and continuously nudged into going back into the walled gardens with nosey neighbours. But yeah to be honest: just wanted to explore these particular materials.
+
+###Deciding on a form factor and material
+I initially thought to put these things into a swatch, but the bikiniclip so strongly demanded a strip as a connection, that I considered a long, stretched out design, that then became a choker.
+
+I only had thin floppy textiles at home – I tend to do electronics development late at night... – and now I see why so many projects, like Jessica Stanley's for example, use (fake) leather or felt. Something relatively stiff and thick yet bouncy is pretty nice to embed electronics in because you don't loose all the form and softness. The rigid and pointy electronics needs some cushioning. So I went back to a leftover of the pink EVA foam I used for the circular fashion week. It was not ideal: you can't make mistakes with stitching, because you can see the holes forever, and it *can* tear if you're not careful. But it didn't and I'm pretty happy with it as a prototype. I used a standard spool of smooth [stainless steel conductive thread](https://www.sparkfun.com/products/13814) that comes on a bobbin. It has a diameter of 0.12 mm and a resistance of 27 Ω/m.
+
+###Sketching up the design
+
+It took several iterations to figure out a way to lay out the traces without crossing them. I wanted to keep it simple and in one layer for now. I was able to do this by moving the buzzer from pin 1 to pin 4. These two are the only pins on the ATtiny that can be used for the buzzer, as described in the Technoblogy article listed above.
+
+**The actual prototype (with improv)**
+And then there's reality. I thought I'd planned the design quite well but of course I had taken the hard-soft connections for granted with my previous electronics design experience haha. There are standardized connectors, headers and what not for *everything* in electronics world. They are so ubiquitous that they become invisible. So I had to do a little improvising along the way. I tried to limit the amount of hardware to embed. I could have used a battery clip but decided to try making a soft connector instead.
+
+PICTURE HERE
+
+DRAWING HERE
+
+**Final code of the circuit**
+
+```
+/*
+
+ Buzzer ATtiny Code from http://www.technoblogy.com/show?20MO
+ Playing Notes on the ATtiny85
+ 31st January 2018
+
+ Modified by Loes Bogers
+ Nov 2019
+
+ This article describes a simple function for playing notes on the ATtiny85.
+ I've called this function note, and it can be used to play notes on the ATtiny85 pins 1 or 4.
+
+ The note function uses Timer/Counter1 in the ATtiny85,
+ leaving Timer/Counter0 free for delay() and millis().
+ It doesn't use interrupts, so the sound buzzerPinPinPinPin is unaffected by other interrupt-driven processes,
+ and it includes a lookup table for the well-tempered scale divisors, so you don't need to remember frequency values.
+
+ It's an improved version of my earlier article Simple Tones for ATtiny.
+ For a similar routine for the ATmega328 or ATmega32u4 see A Lightweight Alternative to tone.
+
+ The note function takes two parameters:
+
+ A note number, from 0 to 11, representing the note in the well-tempered scale,
+ where 0 represents C, 1 represents C#, and so on up to 11 for B.
+ The octave, which can be from 0 to 7 with a 1MHz clock,
+ 0 to 10 with an 8MHz clock,
+ and 0 to 11 with a 16MHz clock.
+
+*/
+
+const int ledPin = 0; // the number of the LED pin > has PWM
+const int buzzerPin = 4; // Can be pin 1 or 4
+const int buttonPin = 2; // the number of the pushbutton pin
+
+// Cater for 16MHz, 8MHz, or 1MHz clock:
+const int Clock = ((F_CPU / 1000000UL) == 16) ? 4 : ((F_CPU / 1000000UL) == 8) ? 3 : 0;
+const uint8_t scale[] PROGMEM = {239, 226, 213, 201, 190, 179, 169, 160, 151, 142, 134, 127};
+
+int buttonState = 0; // variable for reading the pushbutton status
+
+void setup() {
+ // initialize the LED pin as an output:
+ pinMode(ledPin, OUTPUT);
+ // initialize the pushbutton pin as an input:
+ pinMode(buttonPin, INPUT);
+ // // Set the buzzerPinPinPin pin as an OUTPUT //not necessary, programmed globally?
+ pinMode(buzzerPin, OUTPUT);
+}
+
+void loop() {
+
+ // read the state of the pushbutton value:
+ buttonState = digitalRead(buttonPin);
+
+ // check if the pushbutton is pressed. If it is, the buttonState is LOW:
+
+ if (buttonState == LOW) {
+
+ digitalWrite(ledPin, HIGH);
+ digitalWrite(buzzerPin, LOW); // set to low to avoid shorts
+
+ } else {
+
+ digitalWrite(ledPin, LOW);
+
+ for (int n = 0; n <= 12; n++) { //n = 12 is number of notes in octave.
+ note(n, 4);
+ if (n != 4 && n != 11) n++; //
+ delay(100); // delay between each note
+ }
+ note(0, 0);
+ delay(1000); // time in milliseconds before loop starts again
+ }
+}
+
+
+void note (int n, int octave) {
+ int prescaler = 8 + Clock - (octave + n / 12);
+ if (prescaler < 1 || prescaler > 15 || octave == 0) prescaler = 0;
+ DDRB = (DDRB & ~(1 << buzzerPin)) | (prescaler != 0) << buzzerPin;
+ OCR1C = pgm_read_byte(&scale[n % 12]) - 1;
+ GTCCR = (buzzerPin == 4) << COM1B0;
+ TCCR1 = 1 << CTC1 | (buzzerPin == 1) << COM1A0 | prescaler << CS10;
+}
+```
+
+
+###Hard-soft connections
+
+**IC socket made of perfboard**
+
+I used a piece of perfboard to make a socket for the IC. It has holes so is easy to sew onto the fabric. I went through the holes 5-6 times, which fills up the hole but still allows you to press the IC in nice and firmly making nice connections whilst being able to remove it easily if you want to reprogram it or replace it (or wash the garment). I saw similar techniques on Kobakant's [listings for hard/soft connections.](https://www.kobakant.at/DIY/?p=1272). The foam material is so thick that the legs don't pierce through on the other end, which is extra nice because it's invisible and I can keep the legs intact for programming.
+
+**Detachable buzzer**
+
+I made the buzzer detachable, using push buttons because this module gets damaged if you wash it according to the [Lilypad buzzer specs] (https://www.sparkfun.com/products/8463).
+
+**Coin cell battery pocket**
+
+I added some conductive textile to make bigger surfaces to connect to the battery's + and GND. And used them in combination with the conductive thread and pushbuttons. They're called *bottoni automatici* in Italian. Isn't that glorious? Automatic buttons. It reminds me of a time when a push button was seriously new media, and a revelation after all those non-automatic bone and plastic buttons that needed manual handling :D The battery connections could be tighter, but if you wear this on your neck there's a bit of tension that pushes the battery against the pads.
+
+I was getting a lot of shorts because the pushbuttons of the pocket were touching the sides of the battery thereby creating shorts (and very weird beeping sounds from the buzzer). Emma suggested I sew on a bit of rubber band to separate them. Good idea! Not so elegant but a fine prototyping fix.
+
+I should have researched better and I would have found these [Twelve Ways To Hold Your Coin Cells at Kobakant!](https://www.kobakant.at/DIY/?p=7064). I will make one of these for the second part of the assignment and do it proper. A bit of additional research also led me to this tutorial ["How to Work With Conductive Fabric"](https://www.instructables.com/id/How-to-Work-With-Conductive-Fabric/) which is packed with how-to's and tips on everyting e-textile. I'd like to try making a swatch with traces from conductive textile instead of the stitching technique.
+
+**Bikiniclip connections**
+
+I only figured out as I was sewing the bikini clips onto the pink foam that they would not make an electrical connection if I'd just attach them! Haha I needed the thread to somehow touch the clip, which it doesn't do with a standard seam. So I put a small strip of conductive textile inside the fold around the clip before stitching it to attach the clip. Connection sounds good so I'm happy.
+
+**Resistor and SMD LED on a tiny board**
+
+I bent the legs of the resistor to make sewable loops. And I had made some tiny PCB's with an LED taken from the open source files of the [LED modules](https://www.sparkfun.com/products/13902) that you can buy as part of the lilypad line. You can find the schematic and design files under "documents", I modified them to match the components I had, milled and soldered them. What I'd forgotten was that I used these for a different purpose at the time 3 years ago. I had to do a lot of debugging before I realized there was a 1K resistor on the LED board. Which is HUUUUUGE for this circuit, and prevented the LED from lighting up. Also, the front and back of these boards are not connected, you have connect them if you want the front and back pads to be connected. Hahahahaha classic mistake. I undid all the stitches, removed the resistor and replaced it with an SMD 0Ω resitor that acts as a wire/bridge/conductor. And presto! Everything works.
+
+####Front-back-middle?
+
+I spent quite some time thinking about the inside and the outside of the choker, but I would definitely look for more options in a next iteration. I decided to keep the components all on the inside, away from view, and just show the traces to the world. The LED lights up nicely coming from behind the fabric, it gets a bit diffused which I think is very nice. Of course my stitching needs to be way better for this to look nice.
+
+###The art of needlepointing
+
+Ok so I realized that my needlepointing is rather sloppy. I try, but I'm either accidently messing up and putting buttons the wrong way around, or not taking care of my thread allowing it to know, or I'm basically just impatient. I do see that it's a huge part of the aesthetic you can achieve though and would like to improve this and learn some different stitches.
+
+Next time I'll only hand stitch sitting down with a glass of wine and a nice friend or music, and try to really enjoyyyyy doing this repetitive but important job carefully and nicely. It's a kind of finesse that I would really hope to one day bring to my electronics projects.
-###Planning connections: digital switch
+For now: look at these stitches, they are not that bad! Don't look at the other ones please. I used a little rotary pointy tool to draw even dotted lines that helped with stitching in a regular rhythm. But still: Ceciia could you bring us your needlepointing bible?
-**Schematic of the circuit**
+IMAGE OF TOOL
-IMAGE HERE
+###Debugging tips and tricks
-**Design of the circuit**
+Yeaaaasssss my favourite part haha. I get to practice my mindfulness and sense of humour here because this never goes as expected. I used to get so frustrated! Now I understand a little better that it's just part of the process and it's actually a nice puzzle somtimes. I was very hopeful it would work right away. Which is partially did. I was getting a buzzer, and it would stop as the clip connects. But I got a lot of shorts with the battery pocket, like I described (I *heard* weird sounds at times and *saw* that the LED was not turning on when expected. It took half a day to figure out why the LED wasn't coming on. It was because the top and bottom of the board were disconnected and I was connecting the back whereas the front has the components on them.
-IMAGE HERE
+If something is not working or behaving weirdly, I use these debugging strategies I learned from Emma during Fabacademy:
-**hard/soft connection for an ATtiny chip**
+*Debug the connections*
+1. Measure each connection all the way across (using continuity mode), ALSO check that the other traces or not accidently also connected to the trace you're trying to check. Check two things: 1) check whether traces/pads that should be connected are connected, and 2) check whether traces/pads that should be separate are indeed not connecting anywhere. You cannot check this enough in my experience.
-How how how how?
+*Debug resistance, current and voltage*
+1. Measure voltage of the battery to see if it's full enough
+1. Read datasheets and check the operating voltage (your power source should accommodate the operating voltage of all the components used).
+1. Measure voltage across the chip (should be same as voltage of battery)
+1. Measure voltage on pins on the IC that should be high according to your code (should give same voltage as the battery).
+1. Feel the components: is stuff getting hot? Do you smell something burning? Your circuit is drawing too much power and you probably have a short. Disconnect the power immediately and debug. Check whether you've burned any components one by one.
+1. If you are powering your project with a laptop, it will disable the USB ports if it's drawing too many Amperes (to protect your computer from frying). This should tell you you need to look for shorts.
+*Check the code:*
-**detachable buzzer**
+1. If all seems right, also check the code. Did you connect the right components to the right pins mentioned in the code?
+1. Did you make sure your code is not stuck in a loop? Sometimes I write something and I don't realize it can never reach certain states or conditions. For each control statement, write in a feedback loop so you know where in the code you get stuck. E.g. make a led blink once or twice or three times, as it loops through the parts of the code. Or use the serial monitor and print messages to the serial to know what the code is doing and where it might get stuck.
-It gets damaged if you wash it according to the [Lilypad buzzer specs] (https://www.sparkfun.com/products/8463)
+For example: I might try to connect a buzzer but am not sure how to connect it. In my code I'll write a command to play a note on the buzzer, and also turn on an LED. If the buzzer doesn't play a tone but the LED turns on I know that the program is running correctly and I probably have to look at the way I connect the component or how I drive it in the code. If there's no tone AND no light, it probably means the program never reaches that part of the code.
****
diff --git a/docs/assignments/week06.md b/docs/assignments/week06.md
index fc098b8a65ae46c2943b5a831d7690a35d65ac10..19bd0ab56efdbaf60e472d8f6850cfab262057a8 100644
--- a/docs/assignments/week06.md
+++ b/docs/assignments/week06.md
@@ -180,6 +180,9 @@ The natural dye faded quite a lot in terms of saturation and definition: it beca
*bioresin and biosilicon matured for 4 days (left to right: acidic cabbage ink, neutral ink, alkaline ink. Time shows we're not all that different at the core, in the end. And we all get old, unless we're made of plastic, Loes Bogers, 2019*
+**Molding**
+The bioresin started to grow mold after a week. I'd kept them pressed flat so they didn't get a lot of fresh air. The silicone still looks fine even under the same conditions.
+
###Gelatine-based biofoam with acrylic paint and food coloring
@@ -214,7 +217,7 @@ The thickness of the mixture even before curing allows you to create really nice
When drying, *some* of these morphed a lot, curling up at the sides and getting a slightly dried out look. All samples shrank in thickness and size. What I don't understand completely is why they shrank different amounts, and why some stayed flat and other curled a lot.
-The red sample colored with food coloring shrank less than the ones with acrylic paint. Interestingly, there was *one* that kept its shape really well so I was able to measure the exact amount of shrinkage. This was one that had a pretty even mix between red and blues poured in dots across the surface. Perhaps the reason why it behaved differently? When I noticed this one had not gotten rigid and curly like the other ones, started to press it underneath heavy books to keep it flat for the rest of the curing process (below).
+The red sample colored with food coloring shrank less than the ones with acrylic paint. The dotted one kept its shape really well so I was able to measure the exact amount of shrinkage. This was one that had a pretty even mix between red and blues poured in dots across the surface. Cecilia had put a weight on it earlier, and when I noticed the others had started to curl up I kept that one pressed until a week later.
The food coloring in the foam did not leave stains (unlike the other places I've used it later on....)
@@ -222,6 +225,9 @@ The food coloring in the foam did not leave stains (unlike the other places I've
The thicker foam buds (from the mixing pots) feel squishy and soft. The thinner samples got more rigid, much less squishy but still a bit flexible.
+*Changes in rigidity after 5 days*
+The way these feel changed a lot of the course of a week too. I'd kept them in a box in my bag for two days after they'd dried in air for 5 days. They'd become pretty rigid. After two days in the box they seemed a little softer again.
+
###Potluck gelatine-based foam with and without egg shell filler
You can keep adding liquid and heat and keep manipulating gelatine-based plastics (it's not heat- or waterproof), so we made a potluck gelatine left-over pot. It turned out to be very foamy so there was probably a good amount of foam leftovers in.
@@ -285,7 +291,7 @@ Wow, these just turned into coral pretty much. The thinner samples shrank a lot
Rice flour and tapioca can be mixed into the recipe raw and they will dissolve without further cooking. Dissolve it into a mixing pot using a little bit of liquid before pouring the rest of the liquid in. Otherwise for sure it will get lumpy (like you would when cooking with starches to make a sauce for example).
-I forgot to do this when using the wheat flour and got huge lumps. I thought it was a total fail but actually turned into a wonderful blistery textured surface that I released from the mixing pot and treasured anyway.
+I forgot to do this when using the wheat flour and got huge lumps. I thought it was a total fail but actually turned into a wonderful blistery textured surface that I released from the mixing pot and treasured anyway until it started getting moldy. This one stayed wet for days.
**Texture and feeling**
@@ -342,11 +348,11 @@ We also made a leftover pot with tapioca that we mixed into the recipe and then
Bea and I cooked another batch of gelatine/agar foil to make some thin sheets we could play with and try different fabrication techniques on. Like making interlocking modules with the laser cutter. We cooked a batch that we dyed with food coloring. The stove didn't quite reach 80 degrees like it should so it took quite long to thicken. You can turn up the cooker slightly higher just making sure it's not bubbling and boiling (then I turn it down again, and go up and down like that).
-We cast one sheet while the mix was still very liquid, which turned into a beautiful lightweight foil with a very shiny back. (Video's below shot by Bea, while Cecilia is releasing the foil.
+We cast one sheet while the mix was still very liquid, which turned into a beautiful lightweight foil with a very shiny back. A bit similar to the transparent film used to wrap flowers. (Video's below shot by Bea, while Cecilia is releasing the foil.
<iframe width="560" height="315" src="https://www.youtube.com/embed/d6igE9Y31r4?controls=0" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
-The other sheet was poured when the mixture was properly thickened and became a beautiful strong and shiny sheet. WHOA! They even sound nice. Satisfaction all around.
+The other sheet was poured when the mixture was properly thickened and became a beautiful strong and shiny sheet. Thicker than the first one. WHOA! They even sound nice. Satisfaction all around.
<iframe width="560" height="315" src="https://www.youtube.com/embed/ZAViJqdUQqk?controls=0" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
diff --git a/docs/assignments/week07.md b/docs/assignments/week07.md
index ee08140a31e6c6614b43bc45baa6d2fe96c0a923..0fbcc5d099ec02ffc9dc307c51de701ce37d37a4 100644
--- a/docs/assignments/week07.md
+++ b/docs/assignments/week07.md
@@ -1,67 +1,40 @@
# 7. Open Source hardware: from fibers to fabric
-This week I worked on defining my final project idea and started to getting used to the documentation process.
+Machines, techniques and processes of open source hardware to use in relation with yarns and other materials.
-## Research
+##Lecture notes
-"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+Notes from the [lecture by Varvara Guljajeva](https://class.textile-academy.org/classes/week08/)
-> "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+The origigins of knitting; it's a very old craft. Dates back to 400-500 BV.
-## Useful links
+Handcranked circular knitting machines for socks!
-- [Jekyll](http://jekyll.org)
-- [Google](http://google.com)
-- [Markdown](https://en.wikipedia.org/wiki/Markdown)
+The knitting machine was the first personal manufacturing tool at home. Brother used to produce a lot of machines but discontinued at a certain point.
+##Inspiration
-## Code Example
+Knitic
-Use the three backticks to separate code.
+Post-functional wearables
-```
-// the setup function runs once when you press reset or power the board
-void setup() {
- // initialize digital pin LED_BUILTIN as an output.
- pinMode(LED_BUILTIN, OUTPUT);
-}
+Neuroknitting - Varvarag
-// the loop function runs over and over again forever
-void loop() {
- digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
- delay(1000); // wait for a second
- digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
- delay(1000); // wait for a second
-}
-```
+Glitchknit.jp
+Oiko-nomic threads
-## Gallery
+ayab-knitting : alternative way to control the Brother KH-9xx range of knitting machines using a computer.
-
+Openknit and Kniterate
-## Video
+Idda knitting machine
-### From Vimeo
+Kniterate.com
-<iframe src="https://player.vimeo.com/video/10048961" width="640" height="480" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe>
-<p><a href="https://vimeo.com/10048961">Sound Waves</a> from <a href="https://vimeo.com/radarboy">George Gally (Radarboy)</a> on <a href="https://vimeo.com">Vimeo</a>.</p>
+Ecal - Rocking Knit
-### From Youtube
+Wind knitting factory
-<iframe width="560" height="315" src="https://www.youtube.com/embed/jjNgJFemlC4" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>
-## 3D Models
-
-<div class="sketchfab-embed-wrapper"><iframe width="640" height="480" src="https://sketchfab.com/models/658c8f8a2f3042c3ad7bdedd83f1c915/embed" frameborder="0" allow="autoplay; fullscreen; vr" mozallowfullscreen="true" webkitallowfullscreen="true"></iframe>
-
-<p style="font-size: 13px; font-weight: normal; margin: 5px; color: #4A4A4A;">
- <a href="https://sketchfab.com/models/658c8f8a2f3042c3ad7bdedd83f1c915?utm_medium=embed&utm_source=website&utm_campaign=share-popup" target="_blank" style="font-weight: bold; color: #1CAAD9;">Dita's Gown</a>
- by <a href="https://sketchfab.com/francisbitontistudio?utm_medium=embed&utm_source=website&utm_campaign=share-popup" target="_blank" style="font-weight: bold; color: #1CAAD9;">Francis Bitonti Studio</a>
- on <a href="https://sketchfab.com?utm_medium=embed&utm_source=website&utm_campaign=share-popup" target="_blank" style="font-weight: bold; color: #1CAAD9;">Sketchfab</a>
-</p>
-</div>
-
-## Bonus section & recitation
-
-Bonus is a bonus
\ No newline at end of file
+\>> A lot of the examples are exploring new or open source ways of making textile patterns.
\ No newline at end of file
diff --git a/docs/images/wk05_embroideredpot.jpg b/docs/images/wk05_embroideredpot.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..7ed8592bf65834920c15861e8cf26b8b46bc8c44
Binary files /dev/null and b/docs/images/wk05_embroideredpot.jpg differ
diff --git a/docs/images/wk05_isp_ribbon_ictestclip.jpg b/docs/images/wk05_isp_ribbon_ictestclip.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..84c4b4d1f1723734bf873580d555b734a0c3c8b7
Binary files /dev/null and b/docs/images/wk05_isp_ribbon_ictestclip.jpg differ
diff --git a/docs/images/wk05_liza_pot1.jpg b/docs/images/wk05_liza_pot1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..6e9706d69d328050e85e56b57883d91079d8fa4c
Binary files /dev/null and b/docs/images/wk05_liza_pot1.jpg differ
diff --git a/docs/images/wk05_liza_pot2.jpg b/docs/images/wk05_liza_pot2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..903006bc6e5be0f10c8b250dc15433b50039e69c
Binary files /dev/null and b/docs/images/wk05_liza_pot2.jpg differ
diff --git a/docs/images/wk05_liza_pot3.jpg b/docs/images/wk05_liza_pot3.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..54b8603f52a9729840d9f69147b4aa9e95cb929e
Binary files /dev/null and b/docs/images/wk05_liza_pot3.jpg differ
diff --git a/docs/images/wk05_liza_potmeters.jpg b/docs/images/wk05_liza_potmeters.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e11a9bee02ec25be6fcd9a7611b907a2b7a40a9d
Binary files /dev/null and b/docs/images/wk05_liza_potmeters.jpg differ
diff --git a/docs/images/wk05_toolswewant.jpg b/docs/images/wk05_toolswewant.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..4d53595cff58aa6154567e10d5aa4963febb9c24
Binary files /dev/null and b/docs/images/wk05_toolswewant.jpg differ
diff --git a/docs/images/wk05_wiring_programmer.jpg b/docs/images/wk05_wiring_programmer.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..40dc4dced1d43179b4c71101d849450c70005cea
Binary files /dev/null and b/docs/images/wk05_wiring_programmer.jpg differ