Wearables

The ATtiny

The Microchip microcontrollers ATtiny family is a suite of low power, high-performance micro-controllers widely used by hobbyist for it's accesibillity and price range. They are easy to program and exist in both SMT and TH format.

The Attiny's chip can be programmed using In-System-Programming (ISP), a very simple and efficient way of programming a system using an external programmer. There are plenty of programmer able to do ISP programming on the market, the Atmel-ICE for exemple, is a great tool to have for any hobbyist that has to work with modern micro-controllers. But one that we absolutely love (and hate) in the Fablabs environement is the famous fabisp . The chip and the programmer exchange information using a serial peripheral interface (SPI).

The Attiny44 is a 14 pin micro-controllers that has analog, digital and Pulse with modulation (PWM) capability. It can be programmed using the arduino IDE and cost around a bit more than a dollar, even in it's TH version it is incredibly cheap. While it may lacks in memory it pulls more than it's weight for smaller applications.

The EchoTiny

Having in mind that we have to embeded electronics into textile, the surface mount version of the attiny44 would be impossible to integrate into fabric due to its size. So I decided to create a little break-out board that would be able to be sewed onto fabric. Taking inspiration from the lilytiny by Sparkfun, I decided to name my board the Echotiny.

I used eagle to draw my schematic, it is a very simple board consisting of an ATtiny44, a resistor, an ISP header, a resistor, an usb outlet and a capacitor.

I used a 100uF capacitor between the VCC and GND pin to stabilise the current flow. This is a common method call decoupling and it make sure that voltage spike does not interfere with our system. It is nothing else than a safety measure.

The 10k resistor between the reset pins serve as a barrier to make sure that the pin is not floating while not being sollicitated.



I did the routing using 15 thousand of an inch traces, this is a bit sketchy since I intend to mill this pcb, I will have to make sure that the cnc is well callibrated and ready to do precision work, but I really want to keep the design small and compact, and don't want to do two layer pcb since the goal is to make the board as easy and reproductible as possible.



All I had left to do was machine the board, to do so I use my 2x3' cnc and double sided tape to fix the copper sheet onto the sacrificial bed. The milling went great using my 0.1mm v-bit. Here are some demonstration.



As you can see in my video, I totally forgot to create a ground and VCC pin output, this mean that I had to solder a jumper wire directly on the Attiny44 pin wich is far from being optimal. I will have to do a second iteration of the circuit with that in mind, but we can still see that the circuit is working and programmable. Nice!

Building a heatpad

My goal for this week assigment is to make a heatpad for cramps relief that also has integrated vibration motors to massage the belly. Before doing anything serious I need to prototype and understand how will this all work.

To transform electric current into heat, all you really need is a resistor. The energy that flow trought the resistor transform itself into heat. This is what we call the principle of Joule heating. So yes... every electric heater that you have, from your toaster to your calorifier is basicly just a big old resistor!

This week I learn that a very comon material use to create heat out of an electric current is Nichrome. Nichrome is an alloy compose of Nickel, Chromium and Iron. It can be easily find on the market and is pretty cheap. Noemie and me decided to make a small test using a Nichrome wire that we weave using our weaver that we made few weeks back!



To make sure that the fibers in between the Nichrome wouldn't burn or take fire, we use polyimide tape, commonly known as Kapton. This heat resistant tape is perfect for absorbing the heat that will be generated from the nichrome wire. Please bare in mind this is only a prototype and is not supposed to look good in any way!

Programming an ATtiny

Before doing anything too complex, I wanna make sure that I had the right pipeline to easily program an ATtiny. I took a TH ATtiny85 and set it on a breadboard. I simply put an LED on the PB3 pin and set the ISP interface from the Atmel-ICE. One thing to consider is that the Atmel-ICE is not able to provide power to the chip, you will have to power the chip from an external source.



Once everything is wired up, we can go ahead and open Atmel Studio (wich is now named Microchip Studio). Inside Atmel Studio, we can open the device programming interface. And select our programmer and the chip that we want to program, If everything is wired correctly you should see a red and a green light on the atmel ICE, don't forget to power your attiny from an external source.



