Category: Uncategorized

Next week the weaving codes project assembles in the Museum für Abgüsse Klassischer Bildwerke in Munich. We’ll be working for a few days surrounded by these characters to get us in a classical mood:

The museum is hosting Ellen’s ‘Textile Matrix’ exhibition, a crossbreeding of logical science, religion, crafts and visual arts. The word ‘matrix’ originates from the latin word for mother or uterus, but today is predominantly used in mathematics, science and technology. Her work, as much of the weavingcodes project, provides new perspectives on connections between modern digital technology and ancient weaving.

Alex, Ellen, Emma and I will be in residency in the museum from the 6th May and I’ll be reporting our activities here as usual. On the 9th there will be talks and slub will be performing a special livecoding gig. On the 10th we will be presenting the work we have been doing during the residency and inviting people to participate in a citizen science event, exploring mathematics, weaving, music and code – including the brand new pattern matrix tangible weavecoding device.

Here is a member of staff at Miners Court trying some tangible weave coding in the midst of our crafts area – at the moment it’s simply displaying the weave structure on the simulated warp weighed loom with a single colour each for warp and weft threads, the next thing is to get ‘colour & weave’ patterns working.

The pattern matrix is the second generation of tangible programming device from the weavecoding project. It’s been built as an open hardware project in collaboration with Falmouth University’s Makernow fablab, who have designed and built the chassis using many 3D printed parts and assembled the electronics using surface mount components (far beyond my stripboard skills).

Here you can see the aluminium framework supporting the AVR based row controller boards with the Raspberry Pi in the corner. The hall effect sensors detect magnetic fields – this picture was taken before any of the wiring was started.

The row controllers are designed to read the sensor data and dispatch it to the Raspberry Pi using i2c serial communication running on their atmega328 processors. This design was arrived at after the experience of building flotsam which centralised all of the logic in the Raspberry Pi, resulting in lots of wiring required to collect the 128 bits of information and pass it to the GPIO port on the Pi. Using i2c has the advantage that you only need two wires to communicate everything, processing can be distributed and it can be far more modular and extendible in future. In fact we plan to try different sensors and configurations – so this is a great platform for experimenting with tangible programming.

This video shows the current operation of the sensors and row controllers, I’ve programmed the board with test code that displays the state of the magnetic field with the status LED, making sure that it can tell the orientation of the programming block:

The row controllers have a set of multiplexers that allow you to choose between 20 sensor inputs all routed to an analogue pin on the AVR. We’re just using digital here, but it means we can try totally different combinations of sensors without changing the rest of the hardware.

After getting the first couple of rows working and testing it with elderly people at our Miners Court residency there were a couple of issues. Firstly the magnets were really strong, and I worried about leaving it unattended with the programming blocks snapping together so violently (as we plan to use it in museum settings as well as at Miners Court). The other problem was that even with strong magnets, the placement of the blocks needed to be very precise. This is probably to do with the shape of the magnets, and the fact that the fields bend around them and reverse quite short distances from their edges.

To fix these bugs it was a fairly simple matter to take the blocks apart, remove 2 of the 3 magnets and add some rings to guide placement over the sensors properly:

Our work on weavecoding is now reaching out to other uses and projects. One is Future Thinking for Social Living, run by Magda Tyżlik-Carver and Fiona Hackney.

This research project aims to look at the relationship between wellbeing, home, making and technology and is centred on Miners Court, who provide assisted housing in Redruth in Cornwall. As well as a range of flats and accommodation, the residents have shared communal areas with a variety of activities throughout the week. Along with Christiane Berghoff, Robin Hawes and Lucie Hernandez we set up camp with a lot of materials for knitting, crochet and weaving as well as some Raspberry Pis and the all new pattern matrix tangible weavecoding device.

The Future Thinking for Social Living project is set up to research how we can think more critically about home and community, and with particular focus on the future. From discussions with the staff at Miners Court – specific issues they are interested in are how to make better use of communal spaces, and how can they get more men involved with crafts and shared activities.

