Process¶
I've been keeping a digital journal of my thought and design and build process since the start of this whole deal. I tried cleaning it up for the purpose of clearer documentation to the reader. Hopefully it's clear to anyone (including myself) visiting or revisiting this space. 'Tis the design process!
But first my process in a more coherent nutshell :3
Think of uploading your hand-drawings, "frankenstein prototypes", pictures with notes, everything that shows your thinking process and initial development of your personal project. Giving inside in your process, will help the mentors to assist you further in your development.
research papers can also be linked through an online link or when optimised, PDFs of research papers can be added to your repository and credited to the writer or researcher
Design & Fabrication¶
once you start designing and fabricating your first tests, you can link both at the bottom of the page with footnotes
"This step of the process was important because i learnt to draft my own pattern digitally. The first tests of this can be seen here on the right, find half- or test-fabrication files here[^1]"
Prototypes¶
prototypes are your first step towards shaping your final piece, product, material et cetera
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.
Mentoring notes¶
Mentors in all sessions may share with you their comments, notes, advise, projects and technical equipment to check out. This is good place to share those, so that you can find them later on when you need them the most!
Week 1¶
I made a very preliminary gantt chart and BoM this week. I didn’t do much but think and think and think about my project. Not much doing or researching, just a bunch of thinking.
I did get helpful references! Here they are:
- ZOMBITRON
- Sophie Skach - info@sophieskach.com
- Michelle Vossen
- Jessica Stanley
- Intelligent Instruments Lab - Nicola Privato
- Passepartout Duo
Resources:
- DXARTS Softlab - Resources tab of website
- Adafruit
- Pure Data
- Intelligent Instruments Lab
- Adafruit E-Textiles
- Instructables
Week 2¶
I refined my gantt chart this week and made a trello board! Hooray!
Slowly but surely this is coming along.
Now I was posed a couple of options for synths by Nicola P. from the Intelligent Instruments Lab:
- DIY Analog Synth - could by a kit and assemble one of these
- Virtual Synth on your Computer (using Pure Data)
- Build a synth using a microcontroller - microcontroller, digital to analog converter, amplifier, and a speaker.
Which one is best for my vision?... I don’t know. I like the Arturia Microfreak. And I also like the breadboard synth built by this guy.
Well, really, the questions this week are:
- What datasets do I want to visualize/sonify in my project?
- What kind of synthesizer do I want to embed?
- What kind of loom do I want to develop patterns and weave on?
- What kind of folding patterns can and will I develop?
- What kind of language am I developing to turn data into binary
I also found that the same guy I hyperlinked above made a drum machine using rope core memory which was used as the guidance navigation computer for Apollo 8! Side note for either this project or the DXARTS Softlab residency :0 :0
Anyway, I went on a bit of a break which is both a blessing and a curse. It’s Sunday, Jan. 18th and I’m scrambling. But let’s delve into this. A couple of things we need to handle:
- Which synth type do I want to build for this project?
- Once I decide which synth, what materials do I need to prototype it?
- Once that list is defined, order those materials
If I have time I'll address these:
- Research data sonification
- Start developing data-yarn-sound language - logic diagram
DIY Synths
Arturia MicroFreak
The Arturia MicroFreak synthesizer is a hybrid synthesizer. It contains:
- Digital oscillator engines — including wavetable, FM-style, granular, physical modeling, and more
- Analog filter — state-variable filter shaping the tone
- Expressive interface — flat capacitive keyboard with polyphonic aftertouch and touch strip
- Sequencer & arpeggiator built in
- CV/Gate outputs — for controlling external gear with pitch and gate signals
- USB/MIDI connectivity — so it can interface with computers or other synths/controllers too
It’s compact but powerful, and it’s praised for being both a fun sound-design instrument and a creative performance synth.
^^ This was from my research on ChatGPT.
Before I continue, let me actually frame the intention of this project better: My intention is to experiment translating a hardware synth to a soft synth. Point one. I do want a particular sound, truthfully, and the sound I’m intending on replicating is that of a twinkling celesta. It’s honestly a sound that I would consider to be warm and hopeful, much like a home, TO ME. HOWEVER, if the synth is supposed to act as a tool or object that could be modified to be “home” for others, then the sound emanating from their synth might be different, also dependent on weaving and folding patterns. SO, that said, I want to make a versatile and responsive textile synth.
I’ve looked lightly through kits that are sold on musicfromouterspace.com and my Make: Analog Synthesizers book but I think I can safely say that my choice synth for this project is an analog one.
Jessica Stanley’s documentation for her soft synth really was and is a great source for my project. She was looking into kits as well but I didn’t want to spend all this money buying a kit. I wanted to bring the components together myself without the help of a kit. I decided I would prototype a synth using “Look Mum No Computer’s” video on building an analog synth from scratch using a breadboard.
It’s a more advanced synth but I think experimenting with it would prove useful.
As I build this synth up, I may continue researching and switching out components should I decide to depending on what the sound is.
Let me step aside and say translating this to textile, we need to think. A synthesizer’s components that are in place for human interaction are potentiometers and keys. So how can I translate these components into weaving or folding structures that would allow for a textile synthesizer to be as a playable as a hardware analog synth.
Onto what was left on my list:
- Research data sonification
- Start developing data-yarn-sound language - logic diagram
Rico K., bless him, gave me some pretty awesome feedback regarding my project. He also mentioned he had done a data sonification program/class recently.
That link above is some of his documentation. This is interesting and I do think I may take some points from his work but I think the difference for my project is I’m sonifying patterns that are made up of data (binary). Which reminds me, this is the logic I’m dealing with.
Any data set → Converts to binary → Map binary pattern to CV (or controlled voltage) values → Guides creation of weaving and/or folding pattern based on binary
I realize right now that folding may complicate things more than they already are. But I’m prototyping this coming week so we’ll see how this goes.
Just like in my concept page, I'm listed the books recommended by Jessican Stanley in her documentation. I agree, they do look pretty rad.
- Zeros and Ones by Sadie Plant
- The Art of Electronics by Horowitz and Hill
- Handmade Electronic Music by Nicolas Collins
- Textile Messages, edited by Leah Buechley
- Getting Started in Electronics by Forrest M Mims III
Week 3¶
I’m currently working through a problem. I’m using data (binary data) to generate weaving and folding patterns. Okay? With me? Now, I’m translating those patterns in physical form. Okay, good. Sounds difficult but my brain can wrap my brain around that. Solid. But NOW I want those woven and folded samples to produce a synth effect. How can I do that when I have to weave conductive traces in the form of the specific pattern (based on the different datasets!) woven or folded? I mean how the hell do I do that???! Should I weave this data pattern with colored yarn and weave traces along some indiscriminate path along the sample to produce a synth effect. I don’t know. But I’m talking to Passepartout Duo next week on 1/25 and I’m going to email Sophie Skach for some help. She’s an e-textiles guru.
Two days later.. No response from Sophie yet. I’m meeting with Passepartout Duo tomorrow night. AND Louise gave me some helpful insight into my problem, and I quote:
Hello Marissa, it seems to me that you have 2 types of inputs: the datasets (type 1) and the actions on the e-textiles (type 2 maybe capacitive sensors?). What would be the goal of each types?
For instance: one dataset informs your tones/melody and then with the capacitive sensor you are able to modulate it. One dataset can inform your shapes/weaving patterns too. But if you are looking for a dataset that informs the modulation I think you need to list the different types of modulations possible with their interval, minimum and maximum value to remap the dataset to this interval. (for example: your dataset goes from 2 to 50 but your interval is 0V to 9V so your 2 is going to correspond to your 0V and 50 to 9V and all data in between 2 to 50 will be remap from 0 to 9).
Maybe those documentations can help:
Kobakant synth example: https://www.kobakant.at/DIY/?p=9948
Kobakant synth example 2: https://www.kobakant.at/DIY/?p=9812 hope this help!
It does help! Because I have to think okay my datasets will be weaving new patterns, new patterns based on data that will essentially produce synth effects like an oscillator, mixer, LFO, envelope, etc. BUT those patterns can also generate a series of textile sensors that act as inputs. Where when you touch those textiles, it acts like a keyboard on an analog synthesizer.
This week I spent a lot of time thinking about and starting to build a circuit out for this really cool synth but it gets really complicated, really fast. And if I think of my project, I want people to be able to see this project through to completion for their own purposes and reflection. So as much as I spent on researching and buying components and so forth, I didn’t put as much time into the textiles portion of my project. I’ll paste a picture of my breadboard circuit with 2 oscillators and a mixer. It’s involved, trust.
So, my goals for this coming week are to dial it in and reel it in. I’m speaking to Nicolette of Passepartout Duo tomorrow night and hoping to clear up some of my questions about integrating and working with e-textiles and sound. I’m simplifying the modules I do want on the synth and prototyping/testing those on a breadboard. I’ll be weaving some samples on a hand loom and setting out to see what the layout of this synth would be. Oh man, it’s gonna be a busy week but we got this.
Another 2 days later.. I met with Passepartout Duo (Chris and Nicoletta) and they provided some very important insight. So they pointed me to check out Kobakant, https://afroditipsarra.com/ (who’s the person in charge of the DXARTS Softlab residency I applied to! Hope i get in but ill try managing expectations), and Irene Posch.
Plus they shared other textile labs with residencies and/or access to TC2 looms.
- https://www.textilmidstod.is/en/textile-residency/about-the-residency
- https://textiellab.nl/en/advanced-textile-program
- https://www.lottozero.org/residency
Now, I explained my idea and Chris posed 2 possibilities: I weave data according to patterns generated via datasets that include conductive yarn/thread which, when connected to a microcontroller, can become a sort of digital synthesizer. That option basically allows you to have any sound you want because you can program that in to the microcontroller along with a DAW (i.e. Ableton).
The 2nd option is I think more organic to my project. Which is weave data with colored yarn and conductive yarn along with different CMOS components and analog synth hardware (transistors, resistors, ICs, etc.) to essentially produce analog sounds based on binary data. He said data would be present as conductive thread (like a punch card) woven in binary and then you translate that binary to sound.
It’s very hard to create a totally soft synth. You can make a relay, primitive resistors, a kind of capacitor, and decode binary into sound but you can’t produce all this hardware in “soft” form. T
They encouraged me to look into music boxes and rope memory to see about a synthesizer. If I wanted to go the rope memory route, Chris recommended using a parachute cord to insulate. Remove the yarn from the inside and replace it with conductive yarn. They also pointed me to past projects of theirs where they’ve tried translating binary to sound. They both also recommended I look into using an embroidery machine with copper wire and (perhaps later) a TC2 loom.
- https://passepartoutduo.com/40xx-synth
- https://passepartoutduo.com/state-machine
Then, Nico posed another consideration: Consider the long-term survival of the materials. And I thought WHOA. That's actually very profound. What if things we find meaningful aren’t made to last physically. The object doesn’t matter. Also what kinds of sounds are produced from decay and wear?
So, during the weekend I started prototyping an analog synth on breadboards and honestly it got complicated super fast. I mean doable still! But not entirely conducive to the project. If I want people to make it, it won’t be an easy task.
This week I have a lot ahead of me.
Let’s reframe the scope now, given the info from Chris and Nico.
- [ ] Define more or less simple synth modules (LFO, oscillator, etc.)
- [ ] Prototype small sample woven synth module w/ CMOS and more components (or at least draw circuit diagrams and maybe “test” them on LTSpice)
- [ ] Investigate translating binary to sound (Chris and Nico documentation)
- [ ] Warp structo loom
- [ ] Weave samples in simple handloom
- [ ] Fold samples as potentiometers
- [ ] Kirigami/Origami Potentiometers
- [ ] Design out textile/synth layout (what will it look like, how will it connect?)
- [ ] Program translation from dataset to binary
- [ ] Shell script?
- [ ] Python?
- [ ] Translating data to weaving patterns - Code to Excel to Treadl
- [ ] Excel
- [ ] AdaCAD
- [ ] Buy yarn (after making samples)
- [ ] Update BoM
- [ ] Update Gantt chart
- [ ] Visualize understanding through presentation, pitch, and flowcharts
Let’s start at the top of my list. Define my modules.
An analog synthesizer works by using voltage-controlled circuits (VCOs, VCFs, VCAs) to generate and shape sound, relying on physical components like oscillators for pitch, filters for tone (removing frequencies), and amplifiers for volume, all controlled by electrical signals and shaped by modules like envelopes (ADSR) and LFOs to create evolving sounds, unlike digital synths that use binary code. A keyboard press sends a control voltage (CV) to trigger these modules, turning a raw waveform into a musical tone.
Key Components & Signal Flow:
Oscillator (VCO): The sound source, generating basic waveforms (sine, saw, square, pulse) whose pitch is controlled by voltage.
Filter (VCF): Shapes the sound by removing frequencies (e.g., low-pass, high-pass) to alter the timbre, with controls for cutoff and resonance.
Amplifier (VCA): Controls the sound's overall volume, opening and closing based on control voltage.
Envelope Generator (EG/ADSR): Shapes the sound's volume or brightness over time (Attack, Decay, Sustain, Release) when a key is pressed.
Low-Frequency Oscillator (LFO): A slow oscillator used to modulate other parameters (like pitch for vibrato or filter cutoff for movement).
The Process (Subtractive Synthesis):
Sound Creation: A VCO generates a complex waveform (like a sawtooth).
Initial Shaping (Filter): This waveform goes through a VCF, which cuts out unwanted high frequencies, making the sound darker.
Volume Shaping (Envelope): An EG controls the VCA, so the sound gradually fades in (Attack), holds (Sustain), and fades out (Release) when the key is lifted, rather than just cutting off.
Modulation (LFO/EG): An LFO can add a subtle vibrato by slightly altering the VCO's pitch, or an envelope can control the filter to make the sound brighter at the start and darker as it decays.
To be honest, I’d like to make a synth w/ all components if I can: an oscillator, a low pass, high pass filter, an amplifier, an envelope generator (ADSR), and a low-frequency oscillator.
Week 4¶
At the end of last week (1/27), I went to the Fabricademy mentoring session and had to present my progress. It made me realize how ILL PREPARED I WAS. How a lot of my work as of yet has been focused on thinking through my concept. In fact, the comments I got were how I had a lot on my plate and I ran the risk of potentially not finishing by the end of Fabricademy.
So, I made an updated Gantt for the upcoming week and really dialed in my concept. I updated the gantt with the above checklist (somewhat changed), the BoM, and in the process of updating the presentation.
SO! I’ve done quite a bit. I warped my table loom with the help of Susan van Winkle, fellow weaver in San Diego.
I will also add calculations here of what to consider when weaving but I’m also thinking of generating a little loom wherein someone can do this easily by hand and lasercut some lease sticks and stick shuttles. Will update you here soon. I need to decide this week whether I will do that or not.
I missed 2 warps and didn’t keep my cross consistent so there’s a bit of inconsistency there. I may have to make a new warp but that’s okay! I know how to do that now.
I also programmed in python some code for making a shaft lift pattern. Basically, with no TC2 or any other jacquard loom, it’s very hard for me to weave by lifting individual warps to weave data (0s and 1s). SO, I decided to have a byte of data (8 bits of 0s and 1s) dictating which shafts are lifted up and which are down. I’m pretty pleased with the result. It needs to be cleaned up a bit and with maybe an interface someone can interact with and generate their own pattern. The threading pattern you ask? I thought of just a simple straight draw down, which is the simplest twill pattern.
I condensed my code into one file → one that takes data, converts it to binary, maps binary to something specific in the weaving process to produce a unique woven structure. This woven structure then produces sound.
I used python. And I used Norm MacDonald’s moth joke as an example dataset. I love this clip. I first started with the following configuration: data -> binary -> lift warps up or down
- Filled: shaft up
- Empty: shaft down
This is more of a refined version labeling the shafts to columns.
Then I wondered about the conductive and non-conductive yarns and thought why not thread a conductive yarn when there's a 1 present. It doesn't make sense in terms of obviously visually representing data.
Week 5¶
The focus this week is sample making! Going into this week, I was able to warp my loom with the help of Susan von Winkle in Rancho Bernardo. She was super helpful. I learned a ton. I need lease sticks and a shuttle. I’ll either be lasercutting these or 3D printing them. I’m also going to either design or find a file myself to lasercut or 3d print a handheld loom to weave samples on.
I also received all my parts for my CMOS circuits. My plan is to breadboard those and showcase a bit of an example at next week’s midterm.
I did a couple of things already.
- [x] Define more or less simple synth modules (LFO, oscillator, etc.)
- [x] Oscillator, Simulated LFO, Envelope/AR Module, Gate/Trigger Module
- [x] Prototype small sample woven synth module w/ CMOS and more components (or at least draw circuit diagrams and maybe “test” them on LTSpice)
- [x] This week: breadboard this
- [ ] Investigate translating binary to sound (Chris and Nico documentation)
- [ ] This week: simulate sound on web
- [x] Warp structo loom
- [x] This week: Thread through dents
- [x] Weave samples in simple handloom
- [x] Design hand loom
- [x] Print hand loom (pin hole loom)
- [x] Design lease sticks, shuttles
- [x] Print lease sticks
- [ ] Fold samples as potentiometers
- [ ] This week: Kirigami/Origami Potentiometers
- [ ] Design out textile/synth layout (what will it look like, how will it connect?)
- [ ] I may not get to do this this week. My focus is on sample making
- [x] Program translation from dataset to binary
- [x] Shell script?
- [x] Python?
- [x] Translating data to weaving patterns - Code to Excel to Treadl
- [x] Excel
- [x] AdaCAD
- [x] I did the above using just python and excel. - [x] This week: I will be refining this as I weave samples
- [ ] Buy yarn (after making samples)
- [ ] This week: Not only buy yarn but determine whether there will be somewhat of a color scheme for makers to follow
- [x] Update BoM
- [x] This week: Just make sure it’s up to date for midterm
- [x] Update Gantt chart
- [x] This week: Just make sure it’s up to date for midterm
- [x] Visualize understanding through presentation, pitch, and flowcharts
- [x] This week: Make these diagrams for presentation/documentation AND in time for midterm
The modules I'm building are an oscillator, LFO, VCA, binary counter, envelope, gate/trigger module
Here's the code I've been working with!
I modified my code to not map binary values to conductive weft. Rather, mapping 0s to one weave pattern and 1s to another weave pattern. For instance, 0 would be associated with a right twill weave and 1 would be a left twill weave.
# Converting data to binary to weaving pattern using a 2/2 Twill pattern as a base
# Without a base pattern there will be floats in the weave which would produce pretty big inconsistencies
# The "lift_plan" is really just to remind others what shafts to lift on an 8 shaft loom repeatedly
The following are libraries required to interact with Excel through Python. Specifically, filling in cells according to binary data.
import openpyxl
from openpyxl.styles import PatternFill
from openpyxl.utils import get_column_letter
These are essentially our constraints. We want our dents per inch (or ends per inch) to be 18. 7 inches for the sample. With washing the sample, it should shrink to about 6in. 126 total warp yarns in the loom. I have an 8 shaft loom so 8 shafts and no warp is allowed to float more than 4 picks. I’m using a sample “dataset.txt” file with a joke I really like. The output file is then named in OUTPUT_FILE.
EPI = 18
SAMPLE_SIZE_IN = 7
TOTAL_THREADS = EPI * SAMPLE_SIZE_IN # 126
SHAFTS = 8
MAX_FLOAT = 4
TEXT_FILE = "dataset.txt"
OUTPUT_FILE = "weaving_6x6_8shaft_from_text.xlsx"
This reads everything in the dataset.txt file. Then for every character in the file, it’s converted to a number via ASCII, and then converted to 8 bits (00100110). The binary data is then converted to one large stream of binary data.
def text_to_binary(filename):
with open(filename, "r", encoding="utf-8") as f:
text = f.read()
binary_stream = []
for char in text:
byte = format(ord(char), "08b") # ASCII → 8-bit
binary_stream.extend([int(b) for b in byte])
return binary_stream
binary_stream = text_to_binary(TEXT_FILE)
This sets up the excel file. Columns are warp threads, rows are weft picks. It’s color-coded. Dark is for when warps are up and white is for when warps are down.
wb = openpyxl.Workbook()
ws = wb.active
ws.title = "8-Shaft Weave Draft"
warp_color = PatternFill(start_color="222222", end_color="222222", fill_type="solid")
weft_color = PatternFill(start_color="EEEEEE", end_color="EEEEEE", fill_type="solid")
This is really just for reference. Our threading is straight draw down. Meaning one warp per heddle eyelet, sequentially. The threading is for a very simple twill and I think pretty easy for our purposes here.
threading = [i % SHAFTS for i in range(TOTAL_THREADS)]
This is again for our reference. We’re advancing our weave with twill and always lifting 4 shafts at a time to potentially avoid long floats. This is our base weave. We lift shafts 1-4, throw shuttle, lift 2-5, throw shuttle, 3-6, throw shuttle, and so on until we start at the beginning once again.
BASE_LIFTS = [
{0, 1, 2, 3},
{1, 2, 3, 4},
{2, 3, 4, 5},
{3, 4, 5, 6},
{4, 5, 6, 7},
{5, 6, 7, 0},
{6, 7, 0, 1},
{7, 0, 1, 2},
]
This tracks how many picks has a warp been down. The max would be 4 as we stated at the top of the code. This reads 1 bit of data in which that 1 bit influences 1 pick. If bit equals 1 the weave rotates by one shaft (shifting the weave). If it equals 0, the weave remains the same (normal twill weave).
warp_down_count = [0] * TOTAL_THREADS
This starts with say that for every weft in the total number of threads. The twill repeats every 8 picks.
for pick in range(TOTAL_THREADS):
base_lift = BASE_LIFTS[pick % 8]
bit = binary_stream[pick % len(binary_stream)]
# Data-driven modulation
if bit == 1:
lift = {(s + 1) % SHAFTS for s in base_lift}
else:
lift = base_lift.copy()
If the shaft that the warp is threaded on is lifted the cell is filled, if warp is down the cell is not filled.
for warp in range(TOTAL_THREADS):
cell = ws.cell(row=pick + 1, column=warp + 1)
shaft = threading[warp]
if shaft in lift:
warp_down_count[warp] = 0
cell.fill = warp_color
else:
warp_down_count[warp] += 1
cell.fill = weft_color
This makes sure we don’t have more than 4 floats in a row for any warp.
# Enforce max float
if warp_down_count[warp] >= MAX_FLOAT:
cell.fill = warp_color
warp_down_count[warp] = 0
ws.row_dimensions[pick + 1].height = 10
for col in range(1, TOTAL_THREADS + 1):
ws.column_dimensions[get_column_letter(col)].width = 1.5
wb.save(OUTPUT_FILE)
print(f"Weaving draft generated from text: {OUTPUT_FILE}")
I started weaving on my 8 shaft structo artcraft tabletop loom which the aforementioned pattern and this is kind of what it looks like so far close-up. I need to even out the tension because it doesn't look quite as good yet.
Updated BoM and Gantt here!
As I was finishing my midterm presentation, I started thinking about how my synth would work and how one could interact with it. I got this crazy idea: what if I made my body the potentiometer? You fold paper and through folding you can create an analog sensor based on folding. BUT what if I didn’t want to do that and just rely on the folding that the human body or human hand already does through joints. I just thought it was such a cool idea. More on this in the coming week!
Week 6¶
Midterm presentations! I presented my progress this week and it was harrowing.
No, it was actually fine. I think I did great! Here's some of the feedback I received.
I was recommended to look into the following:
- https://lea.zone/jacquard_handweaving.html
- https://clementzheng.info/Sensing-Kirigami
- Aristarco's LoomOne
- Riley's jacquard loom
- Collins Labs Electronic
Anastasia: colins lab! this is how i learned electronics, Afroditti psarra has nice work. lara grant as well
Cecilia: look at Rileys work! AMsterdam 2024
Claudia: I like the project being a sort of an instrument, interface and at the same time of an archive of stories.. is home then a temporary condition? // are you making a glove as well for a person to wear? can you connect that with processing? and create some visuals? also add an extra speaker for a louder sound // involve people to participate in the project so that you can speed up the testing phase / the project can be a performance and definitely a series of workshops // contact also jessica stanley would be nice to have a chat!
Louise: Very nice presentation Marissa, thank you. I am wondering if you could precise the type of data you are using and how it is related to home?
Carolina: Hi Marissa, so fun to see your code in the Loom! Certainly, the first computer codes were created for the loom. I hope you have time to finish all. Good work!
Stephanie: "Right into my field of interest :) Where does your data come from? What is the meaning of using these data and what do you want to communicate through the translation to image/texture? What do you want to convey? A Dutch artist/designer put an arduino on an old Jacquard loom https://www.instagram.com/reel/DTlDSdODbdc/?igsh=MTVtMXhqYXNod2hjNQ== Clement Zheng makes interactive paper mechanisms: https://clementzheng.info/ Also look at the Penelope project https://penelope.hypotheses.org/ which explores weaving looms and digital tools. I have also used my hacked knitting machine as a jacquard loom with Ayab: https://gitlab.com/svilayphiou/knit-tink ANd probably you know it, but the work of Unstable Design Lab is a must see, especially their software adacad.org
Anoush: Such amazing progress! I’m really curious to see the final result! I would suggest working in parallel with the electronics on the visual aspect - how it will look - so you’re ready on time for your final project.
Troy Nachtigall echoed all of the above sentiments.
I got to meet, however, with my instructor Louise last week and realized I HAD TO complete one working model of my project. So, effectively, my goals went from what's on the left to what's on the right.