One the device signature is able to be read, we should be good to go. Atmel Studio is able to read arduino code. When you compile an arduino code, if you activate the verbose for the compiling, you should see the temporary folder in wich the compilation is set. you are looking for a .hex file. You have to keep in mind that before compiling, you have to set your board as an Attiny85 and use the internal 1Mhz crystal for the clock. To install the Attinys into your board collection on the arduino IDE you can follow this tutorial.



Then you can go into the memories tab and flash your code into the ATtiny, If everything is wired up correctly, you should see a LED blink!

Prototyping my final project

For my final project, I will need a fabric circuit that will play the role of outputting the data collected by multiple sensors. The circuit will be powering 9 to 11 neopixel. It will look a bit like this.



Since I alredy know a lot about the Arduino Architecture, I decided to switch my initial idea of using the Flora to an arduino Uno, it will also give me the possibility to connect my motor,sensors,output alltogether. For more information on this you can visite my final project page.

Each Neopixel can draw a maximum current of 60mA. An arduino Uno is capable of outputing up to 900mA trough it 5V pin using an external powersupply (since it is not connected directly to the MCU). It is also important to note that you can't output more than 40mA per logic pin and that the Arduino in itself draw around 50mA.



For my connector, I used those very cute and pratical rivet pins that gives me the ability to snap and unsnap my connection. I can even color code everythin to make things easy.



To program the neo pixel, I used the official Neopixel Arduino library provided by Adafruit wich is pretty easy to use and has a bunch of documentation here. You can find pretty much everything you need to know on there to program and have fun with your neopixels. Refer to my final project page for more information but here is the code for the whole system:

#include <Adafruit_NeoPixel.h> #include "SdsDustSensor.h" #include <dht.h> #define LED_PIN 9 #define enable 5 #define motorDir1 7 #define motorDir2 6 #define light A0 #define LED_COUNT 9 #define BRIGHTNESS 70 // Set BRIGHTNESS to about 1/5 (max = 255) #define DHT_PIN A1 dht DHT; Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // LedStrip uint16_t currentColor = 0; float currentBrightness = 0.0; float brightDelta = 0.5; // using StateDiagram logic enum State { opened, closed, opening, closing }; // REED SWITCHES + LIGHT const int reedOpened = 3; // Pin connected to reed switch const int reedClosed = 2; // Pin connected to reed switch const int lightTreshold = 300; //SDS011 const int airRxPin = 10; // txSensorPin const int airTxPin = 11; // rxSensorPin const int numAirReadings = 3; //numAirReadings is the number of data that it will be taken to creat a average data (smoothing the data) const int numChannel = 1; const float minAir = 0.0; const float maxAir = 100.0; const float minBrightDelta = 10; const float maxBrightDelta = 30; SdsDustSensor sds(airRxPin, airTxPin); float globalCurrentAirQuality = 0.0; //Timing unsigned long ledShowTime = 0; // 50 days max float readings[numChannel][numAirReadings]; float runningAverage[numChannel]; float total[numChannel]; int readingIndex = 0; State currentState; bool firstLoop = true; void setup() { pinMode(enable, OUTPUT); pinMode(motorDir1, OUTPUT); pinMode(motorDir2, OUTPUT); pinMode(light, INPUT); pinMode(reedOpened, INPUT_PULLUP); pinMode(reedClosed, INPUT_PULLUP); Serial.begin(9600); delay(100); strip.begin(); // INITIALIZE NeoPixel strip object (REQUIRED) strip.show(); // Turn OFF all pixels ASAP strip.setBrightness(BRIGHTNESS); sds.begin(); //sensor be prepare to work delay(100); Serial.println(sds.queryFirmwareVersion().toString()); // prints firmware version delay(100); Serial.println(sds.setActiveReportingMode().toString()); // ensures sensor is in 'active' reporting mode delay(100); Serial.println(sds.setContinuousWorkingPeriod().toString()); // sensor sends data every 3 minutes delay(100); //initializing variables for air sensor for (int channel = 0; channel < numChannel; channel++) { runningAverage[channel] = 0; total[channel] = 0; for (int reading = 0; reading <= numAirReadings; reading++) { readings[channel][reading] = 0; } } //should be closing or opening, other states cannot be used as starting states currentState = closing; setDirBreak(); // speed won't change so why not int pwmOutput = 255; analogWrite(enable, pwmOutput); // Send PWM signal to L298N enableble pin } void loop() { // Serial.println(currentState); // delay(1); switch (currentState) { case opening: if (digitalRead(reedOpened) == LOW) { setDirBreak(); currentState = opened; } else if (firstLoop) { firstLoop = false; setDirOpening(); } break; case opened: if (analogRead(light) > lightTreshold) { currentState = closing; setDirClosing(); } break; case closing: if (digitalRead(reedClosed) == LOW) { setDirBreak(); currentState = closed; ledShowTime = millis(); } else if (firstLoop) { firstLoop = false; setDirClosing(); } break; case closed: if (analogRead(light) < lightTreshold) { strip.clear(); strip.show(); currentState = opening; setDirOpening(); } else { unsigned long currentTime = millis(); if ((currentTime - ledShowTime) % 1000 == 0) { int chk = DHT.read11(DHT_PIN); int currentTemperature = DHT.temperature; setStripColor(currentTemperature); } if ((currentTime - ledShowTime) % 500 == 0) { float currentAirQuality = monitorAirQuality()[0]; //FOR DEBUGGING ONLY globalCurrentAirQuality = currentAirQuality; //Serial.println(currentAirQuality); //delayMicroseconds(100); float constrainedAirQuality = constrain(currentAirQuality, minAir, maxAir); int brightSymbol = 1; if (brightDelta < 0) { brightSymbol = -1; } brightDelta = brightSymbol * mapfloat(constrainedAirQuality, minAir, maxAir, minBrightDelta, maxBrightDelta); } //will adjust hardware and update currentBrightness and invert brightDelta setStripBrightness(); //DEBUG Serial.print(currentBrightness); Serial.print(" "); delayMicroseconds(10); Serial.print(brightDelta * 100); Serial.print(" "); delayMicroseconds(10); Serial.println(globalCurrentAirQuality * 10); delayMicroseconds(100); } break; } } // Utility functions to set motor directions void setDirOpening() { digitalWrite(motorDir1, LOW); digitalWrite(motorDir2, HIGH); delay (1); } void setDirClosing() { digitalWrite(motorDir1, HIGH); digitalWrite(motorDir2, LOW); delay (1); } void setDirBreak() { digitalWrite(motorDir1, LOW); digitalWrite(motorDir2, LOW); delay (1); } float* monitorAirQuality() { //read data PmResult pm = sds.readPm(); if (pm.isOk()) { for (int channel = 0 ; channel < numChannel ; channel++) { // subtract oldest reading total[channel] = total[channel] - readings[channel][readingIndex]; if (channel == 0) { //Serial.println("---CHANNEL 25 ---"); //readingIndex = l'offset de l'index (0-1-2-3-4-5) readings[channel][readingIndex] = pm.pm25; } else if (channel == 1) { //Serial.println("--- CHANNEL 10 ---"); readings[channel][readingIndex] = pm.pm10; } //update totals total[channel] += readings[channel][readingIndex]; //update average runningAverage[channel] = total[channel] / numAirReadings; //Serial.println(runningAverage[channel]); //delay(1); } //update index readingIndex++; if (readingIndex >= numAirReadings) { readingIndex = 0; } } else { //Serial.println("Could not read values from sensor."); //delay(1); //Serial.println(pm.statusToString()); //delay(1); } return runningAverage; } void setStripColor (int temperature) { uint16_t constrainedTemperature = constrain(temperature, 14, 30); uint16_t mappedTemperature = map(constrainedTemperature, 14, 30, 32767, 0); uint32_t newColor = strip.ColorHSV(mappedTemperature, 255, currentBrightness); currentColor = mappedTemperature; //Serial.println(temperature); //Serial.print(" "); //delay(1); //Serial.print(mappedTemperature); //Serial.print(" "); //delay(1); //Serial.print(constrainedTemperature); //Serial.print(" "); //delay(1); //update strip hardware //strip.fill(newColor); //strip.show(); } // dont use setBrightness: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use void setStripBrightness() { float newBrightness = currentBrightness + brightDelta; if (newBrightness >= 255) { newBrightness = 255; brightDelta = -brightDelta; } else if (newBrightness <= 0) { newBrightness = 0; brightDelta = -brightDelta; } currentBrightness = newBrightness; uint32_t newColor = strip.ColorHSV(currentColor, 255, newBrightness); strip.fill(newColor); strip.show(); } float mapfloat(float x, float in_min, float in_max, float out_min, float out_max) { return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min; }