I’m also interested in how we can use these settings for artists residencies – how does working with people like this affect a design process, does working in such a place – and using it as way to start conversations (rather than being too much in ‘teacher mode’) affect the people living there positively? Also the weavecoding project provides some ideas in bridging gaps, both between technology and people – but also across gender gaps, mixing textiles with electronics for example.

Here is the new magnetic pattern matrix, running the 3D Raspberry Pi warp weighted loom simulation (more on this soon!) with a nice 4 shaft loom in the background.

On Monday and Tuesday we spent a long time talking, weaving, knitting and making cups of tea of course (and a bit of time debugging magnets on my part). I’ve found helping people weave with tablets on the inkle loom is a good way to get talking, as this seems new to even people who are experienced with crafts. It also appeals to people with mathematics or design background who normally are uninterested in knitting and other crafts, and seems gender neutral perhaps for the same reasons. It also helps to talk about the history of what we are weaving with, the fact that this is an ancient technique and yet there are so many surprises – I can’t really predict to them what will happen e.g. to the pattern when we change rotation direction, and this seems to be important.

What we have yet to do (but a few weeks to experiment yet) is bridge the technology gap. Many of them have an immediate reaction of distaste to computers, as most of them have them but report that they have become unusable or feel that they are not designed well with their needs in mind. Partly the situation of having some circuit boards getting tangled up in the more familiar materials and using the Raspberry Pi simulation to show what is happening on the loom next to it is a start. One interesting thing is that neither the Pi nor the AVR boards look enough like ‘a computer’ for it to stand out too much (which also part of the Pi’s role in the classroom) – this was more so after plugging it into their large TV and getting rid of the monitor. As it gradually gets into a working state, I’d like to first try using it to demonstrate well known weaves – e.g. plain, twill and satin.

Working in this environment on the pattern matrix between weaving with different people has already had an effect on it’s design process. One initial observation resulted in reducing the magnet strength – I hadn’t even considered before that having them snap together too forcefully would be a problem for some people. Such things are obvious in these kinds of settings.

Midway through the weavecoding project and our researches have thrown up a whole load of topics that either don’t quite fit into our framework, or we simply won’t have time to pursue properly. Here are some of the tangents I’ve collected so far.

Coding with knots: Khipu

One of the cultures I’m increasingly interested in are the Incas. Their empire flourished to up to 37 million people, without the need of money or a written language. We know that some numeric information was stored using Khipu, a knot based recording system which was used in combination with black and white stones to read and calculate. Two thirds of the quipus we have are un-translated, and do not fit into the known numeric coding system – what information do they hold?

Harvard University provides a Khipu Database Project with many surviving examples documented – I’m hoping to run a workshop soon to look through some of this data in a variety of ways.

Tablet weaving NAND gates

Diagram thanks to Phiala’s String Page – the only place I’ve seen tablet weaving explained properly.

There are logic gates in tablet weaving logic. I haven’t fully figured this out yet, but I noticed modelling tablet weaving that you end up basically mapping the combinations of the weaving actions (such as turn direction) and colour as truth tables.

Top face colour based on top left/top right hole yarn in a single card and turn direction (clockwise/counter clockwise)

TL Yarn : TR Yarn : Turn : Top face colour
--------------------------------------------
Black   : Black   : CCW  : Black
Black   : Black   : CW   : Black
Black   : White   : CCW  : Black
Black   : White   : CW   : White
White   : Black   : CCW  : White
White   : Black   : CW   : Black
White   : White   : CCW  : White
White   : White   : CW   : White

Things get stranger when you include twist and combinations of actions with multiple cards. Would it be possible to compile high level programming languages into weaving instructions for carrying out computation? Perhaps this is what the untranslatable quipus are about?

Nintendo made a knitting machine

We could really do with some of these, unfortunately they never went beyond prototype stage.

Asemic writing

Asemic writing is a post-literate written form with no semantic content. Miles Visman programs procedural asemic languages and hand weaves them. I think this may be an important connection to livecoding at some point.

More photos from the Makernow fablab, the pattern matrix weavingcoding device is starting to take shape! All schematics, 3d printing shapes and plans will be released soon as open source hardware on the weavecoding repo.

We’re starting construction of version 2 of the flotsam tangible programming device, specialised to weaving – and henceforth known as the ‘pattern matrix’. This will be tested during May at our upcoming performance/workshop/residency at Munich’s Museum für Abgüsse Klassischer Bildwerke (Museum of Casts of Classical Sculpture) with the Coding weaves project, and then for later use in Cornwall (more on that part soon).

The first thing we are exploring is removing the need for physical plugs – although I like them a lot, they are problematic for people as it takes time to learn how to align the blocks in the current prototype. In order to get around this, and maintain the cheapness of the programming blocks themselves we’re looking at using magnetism to represent information. We can use blocks with no connections, painted white and black on different sides and detect their orientation and position via a magnet in the centre.

Initially this idea came from thinking about reed switches with Francesca, and playing with mobile phone magnetometers on the UAV project led to us investigating Hall effect sensors (the building blocks of magnetometers). We had a bit of a testing workshop with Andy from the Falmouth University makernow fablab who are helping with construction of this project.

Hall effect sensors allow us to detect the polarity of nearby magnetic fields – and seem to be restricted enough in range that they can be very precise. Even with fairly weak magnets we found we could put the sensors right next to each other (see above) and still determine the difference between two opposed or aligned fields.

For the warp/weft weave pattern structure we only need 1 bit of information to be detected, but for future extensibility for the yarn colour programming setup it’s important to be able to read more (4 bits are encoded in the flotsam blocks).

Our plan is to try putting 4 sensors in a square which adds an intriguing possibility of rotating the blocks to change their meaning, as well as flipping them. The great thing is that this gets very close to tablet weaving in terms of the notation and the actions required. We can also represent all 16 states with only 4 blocks – if negative is 0 and positive is 1, and we read the code as binary clockwise from top left:

Starting state [0,1,5,6]
- -   + -   + -   - +
- -   - -   - +   - +

Rotate clockwise [0,2,10,12]
- -   - +   - +   - - 
- -   - -   + -   + +

Horizontal flip [15,11,10,12]
+ +   + +   - +   - - 
+ +   + -   + -   + +

Rotate counter-clockwise [15,13,5,6]
+ +   + -   + -   - + 
+ +   + +   - +   - +

Vertical flip [0,4,5,6]
- -   - -   + -   - + 
- -   - +   - +   - +

Here is Andy’s design for the PCB we’ll use under each of the 25 board locations:

Thanks to some funds from the Creative and Cultural Industries Exchange, University of Leeds, I’ve had the pleasure of a week’s research residency within Access Space in Sheffield, working within the highly creative environment of their fabrication/maker lab, to really get to grips with the ancient technology of the warp weighted loom, within the context of advanced digital manufacture.

This was a bit of a chicken-and-egg situation; I hadn’t really woven anything before, but wanted to make my own loom to learn on. Ellen suggested just lashing together four sticks and jumping in, which is what I did:

This loom was pretty terrible to use; wobbly, and I knew that making heddles out of paperclips was a bad idea, they constantly got caught on the wrong threads. But, I needed to learn from failure at this point, and despite all chance to fail, managed to weave (and unweave) a small piece of fabric. What I enjoyed most was tying the thread evenly spaced across the top beam for the warp threads to hang from. I’ve done a lot of knitting in the past, and this felt a lot like casting on. The knowledge for doing this was already in my fingers, a surprise to feel it there which made the confidence flow.

Next was the actual residency, beginning with an induction on lasercutting with John Moseley, my technical and engineering support for the week.

I was a bit worried about jumping into laser cutting, that making things via computer-aided design would distance me from the material. At least with the way John encouraged me to work, this did not turn out to be a problem at all. I sketched out some ideas, and then when straight to the laser cutter to see how they worked. This connected my thought and design processes with the material and the way of making, considering the order of cut, how to avoid cut pieces pivoting and blocking the laser, how the stickiness of the burnt MDF would help or hinder what I’m doing, and so on.. More than all this just holding the pieces in my hands made so much clear and avoided so much theoretical wrangling.

Within a couple of days I had a nicely balanced single-shaft loom with space for a camera and projector to be mounted:

The focus of the residency was not only to make a loom, but experiment with how it could be ‘augmented’ with contemporary technology. This is a bit of a tightrope, because the warp weighted loom is excellent, well developed technology which does not really need augmenting. Nonetheless, despite sometimes ending up in the domain of heritage, I think the nature of craft is not to stay still but to be alive and personal, and it felt right to make a loom customised for myself, and look for ways of extending it with additional sensory apparatus.

Tying the heddles came less naturally to me,  I managed to make some more or less the same length by spacing them using two dowels.

Then straight into some actual weaving, making some plain weave:

As you can see I used some of access space’s hex nuts for weights, five per thread. I used a ruler to beat in the thread. The little symbols on the front are fiducials which might help with future computer vision experiments.

Here’s my first weave on the loom:

https://www.youtube.com/watch?v=LNlOAYWBe0M

The fabric I ended up with charts my learning, starting off messier, getting better, then worse again as I try out different techniques, for example beating in the thread with the shed open and then again with it closed, through the counter shed. I’d like to keep the fabric I made, but in the spirit of live coding, I’ll probably unweave it.

Next directions include:

• Adding more shafts!
• Developing a programming language for describing/generating/exploring weave structures and loom configurations
• Exploring projection mapping with a camera and projector to project the structure onto the fabric
• Exploring picking without shafts, vibrating the strings (e.g. using wireless controlled motors in the warp weights) to indicate which goes over vs under
• Exploring unweaving – can this be automated? It would be great if the loom could automatically unweave whenever it isn’t being used. Ellen will have some thoughts on this I’m sure
• Releasing the laser cut source files with a creative commons license
• Developing a workshop where people construct and use their own loom
• Seeing if the loom can be used as a musical instrument
• more to come…

I’ll explore projection mapping, buzzing and sensors on the final day of my residency. For now I’m really pleased with what I’ve achieved so far in Access Space, I already have a warp weighted loom design that can be cut in minutes at very little cost, that fits in the laptop section of my bag, is sturdy, well balanced and a fantastic framework (literally, and theoretically) for ongoing research. I really recommend these residencies for other researchers who want some time outside their institution to work with material, it’s opened things up for me.

The CCI Exchange funds will also pay for some related events and workshops at Access Space, follow them on facebook or twitter if you’re in the Sheffield area to stay up to date.

Research symposium: Threads and Codes
http://kairotic.org/threads-codes/

10am-6pm, 6th March 2015
137 Richard Hoggart Building, Goldsmiths, New Cross, London SE14 6NW

The symposium is now full. Please use the comment form to join the reserve list.

The Weaving Codes, Coding Weaves project explores the practices of weaving and computer programming together, considering both looms and computers as algorithmic environments for creative work with pattern. The connection between computing and the Jacquard loom is well known, but we want to go deeper in history and philosophy, to investigate traditional work with threads for its digital nature, including the genesis of discrete mathematics in ancient looms. This will provide an unravelling of contemporary technology, finding an alternative account of computer programming with its roots in arts and craft. On this basis this symposium will investigate contemporary theoretical points where textile and code-based crafts connect.

All interested researchers and practitioners are warmly invited to join us for Threads and Codes, an all-day symposium which will consist of diverse talks and panels exploring the above topics, co-organised by Dr Ellen Harlizius-Klück (International co-investigator), Dr Alex McLean (principal investigator) and Prof Janis Jefferies (project partner). The results of the symposium will feed into a special issue of Textile: The Journal of Cloth and Culture.

Confirmed speakers

• Flavia Carraro, Centre for Textile Research, Copenhagen
  http://is.gd/fcarraro
• Emma Cocker, Nottingham Trent University
  http://not-yet-there.blogspot.co.uk/
• Nigel Morgan, Tonality Systems
  http://nigel-morgan.co.uk/
• Ellen Harlizius-Klück, Centre for Textile Research, Copenhagen
  http://www.saumweberei.de/
• Janis Jefferies, Goldsmiths, University of London
  http://www.gold.ac.uk/computing/staff/j-jefferies/
• Ebru Kurbak, University of Applied Arts, Vienna
  http://ebrukurbak.net/
• Alex McLean, University of Leeds
  http://yaxu.org/
• Simon Yuil, Goldsmiths, University of London
  http://www.lipparosa.org/
• Theo Wright, Designer and Weaver, Coventry
  http://www.theowright.co.uk/

We will update with the full programme soon.

Weaving Codes, Coding Weaves is a Digital Transformations project funded by the Arts and Humanities Research Council, UK. For more information on the project, see http://kairotic.org/

One of the main objectives of the weavecoding project is to provide a simulation of the warp weighted loom to use for demonstrations and exploration of ancient weaving techniques. Beyond the 4 shaft loom dyadic calculator we need to show the actual process of weaving to explain how the structures and patterns emerge. Weaving is very much a 3D process and these visualisations fail to show that well. It also needs to be able to be driven by the flotsam tangible livecoding hardware so running on a Raspberry Pi is another requirement.

I’ve decided to make use of the Jellyfish procedural renderer to build something fast and flexible enough, while remaining cross platform. Jellyfish is a lisp-like language which compiles to a vector processing virtual machine written in C++, and approaches speeds of native code (with no garbage collection) while remaining very creative to work with, similar to fluxus livecoding. Previously I’ve only used it for small experiments rather than production like this, so I’ve needed to tighten up the compiler quite a bit. One of the areas which needed work (along with function arguments which were coming out backwards!) were the conditional statements, which I removed and replaced with a single if. Here is the compiler code at the lowest level which emits all the instructions required:

;; compiler code to output a list of instructions for (if pred true-expr false-expr)
(define (emit-if x)
  (let ((tblock (emit-expr (caddr x))) ;; compile true expression to a block
        (fblock (emit-expr (cadddr x)))) ;; compile false expression to block
    (append
     (emit-expr (cadr x)) ;; predicate - returns true or false
     (emit (vector jmz (+ (length tblock) 2) 0)) ;; if false skip true block
     tblock
     (emit (vector jmr (+ (length fblock) 1) 0)) ;; skip false block
     fblock)))

Then I can implement cond (which is a list of different options to check rather than one) as a purely syntactic form with a pre-processor function to create a series of nested ifs before compiling them:

;; preprocessor to take a cond list and convert to nested ifs 
(define (preprocess-cond-to-if x)
  (define (_ l)
    (cond
      ((null? l) 0)          ;; a cond without an else returns 0 
      ((eq? (caar l) 'else)  ;; check for else clause to do
          (cons 'do (pre-process (cdr (car l)))))
      (else (list 'if (pre-process (caar l)) ;; build an if
          (cons 'do (pre-process (cdr (car l))))
                  (_ (cdr l)))))) ;; keep going
  (_ (cdr x))) ;; ignores the 'cond'

Here’s an example of the if in use in the loom simulation at the ‘top’ level – it gets the current weaving draft value for the weft and warp thread position and uses it to move the weft polygons forward or back (in the z) a tiny amount to show up on the correct side of the warp.

(define calc-weft-z
    (lambda ()
        (set! weft-count (+ weft-count 1))
        (set! weft-z
              (if (> (read-draft) 0.5)
                  (vector 0 0 0.01)
                  (vector 0 0 -0.01)))))

One of the reasons I’m writing about all these levels of representation is that they feel close to the multiple representations present in weaving from draft to heddle layout, lift plan, fabric structure and resulting pattern.