Choreographable video synth (PART II)

Inspired by the history of mounting circuits on wood with screws and wire, evoking John Cage’s prepared pianos. 

This iteration of the project is born of a few realizations :

  1. VGA is an analog signal, it’s not digital.
  2. The coolest effects are the simplest ones : XOR, HP and LP filters, comparators, etc. which can be easily made with discrete components.
  3. A simple low frequency oscillator could control these effects with an LED > LDR voltage controlled resistor set-up. 
  4. Two out of sync oscillators easily make a pattern that doesn’t repeat often and is difficult to predict.

Pedagogically and aesthetically I like this idea : it goes back to the basics of electronics, the history of electronics, and will show the materiality of video signals. This in contrast to the overly complex use of digital components to do basic modifications…

The three basic circuits :

  

*TESTED* This works (powered at 5V, with pull down 10K on input and the rest 1K and two BD135s) at lower frequencies (<100KHz) around 5V.  I added a 5K variable resistor (or an LDR + resistor) to increase the resistance of R1 and it varies the threshold !

*TESTED* Works using BD136 PNP, 10K for the pull down and 1K for the base protection. General purpose diodes. I replaced the pull down with a 5K variable resistor and got some messed up results in the MHz. Doesn’t need power – just takes it from the input signal ! (But VGA signal would need to be amplified in order to work. 

*TESTED* With a 104 cap and 5K variable resistor I can vary the filtering of a 5V function generator signal. 

 

****

OK we’re back to the original plan ! Here is the Palimsest.OS Rev.2 :

WHY ?

  • This board is for the inauguration of the IFT at the DVIC. It has to demonstrate technical proficiency on behalf of the staff, and must run independently as an tech-art installation, modifying video independently day in day out. 
  • Rev.1 didn’t work for microchip automation, this one should work smoothly(?). If everything works I could write code that executes different video manipulations. I also added selection LEDs to show the microchip doing its thing.
  • This tests the 8 channel 1-bit WRITE/REWRITE memory idea (but not the more elegant SRAM + buffer idea of Fabien), with certain effects tied to certain channels
  • Incorporates a simple to control XOR, comparator and HP/LP/BP filter into one board
  • Has a stable clock setup with metal can oscilloscope, a gen lock IC, and V SYNC burst setup
  • Tests an (expensive) programmable filter IC
  • It is a test for a simpler, inexpensive 8 ch recorder board that could be a cool kit
  • Does away with the ADC and all its pesky issues and trades it for a simpler 1bit “ADC”. 
  • I’m also using 5V SRAM to avoid the headache of different logic levels (though this means I only have 4MB of SRAM versus 16MB).
  • For testing purposes it can be soldered as a logic-controlled board or as a physical switch controlled-board. 
  • Instead of having lots of jumpers for wires, I went for rotary switches to make things more plug and play. However this also means that there are fewer experminental tests that are facilitated (like disabling a single counter while recording etc.) that were possible on rev.1
  • Can layer different recorded portions easily in theory
  • Battery switch and edge potentiometers instead of knobs
  • Theoretically could do feedback and echo tests with this board as it can read and write from and into memory simoultaneously 
  • This board should be easier to work with than the previous stacked PCI-E motherboard design which made knob turning and mounting hard. 
  • Instead of using generic octal logic ICs I went for more specific purpose ones.
  • The board will be made at https://aisler.net/ instead of JLCPCB so I’m hoping for a really nice finish

Here’s a possible minimal installation with it :

****

PALIMPSEST.OS v2 ERRATA :

  • Pin 1 of the 40MHz clock should be pulled HIGH to be enabled, not LOW as it is on the board !
  • The THRESHOLD pot isn’t connected to GND on one side…
  • I should have tied the CCLR (pin 10) of the 590 to ground with a 10K instead of leaving it floating connected to VSYNC. This made it malfunction.
  • BIG PROBLEM : I ordered multiplexers (unidirectional) instead of analog switches (bidirectional) ! The ‘157 multiplexers mess with SRAM B’s I/Os when it is in READ mode (when the SRAM is outputing values on the I/O pins). I ordered a replacement that is pin compatible, the 74LVC1G3157 (DATASHEET : https://www.ti.com/lit/ds/symlink/sn74lvc1g3157.pdf?HQS=dis-mous-null-mousermode-dsf-pf-null-wwe&ts=1679316452048&ref_url=https%253A%252F%252Fwww.mouser.de%252F). EDIT* The new components work perfectly – everything is good !
  • The Sync Clock IC is 3.3V not 5V…
  • Image jumps around of course. When I try to record with the Burst AND IC which outputs !CLK, no writing can occur. I’m guessing this gate messes with the timing somehow? As a workaround I’m trying to connect the 4 AND’ed V SYNC counts to either the address counter IC Reset or to another reset somewhere. 
  • Lots of noise on V SYNC, I should maybe have made the input and output VGA jacks right next to one another…

Oy vey ! I realized that I could just use an I2C RAM IC and save about a billion components. Here are the more plug and play simple boards I made in the aftermath :

Good news: The 328 works. 

ERRATA : I fried the logic chips with 5V :(. Resoldered new ones and looks good.  I think I need to be feeding in a signal that has already been digitized (like by a comparator). Otherwise I need to mess around with knobs to get the signal right around the threshold of the logic gates with bias setup. 

Good news: The 328 works. And I can see the effect of selecting different filters. I’m not sure why but it works best when the signal is coming in on A and I’m taking the output on B (or vice versa). I’ve also got a cap going from the output of the filter board before amplifying it again.

ERRATA: I ordered the wrong length of bussed resistor network. 

Good news: The 328 works. 

errata ^ Wrong footprint (and value!) for the digital potentiometer here… Will have to wait for the correct part to test this.

Good news: The 328 works and at least it produces an image !

errata ^ H SYNC and V SYNC plugged in to wrong pins on Arduino (should be PD3 and PB1 respectively).

Good news: The 328 works.

ERRATA : the PD pin (which enables ADC IOs when low) is pulled HIGH ! I resoldered it and now it’s working great. 

I chose a non PWM pin on the atmega to be the voltage control pin of the VCO… I soldered it to the nextdoor pin which can do PWM and all is good. 

 

ERRATA: I tried two chips, they both come up as unidentified FRAM when I have them speak on the serial running the demo codes…I should probably pull Write Protect (WP) HIGH just in case. Still not working…I will try replacing with a 23LC1024 serial SPI SRAM as it has the same pinout. 

***EDIT: Just saw this on the Adafruit website : “For the 4Mbit version, you should change this to: fram.begin(3)”…Still doesn’t work though.

I replaced with the 23LC1024 and am using the SRAMsimple libary which appears to work well. For some reason the digitalRead I’m doing in the setup is always returning 0 even if connected to 5V.

#include <SRAMsimple.h>
#defineCSPIN8       // Default Chip Select Line for Uno (change as needed)
SRAMsimple sram;       //initialize an instance of this class
/*******  Set up code to define variables and start the SCI and SPI serial interfaces  *****/
voidsetup()
{
uint32_t address = 0;                       // create a 32 bit variable to hold the address (uint32_t=long)
Serial.begin(9600);                         // set communication speed for the serial monitor
SPI.begin();                                // start communicating with the memory chip
  // And now the fun begins:
/**********Write a Single Byte *******************/
bool data = digitalRead(A0);                        // initialize the data
for(int i = 0; i <=5; i++){                 // Let's write 5 individual bytes to memory
    address = i;                              // use the loop counter as the address
sram.WriteByte(address, byte(data));            // now write the data to that address
    data+=2;                                  // increment the data by 2
}
/********* Read a single Byte *********************/
Serial.println("Reading each data byte individually: ");
  byte value;                                 // create variable to hold the data value read
for(int i = 0; i <=5; i++){                 // start at memory location 0 and end at 5
    address = i;                              // use the loop counter as the memory address
    value = sram.ReadByte(address);           // reads a byte of data at that memory location
Serial.println(value);                    // Let's see what we got
}
}

Not sure why…

OVERALL ERRATA : I also need some kind of power board that distributes 5V and 3.3V 

***

On the back of the boards I tried an experiment using the bmp import ULP in Eagle. Not sure what the results will look like :

   An

**** 

I also starting thinking that I should probably look at more existing DIY and pro analog video synth circuits…

A collection of great video synthesizer schematics resources : https://scanlines.xyz/t/diy-resources-file-system/224

Here are some of the ICs (that are still being manufactured) that I haven’t work with before that appear in several designs :

  • Resettable and retriggerable Monostable Multivibrators : https://assets.nexperia.com/documents/data-sheet/74HC4538.pdf
  • High speed diff comparators : https://www.ti.com/lit/ds/snosbj5c/snosbj5c.pdf?HQS=dis-mous-null-mousermode-dsf-pf-null-wwe&ts=1676232730602&ref_url=https%253A%252F%252Fwww.mouser.fr%252F
  • Video Fader IC: https://www.analog.com/media/en/technical-documentation/data-sheets/12516fa.pdf
  • Graphic EQ display filter : https://www.sparkfun.com/products/10468

To divide a signal into 8 different bands (if you skip the MUX at the end) :

Here’s a simple implementation with a 4051 analog mux at the end :

And I’m revisiting all kinds of combined capacitor + switch circuits which move tiny charges around based on signals  :

  • sample and hold 
  • bucket brigade
  • comb filter 
  • switched capacitor circuit

 I have made this bucket brigade “delay” with 50 microchip tunable (variable) 100-200pF capacitors :

I am now curious about some other capacitor switching circuits like this Comb Filter : https://en.wikipedia.org/wiki/Comb_filter which somehow “provides response” at different multiples of 1KHz depending on 3 bit code. All the caps are the same value.

Here is another circuit design for the same function :

Block diagram of comb filter including the CMOS multiplexers and the... | Download Scientific Diagram

****

For the FPGA board, I’ve ordered an iCE40HX1K development board and am currently planning to test some basic VGA signal generation. The next steps could involve basing a design off of the OLIMEX dev board design (https://github.com/OLIMEX/iCE40HX1K-EVB/blob/master/ICE40-1KEVB_Rev_A.pdf) which already has SRAM and VGA OUT along with code on the internet (which I would follow closely for the first iteration). I would alter the board to be able to program directly via USB using the components from the Ice40 stick ( https://www.mouser.fr/new/lattice-semiconductor/lattice-icestick-kit/), like a fancy new FTDI chip, so I could stay within the Lattice software for my first steps. 

Compared to the VGAX, the FPGA could generate signals much faster (being clocked with a 100MHz crystal versus the 16MHz of the Atmega), it would also be producing signals based on a a different coding paradigm (I have no idea what that would mean in terms of images), and because it has around 90 I/O it could also work with super deep colors using only a R2R ladder. The possibility of using an SDRAM is so cool but it seems hard to implement, with SRAM being much simpler to interface. The OLIMEX has only 512KB of SRAM, so I couldn’t really record a lot with it. 

****

Here is my process for the FPGA programming so far :

  1. I signed up for an account at www.latticesemi.com.
  2. I got a licence for iCEcube2, put it somewhere easy to find and took note of the directory, and downloaded iCEcube2 and the Lattice Diamond software from here : https://www.latticesemi.com/en/Products/DesignSoftwareAndIP
  3. I plugged in the iCEstick and it blinked in a circular pattern. I also checked that it had a port under Device Manager (it had 2!). 
  4. I went into iCEcube2 then to Help > Tutorial to open a pdf called “Implementing the Design” and followed the following steps :
    1. Start new project (iCE40, HX1K, ?TQ144?)
    2. Add Design file iCElab.v and Constraint file iCElab.sdc and checked the Device Info.
    3. Run Synplify Pro Synthesis
    4. Select Implementation
    5. Add constraint file iCElab.pcf under Import P&R Input Files.
    6. Run Placer
    7. Check the Floorplan, package view, timing analysis, power estimation
    8. Generate the bitmap (.bit and .hex files) which is saved wherever the project was saved. (For instance C:\Users\Jonah\Desktop\FPGA LATTICE DEMO PROJECTS\quick_start\quick_start\quick_start_Implmnt\sbt\outputs\bitmap).
    9. Here is what everything should look like once finished :
  5. I then transitioned to Youtube for a detailed explaination of using Diamond Programmer with the iCEstick here : https://www.youtube.com/watch?v=Df9k1T0bHmA&ab_channel=Dom
    1. Launch Diamond Programmer and take the default options (or click scan and take those)
    2. It will mistake the board for a JTAG interface and give the following errors : “Failed to scan board”, “Scan Failed – Creating Blank Programmer Project.”
    3. Now change the Device Family to iCE40, the device to iCE40HX1K, and under Program enter the following information :
      1. Change Access mode to SPI Flash Programming and now some other options appear. Select > Vendor: Micron, Device: N25Q032, Package:  8-pin VDFPN8
      2. Now load the bitmap (.bin) file and check that it has a non-zero datasize :
      3. Click OK and then click the green traffic light on the next to top row of icons. You should then see a completion message and have the program on your board :
      4. Presto !

Just for info :

For the actual pinout of the ice40 (which you can change in Pin Constraints Editor):

Generating your own .v file, you can open Notepad++ and paste :

module AND( input A, input B, output Y ); assign Y = A&B; endmodule

***

Now I want to generate some VGA signals as quickly as possible and start creating images by tweaking pre-made code like for VGAX.

For generating verilog, there is migen for python 3 (https://github.com/m-labs/migen). I’m going to try a super simple thing in Verilog first to get a feeling for it. 

Here’s a tutorial from Hackaday for the ice40 :

https://hackaday.io/project/159720-fpga-bootcamp-0

https://hackaday.com/series_of_posts/williams-icestick-tutorial/

And here is demo code for the OLIMEX ice40 developement board which has RAM, DAC, ADC and VGA : https://github.com/OLIMEX/iCE40HX1K-EVB/tree/master/demo/ice40-io-video

And a super simple VGA code for an ice40 4K: https://github.com/imuguruza/alhambra_II_test/blob/master/vga/vga_test/vga_sync.v

Also super simple : https://www.fpga4fun.com/PongGame.html

 

*****

Here’s what ended up getting presented :

Here is the text I made to go with it :

La préparation d’un piano est l’action expérimentale d’ouvrir le couvercle du piano et de placer des objets (des vis, par exemple) entre les cordes. Ces « préparations » modifient la vibration des cordes et peuvent provoquer de nouveaux sons, parfois des sons de batterie plus du piano. Post-préparation, le pianiste peut composer une partition qui exploite les nouvelles modalités soniques découvertes, entrant en dialogue créatif avec l’instrument. L’acte d’intervenir et de détourner le fonctionnement du piano encourage le pianiste à comprendre le fonctionnement de leur instrument d’une manière concrète et recadre l’instrument en tant que site d’expérimentation créative, menant souvent à des découvertes inopinées, bien que fugaces, dans un processus artistique ouvert et indéterminé.
Ce projet représente une tentative (ambitieuse) de fabriquer, et ensuite de « jouer » avec, un type d’écran préparé. Les signaux électroniques qui passent entre le laptop et l’écran ici sont comparables aux vibrations qui voyagent dans les cordes du ventre du piano. De la même manière qu’une vis peut modifier le son généré par l’activation d’une touche du piano, nous pouvons atténuer et amplifier sélectivement les voies de signaux électroniques pour produire de nouveaux stimuli (en forme d’images cette fois).
Notre quête pour répertorier des préparations vidéo possibles, et pour documenter leur fonctionnement, nous a mené à la rencontre de filtres artisanaux montés sur bois, qui évoquent les radios fait maison des années 1950s, ainsi que les technologies moins abordables et plus sophistiquées comme les FPGA (des circuits intégrés de logiques programmables). Ces prototypes sont fixés dans l’arrière-plan et ont vocation de rappeler le caractère expérimental et ludique du projet de recherche.
En clin d’œil au monde de la synthèse modulaire audio, qui prend souvent une esthétique punk, nous avons fixé un enchainement de modules de préparation vidéo au premier plan. En concaténant des modules, tel que les filtres à capacités commutées, des mémoires vives statiques, des convertisseurs analogique-numérique, des portes logiques combinatoires, et encore d’autres, nous pouvons délaminer les flux vidéo, créer de nouvelles voies électroniques, tordre, caresser et déformer des signaux, les synthétiser, et finalement les tresser ensemble, avec plus ou moins de finesse, et observer les résultats en temps-réel.
                                                                                            ***
A prepared piano is the result of opening up a piano and placing objects (often bolts and screws) between the piano strings. “Preparations” modify the sound of a vibrating piano string to create new sounds, sometimes more resembling a drum than a traditional piano. After a piano has been prepared, a score is developed to explore the new qualities of the instrument. Instrument preparation invites a musician to engage with and understand the inner working of their instrument, literally getting their hands inside the body of the instrument. Preparation reframes the instrument itself as a site of creative experimentation, often leading to serendipitous discovery in an exhilarating, and at times painfully anxious making (!), open-ended design process.
This work is an attempt at making a kind of prepared computer monitor. The electrical signals passing between the laptop and the monitor are analogous to the vibrations inside the strings within the belly of the piano. Just like a bolt can create a new type of sound in the prepared piano, we can similarly dampen and accentuate the video signal pathways of the prepared computer monitor to create new types of image transformations that play out in time for our eyes.
Our journey to explore a range of possible preparations and document their effects has taken us to different eras of technology, from simple, artisanal high pass filters mounted on nails in wood, to more sophisticated technologies like the Field Programmable Gate Array (FPGA). These exploratory prototypes are visible on the backplane and emphasize the importance of the process in this artistic research project.
In a nod to the world of modular audio synthesis, we are displaying one of many different possible concatenations, or “patches” as they are known, of our video preparation modules in the foreground. By linking together various microchip-controlled switched capacitor filters, static RAM delay modules, Analog to Digital converters, combinatorial logic boards, and other circuits, we can playfully delaminate a video signal, open up different signal pathways, bend and warp signals, synthesize new ones altogether, and finally braid these all together on screen and observe the results.
***

My takeaways :

Do something simple, and humble, but try to do it well. Trying to do too many things, or a “universal” thing, or a multi-functional reprogrammable thing is really ambitious. This has happened to me before :

  • At the Barilla Hackathon (the team that did the best made a simple lunch surface, it was simple but really well made and designed). 
  • With my solar robot project (the one that was supposed to run on solar energy and no battery, interact with other robots, and possibly build a structure)
  • With my original solar sunflower design that was supposed to look super intricate.

Making a machine that works for a demo is the highest level of challenge. It requires you to master the functining of the machine to a high degree to be able to fix it and adapt in changing conditions. It you do something simple, you have a higher chance of being able to do this.

It would have been important to realize that the place this was to be shown is a corporate environment, and that my interest in the bodge / bricolage would never have found its place here. The corporate mentality is shiny, new, pro-tech, and “impressive”. I should have understood this before taking the project. 

The simple, distilled, purified, humble and clear idea from this project was the wooden-mounted electronic circuits. This would have been in line with my “design research” interests, my aesthetic.

If I were to make a complex machine like the one I had in mind for this expo that would have worked, I think I would have to change the following things :

  • Generate my own VGA signals. For plug and play things, generating this in software seems so much easier because you are the one making it and you have control over what is being produced. 
  • Figure out, once and for all, the story around shared grounds and blocking caps, and bias pots, and voltage in and voltage out levels, for different modules. Also, 75ohm resistors and small caps before VGA out ? Should I just get a VGA driver chip that works? (EDIT: Here is an explaination of how to calculate the output impedence for VGA cables : https://hackaday.io/project/18682-pic-graphics-demo/log/49786-vga-interface)
  • I would need to figure out what makes the VGA monitor turn off (is it sending something it doesn’t consider a video, or a voltage level that is too high?)

I think the alternative, which would be showing pre-recorded videos, is uninteresting for a performance. Another key ingredient I think is having designers / artists to help me review the project regularly (like in design school). It should also be really clear to me if it is my design project or a commission (in which case I’m an engineer I guess?). I should also get clear right from the begining next time what are the conditions of the final thing – where will it be, what are the goals of the person commissioning the work, etc.). I should probably only work with people who share my interests and aesthetic ! 

I think I have to acknowledge that I have an extremely constrained working process that is highly method driven. I am not focused so much on the end product directly. My friend suggested I was over constraining myself. Basically there is a confusion between whether I’m using technology to stumble upon unexpected things, or whether I’m using it to make something that works. To work efficiently on things would work well would require time developing the things that must work well, and an organized, systematic working practice. I MUST ORGANIZE MY ELECTRONIC PARTS to make this process more efficient.

Also : all the intense pressure and hardcore work streaks I put in DID NOT HELP THE FINAL PROJECT – I can’t even think straight or debug basic circuits right now :(. It would have been better to perhaps start working on the final thing starting on day 1, with the EASIEST, SIMPLEST, AND MOST LIKELY TO WORK PAINLESSLY solutions. 

Another key question is what is the output, and who is my audience ? I need a way of mesuring my output and comparing it. 

  • Am I making art for people who consume art ? (then I have to move towards very simple projects and focus on their EXECUTION while photographing everything super well for my PORTFOLIO)
  • Am I making “design research” papers/talks for academics and people who consume this ? (then I need to WRITE about my research)
  • Am I making open-sourced electronics kits for hobbyists ? (Then I need to spend time ENGINEERING working kits that people would be interested in making)
  • Am I making workshops for designers ? (Then I need to come up with simple exercises for workshops?)

And am I doing several of these things simoultaneously ? I think doing any one of them well first could take a lifetime already ! My friend suggested projecting five years in the future to where I would like to be and building backwards from there. I think I would most like to be a teacher who does art/design research in the form of expos, articles and classes (a bit like Andrew Witt at the GSD).

********

Where I would like to go from here :

  1. Test my basic FPGA VGA board. What can it do with video ? Possibly make another pro version (USB programmale, nicely laid out, SRAM). FPGAs feel like the future because they are good a processing video in parallel, and because coding them is essentially like building 74 series logic circuits but without all the soldering. It could also lead to some cool machine learning experiments later on..
  2. Test my automatable SRAM 4MB board. What kind of automatic looping can it make?
  3. Try to get the SPI SRAM board functioning (it is so simple it would be perfect for a video sampling workshop). It would be cool to see what kinds of images it produces. It works at 20MHz, it would be perfect !
  4. Get Spaghettini working with aluminum board (just avoid going through-hole) – this is the simplest way to generate cool simple memory based video !
  5. Have another stab at presenting my work as an art installation at my show end of march at La Générale. 
  6. Try the bucket brigade and digitally controlled pot boards

*******

    After my colleague Fabien told me about EDID EEPROMs, I am thinking it could be possible to mess with the memory of this EEPROM that communicates with the computer sending VGA signals and create some interesting glitches this way : https://en.wikipedia.org/wiki/Extended_Display_Identification_Data

    Also check out these types of RAM : 

    • https://en.wikipedia.org/wiki/Dual-ported_RAM
    • https://en.wikipedia.org/wiki/GDDR_SDRAM

    And this keeps coming up when looking into controlling screen rows and columns directly : https://en.wikipedia.org/wiki/Low-voltage_differential_signaling

    Choreographable Video Synth

     This circuit is a next version from the video synth. 

    Some ideas from how this installation could look like :

    Messing around with my last synths, here are some circuits that I want to be able to reproduce with my new synth :

       

    Here are some ideas of how the circuit could take form :

    A Nintendo gameboy catridge teardown :

    Some sketches of possible configurations :

    *******

    I am currently splitting the project into two parts : 

    PART 1 : A series of independent transforming modules, VGA IN/OUT with screens, and oscillators with patch cables.

    PART 2: A board called palímpsêst.OS which is a rack (or archive) of several 16MB memory modules. 

    ***********

    Palimpsest.OS

    Each memory will share the same power (5V, 3.3V, GND), timing CLK signals, control signals (to enable/disable counters, buffers, RAM, ADC etc. and to RESET things). All this can be automatically controlled by an microchip which can turn on/off these memory banks individually in time. Despite this there will be basically all the components on the board to make it function independently and, most importantly, test and debug it’s functioning. 

    Just like for the previous memory board, the following parameters will be modifiable :

    • the duration of the recording and playback,
    • the sequencing of addressing this memory,
    • the amplification of the incoming and outgoing video data,
    • the sampling rate and sampling pattern of video recording and playback,
    • the bit resolution of the recording and playback,
    • the continuity of the above processes or the frequency of their interruption

    I have corrected the errata from the previous 16MB memory board, removed jumpers (as this board will be made by JLC PCB), added a ground plane, made it more compact (by removing the burst record functionality, level shifting, and having two layers). I also added a battery so that memory is persistent as long as the battery has juice. The main work however has been breaking out pins to a bus which can be controlled by a microcontroller. There is now the possibility to have 3 memory boards A,B and C, and to control their recording and playback, and all the parameters of these two things that can easily be controlled, in time. 

    With these boards it should be possible to take an input, record it, then play it back and mix it with the input through a feedback pot. Because this can be done by three memories, they can also record their respective outputs and layer without any mixing with the VGA . 

    *****

    01/12/2022 UPDATE :

    So far debugging: For some reason the ADC is not spitting out anything, regardless of what I feed it. I changed the input op amp and it had no effect. Previously to soldering the ADC everything seemed to be working…As far as I can tell the memory is working and all the bias pots too.

    ERRATA :

    -The direction pin of the 245 buffer connecting to the R2 ladder is wrong – it should be HIGH instead of LOW.  To temporarily correct this involves jumping the DIR pin to VCC – AND CRUCIALLY – to ALSO disconnect this pin from GND unless you will have a short.****

    -Why on earth did I connect all the pins without dip switches (ADC EN, 1/0 0-7, etc.) from the memory boards together ? This makes it impossible to record on one board and not on the others. I cut the non-DIP’d traces and it seems to work. 

    -the LED needs a current limiting resistor or it just explodes.

    -one switch for master record (WR EN and ADC EN)?

    -I should follow the ADC1175 instructions and isolate the DGND and AGND with caps. 

    -Should have an input pin and 5V pin for testing on board.

    -I should add the right footprint for a big capacitor at the input of the ADC (I forgot and put a 0.1uF which didn’t work).

    -It would be super cool to have a coarse and fine knob (and or a super precise pot) for the VCO for instance on the base board. 

    -I should take the classic gameboy battery footprint.

    -There isn’t an extra pin so I can send V SYNC both to be frequency divided and pass it on to the VGA out. 

    -The populated side of the memory PCB is facing “backwards” with regards to the base board…

    -The LDO pinout on the base board is wrong

    -I can’t plug in standard jumper headers to the PCIe breakout pins because they are a different diameter

    -I tried hard syncing the VGA’s H Sync with the 4046 ( see text in description of video here : https://www.youtube.com/watch?v=S694YY7sJMw&ab_channel=drumasaurusrex ). It only works with the V Sync but that’s too slow. I can’t get a stable signal out, it looks super wobly at high frequencies.  

    *****

    TESTING THE PALIMSEST.OS

    • Not sure why but it seems like I can’t record only on one board when multiple boards are connected. I have to disconnect all but the board I want to record on to get a recording onto it. *EDIT* Because I connected all the non-dipped pins from the boards together via the PCI-E bus…
    • It would be super cool to be able to send different clock signals to each board. I should maybe not have made the same CLK hardwired to each board. 
    • It’s not possible to turn the knobs when then three boards are plugged in at once because the pot shafts are too long. 
    • Not sure exactly how the battery is working, it seems like it can “remember” something for a few minutes at least. 
    • It’s hard to palimpsest various things together – You have to get one board all calibrated, then send it something from another calibrated board, record it, then rewrite to play it back. (I am hoping the new 8 channel 1 bit device makes things easier). 
    • I can’t automatically have things read or write currently, not sure why it’s not working…
    • I can’t echo with this board because I can’t simoultaneously read and write. That said I can mix a recording with live channel and then record that together into a memory and begin layering. 
    • I would like to have the image stay stable instead of always jumping everywhere. 
    • Dephasing the ADC and RAM clocks makesa large variety of nice patterns on the output !
    • It would be nice to be able to count up and down and do that to 4 bits in the middle of memory !
    • remember to connect GNDs if using memory board with analog f(x) for example
    • Trying to hard sync with h sync and cd4046 based on these links (https://www.renesas.com/us/en/document/oth/tb476regenerating-hsync-corrupted-sog-or-csync-during-vsync and https://www.youtube.com/watch?v=5VymS65eefo&ab_channel=drumasaurusrex)… I think the solution might be an oscillator in a can (with 4 not 2 leads), which I can then divide. (I can still have a free style VCO with knob to control the sampling of the ADC though !)
    • Works great with a four lead crystal oscillator can and the f divider – a very clean image that doesn’t warp ! You can still use the knob controlled high speed VCO to trigger the ADC and it’s a nice combo. 
    • *****WOW – feeding in a quartz can 10MHz into a frequency divider (and sending diff divisions to the SRAM clock), and hooking up V Sync directly to the reset, produces a really stable image that doesn’t slide left or right !!!****
    • ***ABOVE ALSO WORKS WITH H SYNC AT LOWER FREQUENCIES – SOOO COOOL : D !!
    • I’m not able to use MOSFETs or transistors to reliably automate the switch from REC to PB for some reason. I’ve even tried using an optocoupler to isolate the arduino and also tried using and AND gate as a buffer with the WR signal but neither work. I think should use mechanical relays to get around this problem or just avoid it all together by having Arduino send the CLK and WR signals in the next version. 
    • Tying differnt oscillator cans (10MHz, 12MHz, and 40MHz) 12 is nice because it doesn’t jump too much on my screen resolution (800×600). At 1280×720, 10MHz is nicest. 
    • I did a proof of concept for the 8 track recording and rerecodording idea, it seems to work though there may be a bit of interference from neighbouring channels on one another ? Not sure how I would try to isolate them from one another but some bleeding might actually be cool ?
    • I tried doing a feedback recording (recording a mix of a play back and a live feed) and had no success. Not sure why this isn’t working.

    ***********

    Realizing that this whole massive multi-module thing could be made with just one memory module having feedback !!! That or a simple echo IC like this one I ordered (BU9253 : https://www.mouser.fr/datasheet/2/348/rohm_semiconductor_rohms16891-1-1742621.pdf ) :

    That said the delay is only 8Kbits and it’s designed for audio.

    *****

    Analog Functions Board :

    Trying to remake the previous analog functions board but at JLC and as pro-style as I can. The general idea is to make a bunch of op-amp circuits that modify video in various ways and that can be combined with the logic modification board to make a completely full suite of electronics video transformations. Not sure yet how they could be automated.

    Fixes from previous esceptionally newbie laser engraved version :

    • +15/-15V supply for all the op-amps using the handy ICL7660 negative voltage generating IC will hopefully solve many issues.
    • Using normal general purpose op amps in addition to super fast video ones 
    • Having bias pots at the inputs and outputs to sort out any different in offsets. 
    • Doing more research to get better circuit designs, notably looking at the Analog Thing, The Hackaday Logic Noise Series, Rod Elliott’s active op-amp series.
    • Making things less noisy with : seperated AGND and DGND, caps near op amps, following suggested board layouts, 2 sided board with GND plane (!)
    • Tying to take into account impedence matching with 75ohm VGA camble at the input and output and testing a specialized video line driver IC
    • Making op amp board with the possibility of automating thier switching / pot levels ?
    • Adding over-amped fuz circuit, phase-shifter, and various filters (LP, HP, BP, Notch), and adding a reset to the integrator circuit. 

    I think the theme of this board, especially seeing as I have 25 of these TL074 op amps, is showing the diversity of flavours (and range of sometimes exotic circuits) of the history of op amp filters, arithmatic, etc. circuits. I plan on highlighting the names (and dates?) somehow.

    The idea has clarified now, it will be a grid of 24 different op amp circuits in a 6 by 4 grid with the name of each circuit and a letter/number identifier. At the top will be all the power, VGA in out and bias amps.

    I collected the circuits from various places (AoE among them) but especially from Rod Elliott’s write up on active filters (which you can access with Internet Archive) : http://sound.westhost.com/articles/active-filters.htm

    I am most excited about the combination of digital and analog – like in the switched cap filter, sample and hold, resettable integrator, and demux amp circuits. Being able to modify the functioning of am amp with digital signals (even with a tunable capacity and voltage controlled potentiometer) seems to offer really cool potential. This being combined with SRAM could be a really cool composite project.

    ERRATA :

    • VCCIO and GND directly overlapping on top layer  (near A2/A3) :/
    • the preamp in and out and misaligned 
    • Should have included blocking capacitors
    • VGA not being recognized by my computer with driver chip 
    • Should have included an inductor circuit
    • awful humming from the negative 12V generator
    • not enough room for 220uF caps for the video driver on board
    • some kind of “pass through” switch would be useful to show what the input looks like
    • the driver IC can only accept one color for some reason…I should not include it next time
    • the female – female jumpers are not reliable and lead to weak contacts…maybe going towards jumpers?
    • The thing is long to set up – it’s not plug and play and is finicky for demos
    • Learn about the safety of hot plugging
    • The Voltage Control works a litte, with a 1k8 resistor and picking the right voltage range. But it is not reliable, I should move to pot ICs for the next version. 

     

    • A0  with a 200uF cap after the final amp has some filtering output
    • A1  just tears the left side of the screen
    • A2  nothing happening
    • A3 varies nicely with different frequencies, though sometimes just looks like it’s “adding” frequency pattern to input
    • A4 I think the original comparator design (with 1K resistor going to VCC and pot with middle shorted to GND going to GND is correct and this one wrong)
    • A5 same note as above, but preamp in and upper seem to work. Perhaps the best way to get abstract forms from input super easily. 
    • B0 Not working…
    • B1 nice filtering !
    • B2 needs blocking cap on output or else produces nothing. Goes from filtering to almost comparator like behaviour.
    • B3 needs a cap on output and >20MHz to produce anything, no relation to input though ?
    • B4 creates a cool zebra repeating effect at one extreme
    • B5 great filter !! Both knobs do things and there is great range.
    • C0 nothing cool happening here…Seems just to pass on a modified version of the digital in signal ?
    • C1 top knob needs resoldering. Only does stuff when top knob fully to one side then behaves a bit like A3 but can go down to low frequencies on digital in.
    • C2 Cool zebra like filtering (like B4 but messier and less repetitive.
    • C3 nothing happening…
    • C4 faintest image at one extreme
    • C5 nice filter (like B5) ! Only top knob seems to do cool stuff though. (Other knob goes haywire at one extreme).
    • D0 barely the faintest image at low frequencies…
    • D1 the HP inverts the input !
    • D2 Does add when the knobs are set right. I put a cap on the function generator input.
    • D3 Does kind of subtract ! Can invert or not.
    • D4 makes a banding across the screen, not sure what effect the 3 binary inputs have…
    • D5 doesn’t really work but with the second multiplier input floating you can touch it and send the thing into an overdrive momentarily. 

    *********

    Notes from Museum visits :

    Composite (wood, porcelaine, gold) in flat, relief, and form of object.

    Could I have both feathery frilly fuzzy video mixed with crisp solid geometric form to create similar layering ?
    Some video noise looks like different types of stone
    Rococo / Baroque video ?
    Decorative video?
    High quality video / image capture ?
    Once I’ve finished with this round of tools, I have to compose more !!

    Can I mirror an image half way to make a Rorschach like ink splot ?

    Wicker chair silhouette series, pumpkins 
    Some format of showing the circuit and the output that can end up in a book
    Shoot my own video to mess with

    Layering

    Contour
    Surface
    Saturation
    Flow vs. Choppiness
    Look at Photoshop for 
    Roughness, relief 
    Edges versus centers 

    Movement vs stasis 

    Enriching of detail possible ?
    Abstracting, cosmic making
    Fine lines versus coarse
    Exposure 
    Color fields
    Texture
    Deep friedness
    Films of cows, ocean. Stills of still life? Flowers, birds, drapes folding, mold, fruit, bones
    Color mixing vs melting vs meeting
    Paint viscosity (runny vs clotted)
    Direction of brush strokes 
    Contour
    Focus direction in canvas
    Translucent flesh, shine vs glow from interior, waxiness 
    Graininess 
    Composition, color pairings and form
    Foreground displaced to background vice versa 
    Meeting pattern planes 
    Lighting and shadow
    Illusion of depth
    Cloudiness 
    *****
    IDEA : I could take a file, put it into the memory, and then “play” it different ways (because the width is completely arbitrary below). A file could thereby become a pattern, or a long abstract video, 

    Windows PE visualization

    Or I could put an image onto a floppy, then damage the floppy, and show how it would modify the image ?

    THINGS TO TRY:

     

    • Palimpsest.OS with arduino controlling WR and COUNTER CLK (and forgetting about CLK) to control the boards recording and playing back. 

     

    • Check out Video Effects list from Adobe Premiere : https://helpx.adobe.com/premiere-pro/using/effects.html
    • test outputting to a projector !! * EDIT * WOW this was a good idea :

    • take HDMI and mess with it digitally (but not analogically?)

    • design easier to understand / less complex board which is more plug and play ? *EDIT* Try 74*8154 16 bit counter + 32K x8 IS61C256A SRAM !
    • Take photos of boards in the light box !  

    This is what a loop sounds like :

    *****

    I’m currently working on a final set of four boards for the Choreographable Video Synth that will finish this project. 

    All the boards will have the following improvements :

    • Plug and play – very little setup time, no need for a function gen, and no fiddling to get an image on the screen for demos quickly.
    • Nice 2mm banana connectors and 30cm multi colored patch cables that make reliable connections and are more modular. (Not sure about edge connecting female plugs and edge actionnable pot knobs or vertical plugs).
    • Only the best bits of the previous boards (Analog f(x), Oc74, Palimpses.OS) in a smaller square format with playful designs.
    • The three f(x) boards will have an onboard audio amp + speaker to hear the signals you are making. A speaker hole will be present.
    • Finished product for inauguration of the IFT in early March, 75mmx75mm ans nice compositions. 
    • Make this version actually be entirely controlled by digital potentiometers and buffers and then also be able to manually control these digital devices on board with hardware switches and buttons. 

    SIGNALS IN/OUT board :

    • Takes VGA, HDMI, DVI-A in, and puts out VGA and HDMI. (Or just VGA in and out?)
    • Has a passthrough switch to see directly what’s on the screen. (Or skip this?)
    • Has a final mixing stage (especially a microcontrolled matrix mixer !!)
    • Acts as a power supply for the other boards (12V because the analog board needs this?)
    • Could take 2 VGA inputs ?
    • Has an atmega 328 to output low res H and V ?

    ANALOG F(X) board:

    • Only the four best of the 24 analog functions board. (Butterworth HP, LP, Analog MUX, ADC)

    OC74 DIGITAL F(X) board :

    • Only the best functions (comparator, DAC, S+H, XOR, Bin Counter)

    MEMORY board (OR MAYBE THIS IS A SEPERATE KIT AND I SHOULD JUST MAKE A 16MB MEMORY BOARD AGAIN?) :

    • 8 channels of 1 bit memory recording on a total of 1MBit of SRAM
    • Comparators acting as 1-bit ADCs (but maybe this belongs on another board ?)
    • A battery system that actually works (where battery and input voltage Diode-OR’d and with an ON-OFF switch to conserve batt)  !
    • Double SRAM so that I can begin messing with echo and delay, and rerecord over non-new signal channels
    • Series of 74AUP1G157GW MUX to prevent any damage to memories when recording fresh signals and to make this process automizable
    • A pulse generation setup which does not need an external function generator… (like by using an oscillator can).

    Some possible playful interface designs (I especially like the gravity effected ones) :

    ***

    Arduino controlled SRAM :

    Not yet working so going to test with two mechanical relays – this HAS to work or else I’m crazy.

    This code can get the SRAM writing :

    void setup() {
    pinMode(13, OUTPUT);
    pinMode(12, OUTPUT);
    }
    
    void loop() {
    //WRITE
    PORTB = B11101111; // CLK goes LOW/HIGH
    PORTB = B11011111; //WR goes HIGH/LOW
    }

    This code seems to work but it’s results are not predictable (I think because the code runs too slowly)… :

    unsigned long startMillis; //some global variables available anywhere in the program
    unsigned long currentMillis;
    const unsigned long period = 1000; //the value is a number of milliseconds
    int WRState = HIGH; // the current state of the WR pin
    
    void setup()
    {
    pinMode(13, OUTPUT); //WR PIN
    pinMode(12, OUTPUT); //CLK PIN
    pinMode(11, OUTPUT); //ADC EN PIN
    startMillis = millis(); //initial start time
    }
    
    void loop()
    {
    
    if(WRState == HIGH)
    {
    currentMillis = millis(); //get the current "time" (actually the number of milliseconds since the program started)
    
    //WRITE TO SRAM
    PORTB = B11101111; // CLK goes LOW/HIGH, ADC_EN HIGH
    PORTB = B11011111; //WR goes HIGH/LOW, ADC_EN HIGH
         if (currentMillis - startMillis >= period) //test whether the period has elapsed
         {
          WRState = !WRState;
          startMillis = currentMillis; //IMPORTANT to save the start time of the current LED state.
         }
    }
    
    if(WRState == LOW)
    {
    currentMillis = millis(); //get the current "time" (actually the number of milliseconds since the program started)
    
    // READ SRAM
    PORTB = B11100111; // CLK goes LOW/HIGH, ADC_EN LOW
    PORTB = B11110111; //WR stays high, ADC_EN LOW
    
         if (currentMillis - startMillis >= period) //test whether the period has elapsed
          {
           WRState = !WRState;
           startMillis = currentMillis; //IMPORTANT to save the start time of the current LED state.
          }
    }
    }
    

    Magnetic Media Video Synthesis

     

    I want to continue messing around with magnetic media (audio cassette players/recorders, floppy disk drives, video camcorders) and try to get them recording and playing back video.

    Here is some inspiration :

    From the timeless Hardware Hacking manual. The suggestion is to use a high gain amplifier to hear the results of the tape pickup. :

    A very cool project putting video onto a cassette :

    https://www.ubergizmo.com/2020/04/audio-cassette-tape-used-to-capture-video/

    From this reply : https://electronics.stackexchange.com/questions/108907/create-input-jack-from-tape-head

    “You can use the continuity tester to check for the ground lead. This should be connected to the metal shield of the head, you can leave it unconnected. You’ll want to connect the other two wires to your two inputs”

    From this site http://stevecoates.net/walkman/ :

    This https://makezine.com/projects/turn-old-walkman-scratchbox/ Make Magazine article connects simply :

    Four-terminal play head

    Some very cool experiments with a disconnected tape head :

    And a custom loop tape :

    **************************

    I began testing a bit, it looks like I can both see and hear the audio signals from the tape (yellow is R?, blue is L?):

    It’s most audible right near the end (the hum is the tape cassette motor spining) :

     

    *****************************************

    The method is just to power the cassette rotating motor with around 3.3V, then hook up the red(R?) or white(left?) to a probe or audio in for an amp, and then the black (GND) – which looks like it’s connected to two pins – to GND.

    The next step would be to try to amplify with a high gain op-amp circuit ? And then to begin trying to write ?

    UPDATE :

    Might be easier to work with the electronics already present on the board, learn how it works, desolder it and then put it on a breakout board to mess around with? Here is one of the simplest ICs I found on one of the dissassembled tape decks in an easy to solder SOP16 package:

    I could order a series of boards like this to make tests with them : SOIC-32, SOP-32 | SMD to DIP Adapter | SchmalzTech

    UPDATE:

    I plugged in the little audio amp into the Audio out jack of the device while I touched different pins on the IC. I found that the large slide switch on the back switched from REC to PLAY. I found that during REC mode the pins that caused the most amplification were the MIC IN and EQ IN. In PLAY mode I found the most important pin for producing output on the AUDIO OUT was LINE IN.

    I also tried connecting the little speaker amp to the REC OUT, LINE OUT while I touched various pins. 

    I was unable to amplify the tape head signals however with any of the various combinations I tried. I will try the other tape cassette circuit boards to see if I have any more luck, and also test the 2.5W power amp from Adafruit. Ideally I would be able to take an input, amplify it, send it to the tape head, then read it back by reversing the sequence after rewinding to the same section. This should also work with a strip of tape taped to a desk that I can manually run the magnet head over (right??). 

    Once I’m able to do this, I want to try the same thing (amplify an analog signal, write it to the disk through the heads directly, then read the analog signal back off it) with the Floppy Circuitry. 

    *************

    A great VCR technical reference : https://www.wikiwand.com/en/VHS

    I got my hands on a VCR, took it apart and broke out the cable coming from the helical read/write head.

     

     

    It looks like there is one little board with all the drivers for the various motors. Might be able to control it. (See this video : https://www.youtube.com/watch?v=4F7xJOb32GI&ab_channel=LifeOfDiy). I’ve got a BA6878EFV 3-phase motor driver for VTR capstan, datasheets available online. It looks like you need to plug in GND (3), 5V (2), and then connect EC(7) and HYS OUT (9) together.

    So far I haven’t been able to pick anything up on the oscilloscope from moving the tape across the print heads while listening in to various output pins.

    https://www.wikiwand.com/en/VHS#Media/File:Medion_MD8910_-_VHS_Helical_scan_tape_head-8601.jpg

    There appear to be two video heads (with two wires each – one wire for each electromagnet) and two audio heads (with one wire each) making a total of 6 wires with 1 dummy. It looks like the pinout is the following :

    1. Video Green 1
    2. Video Red 1
    3. Video Green 2
    4. Video Red 2
    5. No connection (shortened turn)
    6. Audio Red
    7. Audio Green

    It seems like others have two shortened turns to help isolate signals from one another.

    I measured the resistances between the output pins:

    1. grey 
    2. white
    3. blue(1)
    4. green
    5. yellow(1)
    6. orange
    7. red
    8. blue(2)
    9. yellow(2)

    The following are connected :

    Looking up the chip LA71750 ( Video and Audio Signal-Processing IC) – on the right in the image below – and the LA7264B (Audio Signal-Processing IC) – on the left – and checking out the datasheets and inspecting the PCB, looks like the following are the important connections :

    From the LA71750 datasheet :

     

    Would appear possible to make this pinout diagram :

    I have tried connecting pins to the oscilloscope while moving the tape head, but even at 10mV level at various time scales I can’t see anything. 

    UPDATE : Just seeing now that this chip takes control data in the form of I2C. It would be super hard for me to desolder the chip and make my own controller with it as a result.

    ******************

    I have tried amplifying and sending 20V signals at various frequencies. 

    Turning to more research for answers, check out these links :

    Article about audio sampler made from floppy :

    https://nime.pubpub.org/pub/uh76shf0/release/1

    Video made from floppy :

    Freespin is a demo made for the Commodore 1541 – no, not the computer, just the floppy drive

    For more tech info about floppy heads :

    http://forums.openmusiclabs.com/viewtopic.php?f=11&t=92&sid=9a4c3a6763f9bc02426c9d3910187e70

    ******************

    From this reading break I think the following things should be attempted :

    -with a >2W class D amp can I push some signal onto the tape that I can then read ? (Just afraid that it won’t be fast enough for video signals as it is made for audio signals ? Perhaps a high power high speed amp is even better?).

    -I could get the same preamp LA IC used in the concentric sampler paper.

    -Everyone seems to say, “try different combinations with the R/W heads” and “check continuitiy” and apply the signal to continuous wires. 

    -I could try adding the bias oscillator to the signal I’m trying to R/W?

    -I should get a super strong magnet for testing purposes

    ***********

    Looking at my floppy drive, I found the following CX20185 chip which is a Read/Write Amplifier for Floppy Disk Drive.

    It looks like the pinout is the following :

    It looks like I could read the Preamp Out pins to read from the floppy. I’m not sure how I could yet wright to the floppy without giving data to the logic on the driver.

    Here is me figuring out the pinout :

    I turned on the floppy LED I have by connecting the sixth pin next to the stepper head motor to the GND, and turned on the central motor by connecting the 8th pin to GND and plugging in 12V as well :

    When I listen in to READ DUMP A or B I can see voltage when I spin the disk manually (when I plug in the brushless motor it no longer responds to spinning):

    When I listen in to PRE OUT A or B I can see the normally high voltage go down and vary :

    Meh. 

    Some stuff about data degredation :

    https://fr.wikipedia.org/wiki/The_Disintegration_Loops

    Project Kryoflux – Part 3: Recovery in Practice

    ******

    Suggestion from research engineer at DVIC for the previous experiments:

    -For the floppy, look at the input from head (but oscilloscope will probably mess this up), preamp, and digital out (READ OUT – which should be connected directly to the chip I have the datasheet for) at same time. 

    -Basically you’re not going to see anything on the oscilloscope when looking at these electromagnets. It’s all in the very sensitive amp – so all the more reason to use the amp that comes with the device !

    -Is the preamp chip IC I am looking at even enabled ? Check POWER ON.

    -Try the floppy pinout here : https://old.pinouts.ru/HD/InternalDisk_pinout.shtml

    -For the VCR, get the thing plugged in and functioning as it was in the beginning. Observe it first, then try to intervene (you’ll never be able to reinvent the thing from nothing !)

    ****

    Listening to the DATA READ pin 33 while the disk is spinning :

    ****

    UPDATES:

    I learned from watching this (https://www.youtube.com/watch?v=DdMOGvKjrfk&ab_channel=JeffHxC2001) that the way to read is to sync the oscilloscope with the INDEX pulse. The Difference Out pin is the one being listened to in this video.

    I learned from looking more into the floppy interface that the Head Select (32) is HIGH for BOTTOM and LOW for TOP head. I also learned that Floppy Write Enable (24) is HIGH to READ and LOW to WRITE. Finally, the READY pin 34 may need to be tied to GND.

    From a Floppy Maintenance Manual showing the sequence : R/W head > Pre-Amp > Differentiator > Voltage Comparator > Time/Domain Filter > DATA OUT

    UPDATES:

    I think to make this project work, I would first need to *VERY CAREFULLY* observe the correct functioning of a working device without any changes made to it. I would need to be able to confirm completely the working of the machine, and see what signals are supposed to look like at each step. 

    Only after doing this could I start intervening in this process.

    I think Floppy is the best way to go – it’s part of the history of the computer (like all my other projects) which isn’t the case with the video recorder. The floppy is the best documented, easiest to source, and least expensive to work with. It already has a nice interface which is easy to use. It also is more standardized, unlike the many different kind of video recorders that exist. 

    What is the most standard Floppy Drive Read/Write Amplifier ? The Sony CXA series (1360, 1720, 3010, 3071, 20185, etc.) seem to have specs available online. ROHM also have BH6xxx and BA6xxx series. 

    Then again if I’m only going to be recording analog, I don’t need anything but the preamp (especially for reading) ? I could just take the tape preamps I have and put them on a breakout board ? I have BA3110, CX20023, and a CXA1262 to work with. I could try getting them to work amplifying the mic first, and also get the playback working. Then I could test putting analog signals on a floppy.

    Video synth workshop

    This workshop with La Diagonale at UP Saclay is a simple circuit to begin playing with code and screen patterns. 

    Here is the github: https://github.com/merlinmarrs/spaghettini-video-synth

    Arduino Coding and Video Synthesis Workshop

    Lean to code in C with Arduino, solder and assemble a custom printed-circuit board made in the Fablab, and make your own algorithmically-generated video art!

    This workshop is inspired by the improvisational music of Live coding (https://fr.wikipedia.org/wiki/Live_coding) and the burgeoning minimalist Bytebeats movement (https://nightmachines.tv/bytebeats-tutorial).

    Our video synthesis kit plugs in to the Arduino (https://www.arduino.cc/), a reprogrammable embedded micro-controller that can interact with the world through code, and uses the VGAX library (https://github.com/smaffer/vgax) to generate funky video.

    Meet other creative technologists and sharpen your expertise in computer sciences and electronics soldering!

    Here are some initial sketches :

    The functionality that is important is :

    -being able to select between different programs (with button and leds to indicate)

    -to be able to take audio in and have it modify the patterns on screen

    -to be able to change the colors on the go

    -I have since phased out the brightness changeability but I could add an LDR easily ?

    *******************************************************************************************

    Because our lasercutter is not operational, I am trying to make this circuit with the vinyl cutter using 5cm wide copper tape. 

     

    I am worried about the headers getting pulled out when plugging/unplugging. I will try adding some hot glue to fortify them. The other option is potting the circuit in resin but that would get messy and expensive. 

    Errata:

    -button too close to headers when glue is applied

    -remember space for audio in jack plug 

    -the two columns of headers for the Arduino should not be continuous, also unclear what is first and last pin. Also they should be SMD headers. 

    -don’t mess with RX and TX pins on the Arduino. 

    -make a version with VGA plug?

    -add text but have it cut onto plastic not made from metal

    -audio offset thing doesn’t work

    I also want to think about expandability, how could people take this project further by themselves afterwards ?

    -Having a knob  or two knobs / LDR connected to an analog in on the Arduino…

    -Be able to control the program based on voltage control levels at an input. This could mean it could even be attached to the polyphonic synth !

     

    ***************************************************************************

    Here is the next version called the Spaghettini:

    -It respects the height of the 50mm wide copper tape I have on hand.

    -It makes more sense for the audio in cable to plug in at the side and not interfere with the capacitive sensor. 

    -It uses curvy lines just for the capacitive sensing functionality and straight elsewhere which feels honest. 

    -It has the ability to modify the brightness of any of the three channels, one at a time. 

    -It has a potentiometer for analog in in adition the capacitive sensor. 

    -I’m experimenting with different patterns on the left portion.

    -The sensor works with the Arduino library CapacitiveSensor 

    And here’s what it looks like all plugged in ! (But I need to add hot glue to make it really usable)

     

    Memory Experiments (continued)

    I have two goals for this project:

    1. Finish the VGA video recorder board (with op amps, bias pots, bias for ADC) – DONE!
    2. Make a version of the vectorscope image modification series but with a raster system taking the following image as the input – DONE :

    1. Finishing the VGA Video Sampler board

    For the first goal, I need to correct that last board I made:

    Errata:

    -The gain pots for the op-amp don’t work.

    -I mixed up VCC (3.3V) and VCA (5V) in several places. (I just replaced the PFET with the LDO and manually rewired)

    -The “EN” text next to the ADC was in the wrong place. 

    -I forgot to tie down the reset of 74HC590 with a 10K resistor.

    -The 74HC04 is labelled backwards, I put inputs on the right and outputs on the left for some reason.

    Things appear to work with these changes:

    It takes some knob fiddling but I can get an input sine wave digitalized. One definitely needs an oscilloscope to see what’s happening though.

    2. Vectorscope image series

    I can either load the image into memory by playing it on a computer screen and capturing the pixels, OR, loading the image into memory with a microcontroller. I’m not sure how big I should make the image, and what dimensions, if I load the image. 

    Here is the p5.js code to take an image (called p.jpg) and print the red pixel value into a text document (called OUTPUT) with a comma and space seperator :

    let img;
    
    function preload() {
    img = loadImage('p.jpg');
    }
    
    function setup() {
    createCanvas(img.width, img.height);
    background(220);
    image(img, 0, 0);
    let writer = createWriter('OUTPUT.txt');
    
    for(var y = 0; y < height; y++) {
    for(var x = 0; x < width; x++){
    let pix = img.get(x, y);
    writer.write(pix[0] + ', '); // takes RED pixel info, adds a comma and a space
    if(!(y==1-height || x==1-width))
    {
    writer.write(pix[0]); // don't put a comma if it's the last element of the list
    }
    }
    }
    writer.close();
    }

    And here is the Arduino code to take this color information and load it into the memory space (90×90 max as PROGMEM has max 8,192 bytes max):

    byte myChar;
    
    #define IMG_WIDTH 90
    #define IMG_HEIGHT 90
    //data size=900 bytes
    const unsigned char img [IMG_HEIGHT*IMG_WIDTH] PROGMEM={
    17, 19, 19, 19, 19, 20, 20, 20, 20, 20, 21, 23, 23, 22, 21, 21, 22, 22, 21, 22, 21, 22, 21, 20, 21, 21, 23, 23, 23, 23, 23, 23, 24, 23, 25, 23, 24, 23, 25, 25, 25, 25, 25, 24, 25, 26, 24, 23, 25, 24, 23, 24, 25, 21, 20, 24, 24, 23, 20, 20, 21, 23, 22, 22, 22, 22, 22, 23, 23, 24, 23, 23, 23, 25, 23, 24, 24, 23, 24, 25, 23, 25, 25, 23, 25, 24, 24, 25, 28, 28, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 19, 35, 25, 32, 32, 26, 27, 17, 23, 27, 30, 33, 33, 35, 37, 35, 29, 30, 34, 37, 44, 26, 30, 65, 65, 57, 56, 55, 57, 59, 42, 38, 46, 38, 33, 40, 41, 43, 46, 35, 3, 0, 0, 0, 0, 1, 1, 0, 9, 49, 18, 0, 4, 0, 0, 0, 3, 2, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 3, 29, 231, 255, 245, 252, 250, 247, 248, 240, 245, 249, 255, 255, 255, 255, 255, 254, 254, 255, 255, 255, 255, 252, 252, 255, 254, 255, 254, 255, 255, 255, 254, 255, 255, 254, 253, 255, 255, 255, 255, 255, 71, 1, 1, 1, 1, 0, 15, 189, 244, 255, 223, 205, 216, 183, 191, 207, 210, 221, 234, 240, 233, 220, 215, 113, 138, 251, 225, 219, 223, 224, 169, 166, 201, 208, 217, 220, 196, 190, 181, 189, 181, 188, 193, 148, 149, 207, 171, 25, 0, 50, 255, 255, 255, 255, 255, 255, 255, 255, 254, 255, 250, 245, 244, 253, 255, 255, 246, 240, 239, 231, 239, 234, 255, 255, 255, 249, 238, 234, 247, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 255, 90, 0, 1, 0, 1, 1, 43, 245, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 241, 229, 249, 255, 255, 255, 254, 249, 249, 248, 255, 251, 254, 254, 255, 242, 235, 241, 253, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 77, 0, 31, 240, 254, 249, 189, 170, 192, 190, 179, 202, 131, 12, 4, 0, 107, 226, 192, 54, 0, 11, 8, 2, 2, 146, 225, 204, 71, 0, 0, 65, 200, 206, 192, 194, 197, 185, 200, 255, 255, 255, 211, 24, 0, 1, 0, 1, 0, 8, 178, 255, 255, 243, 204, 194, 197, 198, 189, 209, 181, 25, 0, 0, 106, 217, 213, 96, 0, 6, 5, 7, 0, 126, 236, 199, 38, 0, 0, 84, 220, 208, 203, 205, 198, 210, 200, 225, 255, 255, 68, 0, 19, 226, 254, 219, 10, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 190, 255, 255, 95, 0, 3, 0, 2, 0, 3, 0, 48, 253, 255, 151, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 144, 255, 255, 80, 0, 62, 255, 255, 235, 24, 0, 0, 0, 0, 0, 3, 2, 0, 1, 2, 0, 1, 5, 3, 1, 1, 2, 4, 1, 0, 0, 1, 0, 3, 2, 0, 0, 0, 0, 0, 0, 0, 189, 255, 255, 105, 0, 1, 1, 1, 0, 3, 0, 65, 255, 255, 124, 0, 1, 0, 0, 0, 0, 0, 3, 6, 2, 1, 0, 0, 4, 3, 0, 3, 1, 1, 2, 1, 0, 2, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 157, 255, 255, 85, 0, 45, 252, 255, 241, 31, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 2, 1, 0, 0, 187, 255, 255, 102, 0, 2, 1, 0, 0, 2, 0, 94, 255, 254, 143, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 2, 3, 1, 0, 0, 0, 134, 255, 255, 69, 0, 48, 253, 255, 227, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 178, 255, 255, 119, 0, 1, 0, 0, 1, 2, 0, 66, 255, 255, 138, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 145, 255, 255, 84, 0, 49, 254, 255, 229, 19, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 1, 0, 0, 0, 1, 1, 2, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 196, 255, 255, 110, 0, 0, 0, 0, 0, 2, 1, 54, 255, 255, 138, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 130, 254, 255, 76, 0, 39, 245, 255, 225, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 2, 1, 23, 233, 255, 255, 82, 0, 2, 1, 0, 1, 1, 0, 61, 255, 255, 124, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 142, 255, 254, 74, 0, 55, 255, 254, 246, 31, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 6, 207, 255, 255, 116, 0, 2, 0, 0, 0, 1, 1, 99, 255, 255, 137, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 92, 255, 255, 83, 0, 32, 254, 255, 107, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 1, 0, 0, 2, 1, 0, 71, 231, 255, 79, 0, 3, 0, 0, 0, 5, 0, 68, 241, 193, 48, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 159, 255, 89, 0, 55, 255, 182, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 1, 1, 0, 4, 1, 0, 0, 5, 6, 0, 0, 0, 2, 3, 1, 1, 0, 1, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 3, 3, 0, 137, 255, 95, 0, 52, 255, 186, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 3, 0, 0, 2, 1, 1, 1, 1, 14, 41, 8, 0, 1, 1, 0, 0, 2, 7, 4, 0, 1, 2, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 2, 0, 0, 173, 255, 80, 0, 40, 254, 238, 34, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 7, 5, 0, 0, 0, 1, 1, 0, 29, 124, 222, 255, 113, 0, 0, 0, 0, 0, 4, 0, 44, 174, 80, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 114, 255, 255, 75, 0, 44, 250, 255, 225, 17, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 3, 1, 5, 1, 2, 5, 6, 3, 1, 2, 4, 4, 4, 2, 0, 0, 0, 1, 0, 93, 255, 255, 254, 191, 1, 0, 0, 0, 0, 2, 0, 60, 255, 255, 101, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 1, 0, 0, 2, 0, 113, 255, 255, 87, 0, 47, 251, 255, 249, 36, 1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 1, 2, 1, 1, 3, 3, 1, 1, 1, 3, 0, 1, 1, 0, 0, 0, 0, 1, 89, 255, 255, 255, 178, 0, 0, 0, 0, 1, 2, 0, 66, 241, 255, 139, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 67, 255, 255, 87, 0, 51, 245, 254, 235, 24, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 86, 255, 255, 254, 197, 0, 0, 0, 0, 0, 3, 0, 97, 163, 192, 142, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 1, 0, 1, 0, 1, 115, 255, 255, 77, 0, 68, 254, 255, 241, 29, 1, 2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 95, 255, 255, 255, 192, 0, 1, 0, 1, 0, 3, 0, 78, 237, 254, 114, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 118, 255, 255, 84, 0, 72, 255, 255, 251, 41, 0, 2, 0, 0, 1, 3, 1, 1, 0, 0, 3, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 2, 1, 0, 1, 2, 0, 71, 255, 254, 255, 160, 0, 0, 0, 0, 1, 3, 0, 26, 233, 255, 132, 0, 0, 2, 0, 1, 1, 2, 2, 2, 2, 2, 0, 1, 0, 1, 2, 0, 1, 2, 3, 3, 2, 1, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 165, 255, 255, 83, 0, 77, 255, 254, 227, 17, 0, 0, 0, 0, 0, 1, 4, 2, 2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 51, 253, 255, 255, 158, 0, 0, 0, 0, 2, 0, 1, 54, 255, 255, 98, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 3, 3, 4, 2, 0, 0, 0, 0, 0, 0, 0, 139, 255, 255, 72, 0, 71, 255, 255, 229, 89, 66, 87, 83, 78, 90, 46, 0, 0, 0, 103, 142, 136, 145, 128, 162, 157, 122, 126, 127, 128, 127, 128, 130, 128, 128, 127, 127, 127, 126, 125, 106, 172, 255, 255, 255, 224, 30, 0, 0, 0, 0, 3, 0, 92, 255, 254, 135, 0, 46, 44, 8, 11, 39, 30, 25, 26, 34, 54, 45, 22, 39, 32, 28, 28, 26, 28, 27, 38, 14, 0, 4, 0, 5, 32, 37, 29, 27, 32, 25, 9, 169, 254, 255, 88, 0, 26, 227, 255, 255, 255, 255, 255, 255, 255, 255, 231, 36, 0, 61, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 254, 255, 255, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 116, 0, 0, 0, 1, 0, 20, 190, 255, 254, 250, 239, 255, 255, 181, 196, 255, 245, 240, 241, 248, 255, 247, 239, 253, 246, 245, 245, 242, 243, 243, 255, 173, 0, 0, 0, 100, 254, 255, 245, 243, 247, 246, 246, 250, 255, 255, 79, 0, 46, 245, 255, 255, 254, 255, 255, 255, 255, 255, 255, 190, 0, 163, 255, 255, 254, 255, 255, 255, 255, 255, 254, 255, 254, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 254, 255, 254, 255, 255, 255, 138, 0, 0, 0, 1, 0, 61, 255, 255, 255, 254, 255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 119, 0, 12, 222, 255, 255, 255, 255, 255, 254, 255, 255, 255, 249, 48, 0, 80, 255, 255, 237, 139, 113, 121, 128, 127, 123, 149, 83, 1, 92, 219, 207, 197, 173, 206, 190, 150, 183, 255, 255, 255, 221, 214, 199, 170, 170, 180, 189, 242, 255, 255, 255, 254, 255, 255, 255, 255, 131, 0, 0, 0, 1, 0, 58, 255, 254, 255, 255, 254, 255, 255, 172, 80, 103, 108, 175, 220, 199, 101, 141, 255, 255, 158, 74, 100, 96, 102, 107, 87, 109, 60, 0, 4, 104, 128, 109, 115, 114, 125, 108, 97, 209, 255, 255, 88, 0, 58, 255, 255, 157, 0, 0, 0, 0, 0, 1, 0, 0, 5, 1, 1, 0, 0, 1, 0, 1, 0, 10, 221, 255, 253, 48, 2, 1, 0, 3, 12, 83, 255, 255, 254, 255, 255, 255, 254, 249, 193, 35, 0, 1, 0, 1, 1, 0, 79, 162, 233, 255, 255, 255, 255, 129, 0, 1, 8, 14, 11, 6, 8, 85, 255, 255, 70, 0, 0, 1, 1, 0, 0, 1, 1, 7, 10, 2, 1, 0, 0, 0, 0, 1, 0, 115, 255, 255, 86, 0, 80, 254, 187, 0, 0, 0, 2, 1, 1, 1, 0, 2, 6, 1, 0, 0, 0, 1, 0, 0, 0, 23, 231, 255, 255, 60, 1, 0, 1, 98, 200, 251, 254, 255, 255, 255, 241, 154, 81, 9, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 6, 70, 183, 254, 255, 254, 189, 27, 16, 8, 0, 0, 5, 169, 255, 255, 86, 0, 1, 2, 3, 5, 4, 1, 1, 3, 5, 4, 4, 0, 1, 3, 1, 3, 0, 0, 169, 255, 90, 0, 88, 255, 179, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1, 5, 5, 5, 1, 0, 2, 0, 1, 57, 255, 255, 255, 86, 0, 1, 137, 255, 255, 254, 255, 254, 209, 79, 11, 1, 0, 0, 1, 2, 0, 1, 0, 0, 1, 1, 2, 1, 1, 0, 0, 42, 168, 255, 255, 252, 152, 27, 1, 0, 14, 193, 255, 255, 88, 0, 2, 0, 2, 1, 1, 3, 6, 2, 0, 6, 4, 0, 1, 0, 0, 2, 4, 0, 150, 255, 89, 0, 64, 255, 255, 73, 0, 0, 0, 0, 2, 2, 8, 8, 0, 2, 4, 3, 1, 0, 1, 1, 0, 47, 250, 255, 255, 114, 0, 141, 255, 255, 255, 255, 247, 107, 0, 0, 1, 1, 2, 0, 1, 1, 0, 0, 1, 0, 0, 1, 2, 2, 0, 2, 1, 0, 0, 77, 244, 255, 255, 200, 22, 4, 12, 141, 255, 255, 87, 0, 2, 3, 1, 1, 0, 1, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 33, 221, 255, 79, 0, 72, 255, 255, 201, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 34, 242, 255, 255, 90, 50, 255, 255, 253, 255, 220, 37, 0, 1, 9, 3, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 2, 2, 1, 1, 1, 0, 4, 4, 0, 27, 208, 255, 255, 196, 24, 8, 62, 255, 254, 86, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 174, 255, 255, 92, 0, 99, 255, 255, 227, 16, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 64, 255, 255, 255, 87, 145, 255, 255, 255, 214, 23, 0, 2, 2, 5, 5, 0, 2, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 5, 0, 8, 192, 255, 185, 5, 2, 80, 255, 255, 91, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 172, 255, 255, 93, 0, 105, 255, 255, 226, 16, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 52, 253, 255, 243, 131, 217, 255, 255, 235, 33, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 2, 0, 0, 214, 207, 0, 0, 73, 254, 255, 89, 0, 3, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 173, 255, 255, 97, 0, 93, 255, 255, 221, 13, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 49, 252, 255, 253, 254, 255, 255, 255, 97, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 33, 239, 193, 81, 141, 255, 254, 93, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 168, 255, 255, 93, 0, 68, 255, 245, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 34, 242, 255, 255, 255, 254, 255, 139, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 113, 254, 255, 255, 254, 255, 94, 1, 3, 0, 0, 1, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 191, 255, 94, 0, 69, 255, 185, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 16, 228, 254, 255, 255, 255, 212, 15, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 5, 204, 255, 255, 255, 255, 88, 0, 2, 1, 1, 3, 2, 1, 5, 2, 2, 1, 1, 1, 1, 0, 0, 2, 1, 0, 153, 255, 95, 0, 92, 254, 179, 0, 1, 0, 0, 0, 0, 0, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74, 254, 255, 255, 255, 255, 111, 0, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3, 0, 101, 255, 255, 255, 255, 94, 1, 0, 3, 2, 3, 4, 5, 7, 3, 5, 7, 5, 2, 0, 1, 0, 0, 5, 1, 163, 255, 93, 0, 102, 255, 241, 50, 0, 0, 0, 0, 0, 1, 0, 5, 4, 2, 0, 0, 0, 0, 0, 0, 0, 81, 255, 254, 254, 255, 233, 25, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 3, 1, 10, 216, 254, 255, 254, 86, 0, 0, 1, 0, 0, 0, 1, 2, 6, 6, 4, 0, 0, 1, 0, 0, 0, 1, 21, 220, 255, 87, 0, 72, 255, 254, 235, 163, 162, 167, 164, 164, 182, 89, 0, 0, 15, 192, 233, 211, 212, 212, 210, 236, 223, 242, 255, 255, 255, 164, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 2, 0, 0, 125, 255, 255, 255, 169, 87, 118, 97, 98, 106, 124, 72, 0, 5, 0, 39, 152, 148, 142, 143, 141, 146, 132, 216, 255, 255, 94, 0, 81, 255, 255, 255, 254, 255, 255, 255, 255, 255, 246, 63, 0, 115, 255, 255, 255, 255, 255, 255, 255, 254, 255, 254, 255, 255, 67, 0, 1, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 6, 0, 56, 255, 254, 255, 255, 255, 255, 255, 255, 254, 255, 255, 75, 0, 0, 165, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 98, 0, 87, 254, 255, 254, 255, 254, 255, 255, 255, 255, 255, 109, 0, 165, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 48, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 25, 232, 255, 237, 255, 244, 238, 255, 249, 248, 255, 254, 150, 0, 2, 212, 255, 255, 255, 255, 254, 254, 250, 252, 255, 255, 100, 0, 37, 224, 255, 173, 71, 81, 83, 70, 66, 70, 69, 20, 0, 81, 177, 148, 121, 117, 119, 116, 116, 119, 116, 118, 128, 82, 1, 1, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2, 1, 3, 2, 0, 25, 36, 15, 41, 23, 18, 46, 31, 26, 36, 30, 10, 0, 0, 34, 55, 37, 40, 41, 41, 40, 8, 91, 234, 222, 57, 0, 0, 11, 12, 3, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 3, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 4, 1, 0, 0, 0, 1, 1, 0, 0, 0, 2, 0, 3, 4, 3, 0, 0, 1, 4, 2, 2, 2, 1, 3, 2, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 3, 4, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 3, 6, 1, 2, 1, 0, 0, 2, 5, 4, 0, 0, 2, 2, 0, 2, 10, 7, 0, 0, 2, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 4, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 5, 8, 1, 5, 7, 2, 1, 0, 0, 0, 1, 1, 0, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 1, 0, 0, 0, 0, 0, 5, 1, 1, 0, 6, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 4, 1, 0, 0, 0, 0, 0, 7, 8, 0, 0, 1, 0, 0, 0, 0, 0, 3, 56, 60, 8, 0, 1, 161, 252, 137, 40, 65, 62, 45, 46, 68, 68, 16, 0, 18, 97, 111, 100, 100, 95, 100, 111, 113, 108, 129, 137, 42, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 1, 1, 0, 11, 183, 217, 202, 207, 213, 221, 195, 189, 202, 211, 234, 99, 0, 0, 104, 182, 142, 141, 153, 141, 145, 126, 189, 255, 253, 45, 0, 18, 225, 255, 255, 255, 255, 255, 255, 255, 255, 255, 83, 0, 73, 255, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 177, 0, 0, 2, 1, 2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 3, 0, 62, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 103, 0, 1, 164, 255, 255, 255, 255, 255, 254, 255, 254, 255, 251, 46, 0, 8, 210, 255, 255, 254, 252, 253, 255, 253, 255, 180, 2, 0, 0, 181, 255, 255, 254, 255, 255, 254, 254, 255, 255, 255, 233, 23, 0, 4, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 97, 255, 255, 255, 255, 247, 244, 241, 241, 244, 255, 156, 0, 0, 0, 34, 192, 208, 191, 190, 186, 186, 166, 218, 254, 249, 43, 0, 10, 225, 255, 119, 8, 26, 29, 28, 26, 28, 10, 0, 10, 1, 12, 57, 55, 52, 49, 36, 40, 35, 199, 255, 254, 255, 84, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 3, 1, 0, 159, 255, 255, 255, 135, 1, 23, 22, 20, 22, 16, 3, 0, 7, 8, 0, 1, 0, 0, 1, 0, 0, 1, 74, 255, 255, 40, 0, 20, 248, 131, 1, 1, 0, 0, 0, 0, 1, 0, 3, 2, 4, 2, 0, 0, 0, 0, 0, 0, 0, 169, 254, 255, 255, 165, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 4, 1, 31, 240, 255, 255, 255, 117, 0, 1, 0, 0, 0, 0, 1, 3, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 136, 255, 46, 0, 21, 246, 124, 0, 1, 0, 0, 0, 0, 2, 1, 1, 2, 1, 4, 0, 0, 0, 1, 2, 0, 1, 184, 255, 255, 254, 255, 55, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 1, 0, 148, 254, 255, 255, 255, 118, 0, 0, 0, 1, 2, 1, 0, 2, 1, 0, 3, 2, 1, 0, 0, 0, 2, 6, 1, 124, 255, 45, 0, 16, 250, 156, 0, 1, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 1, 0, 0, 0, 0, 1, 0, 194, 255, 254, 255, 255, 171, 0, 0, 2, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 6, 0, 40, 245, 255, 255, 255, 255, 121, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 0, 137, 255, 42, 0, 22, 240, 255, 93, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 196, 255, 255, 255, 255, 255, 80, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 137, 255, 255, 255, 255, 254, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 73, 255, 255, 49, 0, 13, 219, 255, 148, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 191, 255, 255, 255, 176, 202, 247, 31, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 2, 0, 64, 253, 255, 254, 255, 255, 255, 122, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 138, 255, 250, 46, 0, 13, 222, 255, 113, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 2, 0, 1, 0, 190, 255, 254, 99, 0, 134, 255, 173, 0, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 4, 0, 24, 248, 192, 40, 29, 128, 255, 255, 113, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 107, 255, 255, 46, 0, 22, 227, 255, 138, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 188, 254, 197, 0, 54, 255, 255, 254, 153, 0, 1, 2, 2, 0, 0, 0, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 2, 3, 0, 1, 2, 1, 4, 7, 0, 23, 217, 255, 200, 24, 0, 94, 254, 255, 126, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 142, 255, 245, 38, 0, 17, 233, 255, 103, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 191, 255, 212, 8, 24, 181, 255, 255, 255, 186, 20, 0, 0, 3, 4, 2, 1, 2, 2, 0, 0, 0, 0, 1, 0, 2, 2, 0, 3, 2, 1, 3, 1, 0, 48, 230, 255, 255, 254, 84, 11, 84, 255, 255, 132, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 98, 254, 254, 39, 0, 18, 248, 143, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 4, 209, 255, 255, 108, 5, 4, 123, 255, 255, 255, 235, 75, 0, 0, 3, 5, 0, 4, 4, 0, 0, 1, 1, 1, 2, 0, 4, 1, 2, 4, 2, 0, 0, 109, 255, 255, 255, 254, 111, 4, 11, 165, 255, 255, 116, 1, 1, 2, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 3, 1, 0, 139, 255, 48, 0, 18, 245, 126, 0, 1, 0, 1, 2, 0, 0, 2, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 183, 255, 255, 89, 1, 1, 6, 94, 239, 255, 254, 255, 186, 52, 0, 0, 1, 0, 6, 7, 0, 0, 0, 0, 2, 7, 6, 2, 0, 0, 0, 80, 211, 255, 255, 255, 179, 33, 8, 0, 5, 162, 254, 255, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 128, 255, 47, 0, 25, 255, 173, 0, 0, 0, 0, 0, 1, 0, 0, 4, 4, 2, 1, 0, 0, 0, 0, 0, 1, 0, 200, 255, 245, 48, 6, 0, 2, 11, 15, 140, 252, 255, 255, 255, 185, 74, 0, 0, 0, 4, 2, 0, 0, 2, 5, 2, 0, 1, 7, 90, 201, 255, 255, 255, 255, 113, 9, 12, 0, 0, 5, 134, 255, 255, 123, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 143, 255, 44, 0, 31, 241, 255, 140, 7, 29, 33, 29, 14, 28, 32, 10, 0, 0, 51, 65, 51, 54, 54, 55, 36, 55, 227, 255, 235, 69, 142, 200, 122, 55, 1, 1, 189, 255, 255, 255, 254, 255, 227, 194, 108, 3, 0, 0, 0, 1, 0, 12, 102, 165, 228, 255, 255, 255, 255, 255, 123, 0, 9, 92, 135, 130, 52, 149, 255, 255, 137, 0, 19, 23, 24, 11, 0, 21, 9, 0, 5, 0, 0, 0, 0, 0, 0, 0, 1, 80, 255, 255, 64, 0, 10, 213, 255, 254, 251, 249, 251, 247, 231, 249, 255, 107, 0, 32, 243, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 253, 243, 240, 254, 255, 255, 255, 255, 254, 255, 254, 255, 65, 0, 0, 1, 0, 0, 121, 255, 255, 255, 255, 255, 255, 255, 255, 220, 213, 241, 251, 255, 255, 253, 252, 255, 255, 250, 233, 237, 239, 241, 228, 216, 254, 185, 0, 0, 132, 189, 164, 167, 156, 163, 161, 155, 228, 254, 255, 61, 0, 17, 221, 255, 255, 255, 255, 255, 254, 255, 255, 228, 37, 0, 0, 171, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 66, 0, 1, 0, 0, 1, 124, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 167, 0, 1, 176, 255, 255, 255, 255, 255, 255, 255, 255, 255, 199, 1, 0, 21, 229, 255, 172, 79, 95, 102, 99, 95, 106, 46, 0, 2, 0, 36, 133, 138, 128, 127, 130, 132, 136, 140, 142, 141, 145, 145, 140, 142, 154, 159, 147, 157, 157, 143, 143, 146, 220, 255, 255, 153, 0, 0, 0, 0, 1, 0, 16, 200, 255, 255, 211, 148, 182, 180, 192, 203, 193, 188, 194, 196, 192, 187, 196, 189, 194, 196, 177, 187, 194, 201, 206, 220, 192, 29, 0, 0, 45, 175, 173, 158, 165, 164, 163, 137, 209, 255, 209, 12, 0, 26, 237, 255, 108, 1, 0, 0, 0, 0, 0, 0, 7, 5, 5, 3, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 152, 255, 254, 55, 1, 3, 0, 0, 0, 5, 0, 99, 255, 255, 122, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 3, 7, 5, 2, 1, 0, 0, 0, 0, 0, 0, 122, 255, 251, 43, 0, 30, 238, 255, 113, 0, 2, 0, 1, 0, 2, 2, 3, 3, 1, 2, 2, 2, 2, 2, 3, 5, 1, 1, 4, 3, 3, 3, 3, 4, 1, 1, 3, 1, 1, 1, 0, 1, 185, 255, 255, 87, 0, 1, 0, 1, 1, 0, 0, 141, 255, 255, 114, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 3, 2, 1, 0, 1, 0, 0, 0, 0, 0, 0, 142, 255, 255, 57, 0, 19, 228, 255, 120, 1, 0, 1, 0, 1, 0, 2, 0, 0, 0, 1, 2, 1, 1, 1, 2, 2, 1, 4, 2, 0, 0, 2, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 163, 255, 255, 74, 1, 1, 0, 0, 2, 0, 0, 141, 254, 255, 114, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 2, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 147, 255, 255, 54, 0, 30, 238, 255, 121, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 1, 142, 255, 255, 66, 0, 1, 1, 0, 0, 1, 0, 128, 255, 255, 105, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 152, 255, 247, 40, 0, 25, 232, 254, 119, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 174, 255, 255, 71, 0, 1, 0, 0, 2, 0, 0, 143, 255, 255, 106, 1, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 153, 255, 250, 45, 0, 28, 235, 254, 142, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 190, 255, 255, 76, 0, 1, 0, 0, 0, 0, 0, 148, 255, 255, 122, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 152, 255, 248, 45, 0, 20, 244, 230, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 117, 255, 255, 75, 1, 0, 0, 0, 0, 0, 1, 145, 255, 255, 94, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 118, 255, 250, 38, 0, 40, 254, 117, 1, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 70, 146, 27, 0, 1, 0, 0, 0, 2, 0, 65, 197, 84, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 143, 255, 39, 0, 25, 253, 126, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 3, 2, 0, 0, 4, 4, 0, 0, 1, 0, 2, 4, 0, 0, 0, 4, 4, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 121, 255, 43, 0, 27, 255, 137, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 1, 8, 25, 6, 1, 0, 0, 0, 0, 0, 4, 8, 11, 3, 2, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 114, 255, 52, 0, 39, 254, 255, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 23, 201, 237, 27, 0, 0, 0, 1, 0, 1, 0, 39, 240, 141, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 26, 206, 255, 45, 0, 37, 244, 255, 131, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 98, 255, 236, 27, 0, 2, 1, 0, 0, 3, 0, 34, 255, 255, 52, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 138, 255, 245, 39, 0, 37, 245, 254, 118, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 95, 255, 244, 32, 1, 0, 0, 0, 2, 1, 0, 55, 255, 255, 46, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 117, 255, 248, 39, 0, 33, 242, 255, 117, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 114, 255, 230, 21, 0, 1, 0, 0, 0, 4, 0, 51, 255, 255, 53, 0, 2, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 118, 255, 251, 43, 0, 29, 239, 255, 115, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 114, 255, 237, 35, 0, 1, 0, 0, 0, 5, 0, 45, 255, 254, 51, 0, 2, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 125, 254, 254, 48, 0, 34, 242, 255, 116, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 3, 2, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 109, 255, 242, 36, 0, 1, 0, 0, 1, 2, 0, 51, 254, 255, 56, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 1, 0, 1, 124, 255, 246, 38, 0, 34, 245, 255, 111, 0, 1, 0, 0, 0, 0, 1, 0, 2, 2, 0, 0, 1, 4, 3, 7, 3, 2, 2, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 108, 255, 218, 7, 0, 0, 0, 1, 0, 3, 0, 44, 254, 255, 50, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 0, 0, 1, 3, 3, 1, 1, 3, 1, 1, 0, 1, 1, 4, 2, 2, 0, 0, 0, 0, 0, 0, 0, 128, 255, 243, 36, 0, 40, 246, 255, 157, 9, 23, 32, 30, 17, 29, 13, 0, 1, 0, 24, 61, 25, 0, 1, 0, 0, 1, 0, 0, 34, 32, 0, 1, 0, 1, 12, 6, 0, 2, 19, 22, 0, 128, 255, 240, 36, 0, 2, 1, 1, 0, 1, 1, 64, 255, 255, 64, 1, 10, 7, 10, 10, 16, 6, 0, 0, 0, 10, 35, 13, 1, 0, 0, 0, 0, 0, 0, 6, 8, 0, 0, 0, 0, 3, 8, 6, 7, 8, 2, 0, 150, 255, 248, 43, 0, 27, 229, 255, 255, 247, 242, 246, 243, 233, 254, 216, 46, 0, 43, 217, 255, 242, 61, 0, 23, 11, 18, 0, 94, 255, 255, 102, 2, 6, 121, 253, 228, 215, 220, 241, 250, 176, 197, 255, 255, 204, 6, 1, 0, 0, 2, 1, 8, 214, 255, 238, 243, 222, 230, 223, 225, 226, 255, 150, 0, 0, 49, 217, 255, 189, 22, 18, 37, 36, 41, 22, 75, 228, 250, 83, 0, 1, 44, 203, 245, 227, 226, 226, 224, 223, 249, 255, 251, 46, 0, 23, 231, 255, 254, 255, 255, 254, 255, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 252, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 254, 255, 255, 255, 255, 241, 33, 0, 1, 0, 1, 0, 14, 224, 255, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 254, 255, 253, 254, 255, 255, 255, 255, 255, 254, 255, 255, 255, 255, 244, 39, 0, 10, 122, 153, 147, 144, 138, 142, 134, 131, 131, 138, 145, 136, 124, 122, 125, 139, 148, 151, 158, 139, 129, 143, 40, 74, 144, 135, 128, 127, 106, 109, 116, 106, 102, 99, 110, 117, 114, 97, 129, 96, 0, 0, 0, 0, 0, 0, 0, 102, 138, 112, 123, 116, 117, 107, 114, 131, 132, 140, 135, 135, 130, 112, 137, 86, 86, 118, 105, 101, 100, 108, 94, 93, 101, 103, 119, 120, 105, 100, 103, 102, 101, 99, 97, 95, 89, 83, 63, 7, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    // ARRAY OF PIXELS GOES HERE, COMMA + SPACE SEPERATED
    };
    
    void setup() {
    pinMode (0, OUTPUT);
    pinMode (1, OUTPUT);
    pinMode (2, OUTPUT);
    pinMode (3, OUTPUT);
    pinMode (4, OUTPUT);
    pinMode (5, OUTPUT);
    pinMode (6, OUTPUT);
    pinMode (7, OUTPUT); // PORT D
    
    pinMode (8, OUTPUT); // WR PIN (inverted)
    
    
    for (byte k = 0; k < strlen_P(img); k++) {
    
    digitalWrite(8, LOW); // inverted so this puts WR HIGH (to read)
    delay(10);
    
    myChar = pgm_read_byte_near(img + k);
    PORTD = myChar;
    
    digitalWrite(8, HIGH); // inverted so this puts WR LOW (to write)
    delay(10);
    
    }
    }
    void loop() {
    }
    
    

    Success finishing the board and recording Palladio distorted by the board :

     

     

     

    Here is the setup :

    I’m currently using two boards, but soon I’ll have the components to put everything on the board to the left. 

    The techniques I’m using is the one developed in the previous post :

    TO RECORD IN BURSTS: I can now save a short video : 695.45 kHz (This is the slowest I can go and still almost see an image) on the function gen AND’ed with the top 4 frequency divisions of the vertical sync. This makes for a burst of image recording every X number of frames.  I then amplify the output to make it visible on screen (and speed the clock up to 695.48 kHz). 
    TO STOP THE IMAGE JUMPING: If the reset is connected to the inverse of the freq subdivision of the vertical sync signal AND’ed with the address 20, it will play the image in a loop and always place it in the same part of the screen ! 
    EXPERIMENT : 1 bit recording 

    Recording a single bit of an image appears to produce almost the same image quality ! This means that in theory I could record 8 videos at the same time and output video to 8 screens simoultaneously !

     

    EXPERIMENT : Loading an image with Arduino
    Loading the tiny image once was a drop of water in the ocean so I recorded the image again and again until I ran out of space. This is taking a long time with a few 10ms delays in my code. 

     

    Here is the Arduino sending bits (captured after DAC) :

     

    but so far nothing that comes out looking like an image on the other side…

    I also can’t get my VGA to HDMI converter working…

    Here’s an attempt at a grid of raster variations :

    Here’s the final version of the board :

     

    Memory Experiments

     

    https://github.com/merlinmarrs/Video-Memory

    This project started with an ambitious board combining ADC, DAC and SRAM. 

     

    There were too many issues so I broke the board down into two parts: a memory board and a ADC/DAC board. This allowed me to isolate things and proceed in a step by step way.

    I discovered that the memory needed a WR signal inbetween clock address refreshing, and for the second board that my op amp choice was inappropriate and needed to work around it (by using the DAC only as an R2R ladder and skipping the op-amp for the ADC input). 

     

    During assembly I found that several 0 ohm jumpers were causing shorts. I also tore out the 8 pin header but applying too much force accidentally. Otherwise the switch system was very effective to test my understanding of the memory chip operation. It can essentially record a series of button manipulations for about 1.5 minutes.  

    Here is my first successful “recording” of a sine wave through the ADC and into SRAM and play back from SRAM through the DAC :

    BOARD ERRATA:

    -need last bit of address counter (cuts memory in half !)

    -more jumpers should be broken out for testing (like alternative op amp for input, clk for various chips, etc.)

    -leds burn out when activated and output plugged into 5V at the same time…

    -GND and 5V switched on the two boards 🙁

    -Wrong op amp spec’d. The ADC1175 suggests the LMH6702MF and a choke between power supplies. 

    -caps on all ICs

    -the LEDs I set up on the microchip are plugged into ADC…

    -Add enable header on microchip board

    -power LED on the ADC board

    -add a MSB and LSB next to LEDs on memory board **

    I calculated how much I could store in the 4K of the SRAM I am currently using, and it would be a single line of a 600×800 screen at 40Mhz pixel frequency…

    So what can I do with this ? I could record 4,000 pixels of a static image (i.e. lower the resolution of the image to 100×400 for instance) and then play it back. This would require me to control the sampling of the ADC with the CLK pin of the ADC1175 for every X pixels, somehow synchronized with the VGA in signal (use timing signals of an incoming VGA signal set), or to generate a custom VGA output signal with different timing using the VGAX library. 

    Some important references : 

    nootropicdesign.com/video-experimenter/build

    gieskes.nl/visual-equipment/?file=gvs1

    I am looking into what I could draw on screen with only 4K memory at a 20MHz clock.

    EEPROM and SD cards are also interesting before reaching the holy grail of magnetic recording media of course…

    I have the AT28C256F-15TU EEPROM chip which has 256K x 8 bits (enough to at least store an entire 600×800 static screen) and the ADV7125STZ50 8 bit triple HS video DAC. 

    https://www.mouser.fr/datasheet/2/268/doc0006-1108095.pdf

    https://www.mouser.fr/datasheet/2/609/ADV7125-1503638.pdf

    I’d like to have a standalone arduino VGAX based board (https://github.com/smaffer/vgax) which can output 120×60 pixels and reads from internal SRAM and can record and playback. With 256K I could record a static image on screen at a higher resolution or a low resolution short video.

    I have already made an SD card image saving board: 

    Just realized what I’m trying to do is called a frame grabber and it’s a massive PCB :

    https://en.wikipedia.org/wiki/Frame_grabber#:~:text=A%20frame%20grabber%20is%20an,or%20a%20digital%20video%20stream.&text=Historically%2C%20frame%20grabber%20expansion%20cards,to%20interface%20cameras%20to%20PCs.

     

    *********************************************************************************

    I have designed a similar memory board but using a 256K EEPROM chip in place of the  SRAM and with VGA connectors to begin testing images. (There do appear to be larger SRAMs, going up to 16MB. There are obviously large flash memories in SD format going into the GBs which may also be interesting to play with).

    -Added out VGA to work with VGAX library (not sure if need a second microchip to handle just the memory stuff?)

    -Added a 16MHz resonator

    -With two 8 bit counters to have the full 13 bits to control this time.

    -EEPROM will keep a recording after power down.

    -can control buffers with microchip

    Just learned that EEPROM is probably the slowest…

    Just a thought but I could save control signals for the 0c74 instead of saving actual pixel information…

    *************

    First test (WORKING):

    int switchState = 0;

    pinMode(6, OUTPUT); // CLK LED (*)
    pinMode(7, OUTPUT); // CLK

    pinMode(10, OUTPUT); // WR/RD SIGNAL TO SRAM
    pinMode(A3, INPUT); // WR/RD SWITCH (WR HIGH, READ LOW)

    pinMode(8, OUTPUT); // WR LED
    }

    // the loop function runs over and over again forever
    void loop() {

    switchState = digitalRead(A3);

    // check if the pushbutton is pressed.
    // if it is, the buttonState is HIGH:
    if (switchState == LOW) {
    // WR selected on switch so turn WR LED on and send a LOW to SRAM

    digitalWrite(8, HIGH);
    //
    digitalWrite(10, HIGH);
    digitalWrite(6, HIGH); // 
    digitalWrite(7, HIGH); // 
    delay(10);
    digitalWrite(10, LOW);
    digitalWrite(6, HIGH); // 
    digitalWrite(7, HIGH); // 
    delay(10); // 
    digitalWrite(10, LOW);
    digitalWrite(6, LOW); 
    digitalWrite(7, LOW); 
    delay(10); // 
    digitalWrite(10, HIGH);
    digitalWrite(6, LOW); // 
    digitalWrite(7, LOW); // 
    delay(10); // 

    }
    else {
    // READ selected on switch so turn WR LED OFF on and send a HIGH to SRAM
    digitalWrite(10, HIGH); // STAYS HIGH THE WHOLE TIME
    digitalWrite(8, LOW);
    //
    digitalWrite(6, HIGH); // 
    digitalWrite(7, HIGH); //
    delay(20); // 
    digitalWrite(6, LOW); // 
    digitalWrite(7, LOW); // 
    delay(20); //

    }

    }

    This is what it produces:

    Second test (WORKING): 

    int switchState = 0;

    // the setup function runs once when you press reset or power the board
    void setup() {
    // initialize digital pin 13 as an output.
    pinMode(6, OUTPUT); // CLK LED (*)
    pinMode(7, OUTPUT); // CLK

    pinMode(10, OUTPUT); // WR/RD SIGNAL TO SRAM
    pinMode(A3, INPUT); // WR/RD SWITCH (WR HIGH, READ LOW)

    pinMode(8, OUTPUT); // WR LED
    }

    // the loop function runs over and over again forever
    void loop() {

    switchState = digitalRead(A3);

    // check if the pushbutton is pressed.
    // if it is, the buttonState is HIGH:
    if (switchState == LOW) {
    // WR selected on switch so turn WR LED on and send a LOW to SRAM

    digitalWrite(8, HIGH);
    //
    digitalWrite(10, HIGH);
    digitalWrite(6, HIGH); // turn the LED on (HIGH is the voltage level)
    digitalWrite(7, HIGH); // turn the LED on (HIGH is the voltage level)
    delayMicroseconds(1);
    digitalWrite(10, LOW);
    digitalWrite(6, HIGH); // turn the LED on (HIGH is the voltage level)
    digitalWrite(7, HIGH); // turn the LED on (HIGH is the voltage level)
    delayMicroseconds(1); // wait for a second
    digitalWrite(10, LOW);
    digitalWrite(6, LOW); // turn the LED on (HIGH is the voltage level)
    digitalWrite(7, LOW); // turn the LED on (HIGH is the voltage level)
    delayMicroseconds(1); // wait for a second
    digitalWrite(10, HIGH);
    digitalWrite(6, LOW); // turn the LED on (HIGH is the voltage level)
    digitalWrite(7, LOW); // turn the LED on (HIGH is the voltage level)
    delayMicroseconds(1); // wait for a second
    // wait for a second
    }
    else {
    // READ selected on switch so turn WR LED OFF on and send a HIGH to SRAM
    digitalWrite(10, HIGH); // STAYS HIGH THE WHOLE TIME
    digitalWrite(8, LOW);
    //
    digitalWrite(6, HIGH); // turn the LED on (HIGH is the voltage level)
    digitalWrite(7, HIGH); // turn the LED on (HIGH is the voltage level)
    delayMicroseconds(1); // wait for a second
    digitalWrite(6, LOW); // turn the LED on (HIGH is the voltage level)
    digitalWrite(7, LOW); // turn the LED on (HIGH is the voltage level)
    delayMicroseconds(1); // wait for a second

    }

    }

    And here are some shots of what three different speeds (10ms, 10microseconds, 1 microseconds) as delay in the Arduino code :

     

    ***********************************************************************

    Third test (NOT WORKING):

    I recorded a sine wave at 100KHz (with WR activated on the microchip board) with the ADC being clocked at 10KHz. I made sure I had the ADC selected with the right buffers and then sent this 8 bit sequence to the memory where I recorded it with a new Arduino code:

    void setup()
    {
    DDRD = B11111111; // set PORTD (digital 7~0) to outputs
    DDRB = B11111111; // set PORTB (digital 7~0) to outputs
    }

    void loop()
    {
    if((PINC & 0b00001000)==0)
    {
    PORTD = B11111111; // set PORTD pins (digital 7~0) high
    PORTB = B00000000; // set PORTD pins (digital 7~0) low
    PORTD = B00000000; // set PORTD pins (digital 7~0) low
    PORTB = B11111111; // set PORTD pins (digital 7~0) high

    }
    else
    {
    PORTB = B00000100; // WR PULLED HIGH SO TURNED OFF
    PORTD = B11111111; // set PORTD pins (digital 7~0) high
    PORTD = B00000000; // set PORTD pins (digital 7~0) low
    }
    }

    /*
    CLOCK:
    _____ _____
    | ` | | |
    ___| |___| |____

    WR:
    _________ ____________
    ` | |
    |___|

    */

    I then switched to the DAC with the buffers and switched into READ mode on the microchip board.  Now the 8 bit sequence was being translated back into a sine wave. I took this sine wave and amplified it with an audio amp and sent it to the three color channels combined with an arduino running the VGAX pattern code without the colors plugged in and only H and V SYNC.

    I got this on the screen :

    Here is the tentacular and unoptimized setup :

    To make this actually easy to use, I need to:

    -have the microchip control the buffers and the ADC clocking based on the switch state.

    -have the memory and adc on a single board.

    -have a VGAX out setup integrated into the memory board.

    -have an op amp on the ADC board to amplify the output signal !!

    -have a dial change the speed of the playback / sampling of recording.

    *******************************************

    I added an external crystal and set the AVR dude Fuses to : Ext. Crystal Osc.8.0 – ___MHz 16K CK/14 CK + 65 ms. 

    I added F_CPU 16000000UL ABOVE the #include. 

    Forgot that if you don’t add 0b before a binary number nothing happens with the pins !

    Here is the code that still isn’t working :

    /*
    * eeprom board v.2.c
    *
    * Created: 06/02/2022 09:19:50
    * Author : Jonah
    */

    #include <avr/io.h>

    int main(void)
    {

    DDRC = 0b00000000; // PC3 is the switch for WR (0) or RD(1)

    DDRD = 0b11111111; //PD5 is CLK and PD4 is !OE

    DDRB = 0b11111111; //PB0 is the LED and PB2 is !WE

    while (1)
    {

    /*
    BYTE WRITE: A low pulse on the WE or CE input with CE or WE low (respectively) and OE high initiates a write
    cycle. The address is latched on the falling edge of CE or WE, whichever occurs last. The data is latched by the first
    rising edge of CE or WE. Once a byte write is started, it will automatically time itself to completion. Once a
    programming operation is initiated and for the duration of tWC, a read operation will effectively be a polling operation.
    */

    if((PINC & 0b00001000)==0) // WRITE MODE: (CE -> TIED LO); !WE -> TOGGLE ; !OE -> HI ; CLK -> TOGGLE
    {
    PORTD = 0b00010000; // !OE -> HI ; CLK -> LO
    PORTB = 0b00000000; // !WE -> LO
    PORTB = 0b00000001; // !WE -> LO (to make the pulse width at least 100ns)
    PORTB = 0b00000101; // !WE -> HI
    PORTD = 0b00110000; // !OE -> HI ; CLK -> HI (next address must come a max of 50 ns following !WE going HI?)

    }

    /*
    READ: The AT28C256 is accessed like a Static RAM. When CE and OE are low and WE is high, the data stored at
    the memory location determined by the address pins is asserted on the outputs.
    The outputs are put in the highimpedance state when either CE or OE is high. This dual-line control offers designers flexibility in preventing bus
    contention in their system.

    */

    else // READ MODE : (CE -> TIED LO); !WE -> HI ; !OE -> (TOGGLE ? OR JUST LO?) ; CLK -> TOGGLE
    {
    PORTB = 0b00000101; // !WE -> HI
    PORTD = 0b00100000; // !OE -> LO ; CLK -> HI
    PORTD = 0b00000000; // !OE -> LO ; CLK -> LO
    }
    }
    }

    **********************************************************************************

    One question I have is: does the EEPROM require OE to go on and off when reading unlike the SRAM I worked with in the previous board ?

    Another question is, how long does the EEPROM need to write a byte ? It talks about “access times of 150ns”…?

    Is it OK I have CE tied low the whole time ?

    As a next step I will try doing all of this but very slowly to see if that works. 

    *EDIT : tried slowing everything down and I’m still not able to load anything into the memory :(. I just get 5V and little pops of ground after writing ground into every cell of the memory. This is after changing !OE toggle and always ON also. 

    I did get the VGAX code running though so at least that works. 

    ERRATA:

    -the labeling of WR and RD are confusing, when the switch is to the RD side it is in WR mode etc. 

    -the VGA parts are COMPLETELY wrong. 

    -I need to order 16MHz of this format (I took one from a dead Arduino board). 

    -the text is too small and came off during cleaning.

     

    TROUBLESHOOTING AT28C256 EEPROM:

    -Need to wait a second before doing and writing or reading,

    -Need to either wait the maximum time for the EEPROM to write (Write Cycle Time Max AT28C256 = 10ms) or poll 1/0 7 to wait until it matches what you sent it before starting another write cycle.

    -The device may be locked (even though the devices should ship unlocked) :(. The unlock sequence is :

    LOAD DATA AA
    TO
    ADDRESS 5555

    LOAD DATA 55
    TO
    ADDRESS 2AAA

    LOAD DATA 80
    TO
    ADDRESS 5555

    LOAD DATA AA
    TO
    ADDRESS 5555

     

    LOAD DATA 55
    TO
    ADDRESS 2AAA

    LOAD DATA 20
    TO
    ADDRESS 5555

    LOAD DATA XX
    TO
    ANY ADDRESS(4)

    LOAD LAST BYTE
    TO
    LAST ADDRESS

     

    ************************

    Here are some thoughts I have on the SRAM device :

    Do I want addressed to loop or not ? (Add inverter if want to loop)

      >> Make it optional with a jumper, this expands the possibilities of experimenting.

    Max sample rate I can get from SRAM ? 
    >>Looks to be around 20MHz if the read time is 50ns ?
    What happens if I slow a recorded signal down with a knob, what visual effects produced ?
    >> I need a bunch of recorded stuff and a super fast clock or else I just output bands everyonce and a while.
    Bigger SRAM same brand? need more counters?

      >> Check out this super fast 1Mx8bit SRAM

    61-64WV10248EDBLL-276598.pdf (mouser.fr)

    Two memories ? Feedback from one memory possible ?
    Jumpers to either have vgax doing syncs or input vga.
    Record at slow speed play back at high speed ? Keeps theme of time and computation…
    How have vgax send clock and wr signal for memory circuit while doing vgax timing ? Or have separate clocks (high speed resonator) and sync somehow ? ( Or generate my own sync sign also in logic ?)
    How actually use and function with two vgas ?
    It would be cool to be able to record an image, or parts of a series of images, on an input vga signal and then play them back at different speeds and doubled with the original. This seems really challenging to do accurately but could be cool to stretch an image or sample every line from an animation.

    Also would be cool to be able to output blocky animations based on memory. Could vgax output memory values? Then could compose.

    Could the vgax do a kind of low fi screen capture ? This is a ripoff of gieske though…
    Could this thing be a composition machine, where you slowly switch 8 pin dip switches and take a “photo” of each finished byte ? Then play back at higher speeds?
    I started this board wanting to learn about memory. What have I learned ? Could have button to reset address counters, knob for clock speed, but what other Params?
    Could take memory and output it as pattern by vgax ?
    Do all first with Arduino analog read  ?? Why is this better than Arduino ? What advantage, what has it allowed me to learn ? Faster ? Physicalized memory space ?
    **********
    Retried this code modified slightly from this tutorial : https://scanlines.xyz/t/tutorials-for-generating-video-sync-signals-with-arduino/104

    #define LINE_CYCLES 508
    #define HSYNC_CYLCLES 60
    #define VSYNC_LINES 2
    #define FRAME_LINES 525
    #define PIXEL_FREQ 1

    volatile int linecount;

    void setup(){
    pinMode(7, OUTPUT); // VSync
    pinMode(9, OUTPUT); // HSync
    pinMode(6, OUTPUT); // Pixel frequency

    //inverted fast pwm mode on timer 1
    TCCR1A = _BV(COM1A1) | _BV(COM1A0) | _BV(WGM11);
    TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10);

    ICR1 = LINE_CYCLES; // Overflow at Cycles per line
    OCR1A = HSYNC_CYLCLES; // Compare high after HSync cycles

    //timer 0 in CTC mode
    TCCR0A = _BV(COM0A0) | _BV(WGM01) ; // Toggle pin on each cycle, no CPU clock prescaling/
    TCCR0B = _BV(CS00); // no clock prescaling
    OCR0A = PIXEL_FREQ; // go super fast

    TIMSK1 = _BV(TOIE1); // Enable timer overflow interrupt
    }

    ISR(TIMER1_OVF_vect)
    {

    if (linecount == 0) PORTD = PORTD ^ 0x80; //Toggle the most significant bit of port D.;
    else if (linecount == 2) PORTD = PORTD ^ 0x80; //Toggle the most significant bit of port D.;
    else if (linecount == 3) PORTD = PORTD ^ 0x80; //Toggle the most significant bit of port D.;
    else if (linecount == FRAME_LINES) linecount = 0;
    linecount++;
    }

    void loop(){}

    *******************

    Works well. Also tried generating my own V and H sync with logic and a 4040 counter from this tutorial : https://hackaday.io/project/9782-nes-zapper-video-synth-theremin/log/32271-vga-sync-generation

    It didn’t work for me. The reset of the 4040 didn’t want to be connected to anything but GND, otherwise the whole thing was inoperational. 

    I also messed around again with floppy disk writing. I got the floppy disk motor turning, plugged the index into step, activated the drive select, and connected direction to either 5V or GND. I soldered a connector for the 5 wires froming from the recording magnets. I tried blasting them with a sine wave added to a 10KHz square wave but saw no sign of the signals when playing back the floppy. 

    I have a new plan: Triple SRAM device for copying and pasting a loop of very blocky “video” :

     

    *****************************************************************************************

    Here’s what I learned :

    version 1 :

    I need to make a smd breakout board for chips or order DIP versions so that I can do tests first. This would save a lot of time designing and redesigning boards. The idea for a minimal integrated board was good though. Break more pins out.

    version 2 :

    BOARD A : I need to make a more stable way to solder pin headers to the card so they don’t rip off easily. I should use buffers to protect the LEDs. There are also way too many jumpers between the the counter and SRAM. 

    BOARD B : The op amps don’t work. The DAC doesn’t work as I wired it. I forgot to connect the CLK of the DAC.  

    It’s a mess to connect the two boards, make the right connections. The two boards need to be integrated. 

    version 3 :

    The EEPROM doesn’t work, is it locked ? I also used the wrong VGA pins. 

    version 4 :

    It’s a beautiful board but the DAC was VERY challenging to solder by hand. I think the level of complexity and ambition of the board was a little bit too high for this production method. I think I should head back to a board that is easy to assemble, easy to test and understand. 

    version 5: 

    The idea : using buffers I can have LEDs display what is in the memory while also outputing analog output. There are fewer jumpers than in earlier versions. I am planning to use the inverter to control the SRAM WR which appears to be possible based on the datasheet. Simplified DAC with R2 ladder, I can control A12 with a switch and have an A11 LED now. I got rid of the VGA functionality – this makes things simpler. I chose switches over shunts to make connections.

    I want to make 3 of these boards, ABC, so that they can each record in two 4K memories, and then do cool logic transformations and save the results too. Connecting the ADC to the SRAM inputs requires 8 jumpers, and I’ve done away with 8 pin dip switches. To manually set data you connect the jumpers to the spare + and – headers. 

    I would like the decisions to be guided by how I could practically use this device to “record” 8 bits of data / an analog signal for a given period of time (based on the clock speed) and then play it back (while modifying the clock speed manually, and overwriting portions of the memory, possibly from another pair of memory boards) to display on a screen (with another board handling the VGA signals and optionally sharing its clock with this board to keep things in sync). I want to move to something that produces output ASAP, and away from endlessly redesigning these boards looking for something perfect. (If this works I want to make 3, then a specialized VGA board too).

    I’ve added reverse polarity protection, a STEP button, which is hardware debounced, to manually advance one address at a time. I kept the op-amp modular so that it could be used to amplify analog in or out. I switched out the edge accessible thumb pots for normal pots, so this thing is no longer really stackable.

    Not sure exactly how they stack (but many things accessible on the edges) though and not sure if I should have a battery included or not so that it remembers what it recorded…

    Version 5 UPDATE :

    Thoughts on possible  version 6 additions :

    Backup battery to record option ?

    8pin dip switch with header somewhere on board?
    Question I have to resolve with current version :
    What can I record (in analog and in digital) and for how long ?
    What does it look like on the screen with and without a generated pixel clock to do the sync?
    Going at pixel frequency speed I can draw different repeating textures on the screen when I record very slowly and then speed it up :

    Patterns are repeating, it’s like a texture. Sending a non-repeating signal, like the arbitrary function signal which leaves a non-repeating pattern on screen, seems like a cool thing to try. Another option is to have a single block of memory but to jump around in how you address it somehow ?
    How fast and how slow can it go ?
    With a 10K resistor and a 0.1uF for the CD4046 I have a max sampling speed of 1Khz that is barely enough to represent a 100 Hz sine wave.
    Apparently this max is called the Nyquist frequency :

    Nyquist Frequency=Fmax = SampleRate/2

    The SRAM module IS61C64AL can run up to 20MHz according to the datasheet (https://www.issi.com/WW/pdf/61C64AL.pdf)

    When I feed it the 3MHz pixel frequency from the modified VGAX it can record a 1.5MHz sine wave and play it back ! The problem when it is going slow is that it just outputs bands every now and then. It could act as a memory of a control signals which would change parameters in a circuit which generates more interesting output. (It could even control an analog computer like this https://the-analog-thing.org/ ).
    The other option would be to have a super fast clock that is connected to the V and H sync, one that I can divide and use to control recording of a large SRAM memory.
    Would second mem board be cool ?
    Not unless I get a bigger SRAM I think and daisy chain a series of 8 bit counters :
    https://www.mouser.fr/datasheet/2/198/62-65WV10248EALL-BLL-462620.pdf
    VERSION 5 UPDATE :

    Here are the issues :
    -I added a reset for the counters to go back to address 0. It takes a while to kick in though – I think because it resets the counter but not the 8 bit storage register ?
    -I added an LED to show when ADD21 is activated.
    -the 74F541 does not like 5V. I replaced it with an 74HCT254 and pulled the DIR pin HIGH.
    -the ADC1175 operates at 4.5-5.5V ! (I will test it’s max speed – supposedly 20MHz by powering it with 5V)
    -One pin connection missing on 8 pin dip switch
    -The phase shifter sucks and the amp doesn’t currently work.
    -CS should be held down and not toggled with WE.
    -RCO for cascading counters was not working at higher frequencies – I switched to sending the last Qout of each counter to the CLK in. 
    -I don’t have a way of taking 5V analog signals and stepping them down to 3.3V.
    -The memory should default to floating (instead of ground?) so that I can re-record over previous stuff. (Currently when I re-record, if a pin is not set it defaults to being black and just erasing everything).
    -need a 3.3V to 5V booster if you want to interface with another 5V memory. It would be nice to have an in-line 8 plug so I don’t need to plug in each wire one by one…
    -I can’t currently take VGA in at 400×800 from a computer (amplified) and saved it into the memory (it’s pixel clock is at 40MHz, I set the function generator to 4MHz). But I can record an image imperfectly from the VGAX color out at around 1.3038210 MHz.
    -I need to amplify at the input and the output (and ideally be able to offset them both and up and down – especially to hit the middly of the CMOS threshold between low and hi if I want to record in image in b&w with a single bit). The next version of the board would have two amps.
    -When I play back a recording, each time the memory restarts at zero, the frame of the video moves. (To solve this I need the freq divider, AND chip and inverter).
    -Pin 11 of the ADC should be connected to 3.3V while pin 13 should be connected to 5V.
    Possible improvements:
    -a 5V power in with 3.3V LDO so I can power things with both ?
    -if I want to upload something to memory, and then change to outputing, I have to disconnect all the wires that were connected to it previously. I should have a 74HCT254 Bus transciever that can change directions to disconnect a set of 8 wires from the memory. ALTERNATE OPTION : Just keep everything plugged in and turn off ADC?
    -Maybe an LED that tells me I’m recording (easy not to notice that it’s not in recording mode and then connect it to outputs that are pulling it up and down). 
    -Would be cool to be able to select which chunk of memory I’m replaying over with two knobs that control the start point and end point. (This could be two comparators connected to two pots ?)
    Developements:
    I can load values into the memory from Arduino’s PRGMEM like so:
    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    /* TO LOAD DATA INTO THE MEMORY */

    #include <avr/pgmspace.h>

    byte myByte;

    #define IMG_PIRATE_BWIDTH 30
    #define IMG_PIRATE_HEIGHT 60
    //data size=900 bytes
    const byte img_pirate_data[IMG_PIRATE_HEIGHT*IMG_PIRATE_BWIDTH] PROGMEM={
    0, 7,255,192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 63,252, 6, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,192, 0, 0, 0, 0, 0,
    2,255,112, 96,129, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    15,222, 2, 4, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
    255,240, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
    252, 65,144, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0,
    248, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,144, 0, 0, 0, 0, 0, 0,
    65,132, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0,
    0, 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0,
    36,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0,
    65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0,
    8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0,
    16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,192, 0, 0, 0, 0, 0, 0, 0, 0,
    32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,128,130,168,160, 0, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34,138, 42, 32, 0,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    16, 0, 0, 0, 0, 0, 0, 0, 0, 34, 34, 34,136, 32,130, 0, 0, 32, 0, 0, 0, 1, 69, 64, 80, 0, 20, 5, 4, 0,
    32, 0, 0, 0, 0, 0, 0, 8,170,160, 0, 0,170,170, 40, 42,170,136, 0, 0, 0, 0, 64, 17, 4, 68, 64, 16, 68, 0,
    0, 0, 0, 0, 0, 0, 0,162, 10, 2,170,170,170,170,168, 32, 0, 34, 0, 0, 0, 0, 65, 65, 4, 16, 84, 16, 68, 0,
    64, 0, 0, 0, 0, 0, 10,130,171,239,255,238,170,170,160,162,170,162, 0, 0, 0, 0, 68, 1, 4, 16, 65, 16, 64, 0,
    36, 0, 0, 0, 0, 0, 8, 42,187,250,170,170,187,238,250, 0, 0, 34, 0, 0, 0, 0, 69, 80, 80, 68, 20, 5, 4, 0,
    0, 0, 0, 0, 0, 0, 34,170,255,234,170,170,171,187,178, 60, 0,170,160, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    152, 0, 0, 0, 0, 0, 0,171,254,170, 0, 2,186,255,248, 61, 3, 2, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1,196, 0, 0, 0, 0, 10,187,254,168,112, 4,171,191,248, 54, 0, 40,136, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 8,198, 96, 0, 0, 42,191,250,163,240, 14,174,255,254,136,170,138, 34,128, 1,128, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0,139,191,250,168, 53, 26,171,255,252,138, 34,186,162, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 42,251,250,170,170,170,174,191,254, 34,187,174,232,128, 0, 64, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 2,170,174,255,186,170,170,187,255,255, 34,234,251,170,128, 0,128, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 1, 0, 0,138,187,187,171,170,238,187,191,255,138,175,255,238, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 10,239,255,186,186,170,238,239,255,224,235,255,250, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 46,175,255,255,238,186,190,255,255,248,171,255,250,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0,170,191,255,255,250,171,187,239,255,254, 42,255,238, 32, 0,144, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 42,238,255,255,251,170,174,187,255,254,174,190,234,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 1,128, 0, 0,174,187,255,255,254,235,171,255,255,254, 10,171,170,128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 32, 0, 0, 0,138,174,255,255,255,186,163,255,255,255,162,186,186,128, 0, 4, 36, 0, 0, 0, 0, 0, 0, 0,
    0, 4, 0, 0, 0, 0, 43,187,239,255,254,170,234,170,174,234, 34, 42,168, 0, 0, 8, 2, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 10,174,186,255,251,171,168,128, 10,128, 2, 34,226, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0,
    0, 0, 64, 0, 0, 0, 2,171,239,187,254,234,170, 40, 0, 0, 0, 40, 32, 0, 0, 2,170,168, 0, 0, 0, 0, 0, 0,
    0, 0, 40, 0, 8, 0, 0, 42,190,239,190,186,128, 0, 0, 0, 0, 0,160, 0, 0, 64,170,170,160, 0, 0, 0, 0, 0,
    0, 2,160, 0, 60, 0, 0, 42,171,190,250,168, 0, 0, 10,170,168, 0, 0, 0, 0,128, 16, 10,168, 0, 0, 0, 0, 0,
    0, 42,128, 2,240, 0, 0,130,234,186,170,160, 0,170,170,170,174,128, 0, 0, 0, 6, 0,170,170,128, 0, 0, 0, 0,
    0,170,128, 47, 0, 0, 0, 10, 42,170,170,128, 42,170,175,255,250, 32, 0, 0, 1, 0, 42,170,170,168, 0, 0, 0, 0,
    10,170, 64, 40, 48, 0, 0, 0, 40,162,170, 0,171,255,255,255,234,136, 0, 0, 2, 0, 2,170,170,170, 0, 0, 0, 0,
    170,170, 0,160,176, 0, 0, 0, 0,130,168, 2,191,186,175,250,170, 32, 0, 0, 1, 56, 0,170,170,170, 0, 0, 0, 0,
    170,170,130,130, 64, 0, 0, 0, 2, 8,168, 10,239,255,234,170,170,136, 0, 0, 16, 60,128,170,170,170, 0, 0, 0, 0,
    170,170,128,138, 0, 60, 0, 0, 0, 8, 32, 2,255,255,255,234,186,128, 0, 0, 0, 7,232, 42,170,170,128, 0, 0, 0,
    170,170,160,168, 0,252, 0, 0, 0, 0, 0, 10,175,255,255,251,170,128, 0, 0, 0, 0, 26, 42,170,170,128, 0, 0, 0,
    170,170,168, 8, 0,240, 32, 0, 0, 0, 0, 8,190,187,235,238,168, 32, 0, 0, 0, 0, 4,170,170,170,160, 0, 0, 0,
    170,170,160,170, 0,240,192, 0, 0, 0, 0, 0,170,254,238,170,186, 0, 0, 0, 0, 0, 72, 42,170,170,168, 0, 0, 0,
    170,168, 0,170,128, 2, 64, 0, 0, 0, 0, 0, 2,171,170, 58,160, 0, 0, 0, 0, 0, 2, 10,170,170,170,128, 0, 0,
    170,170, 42,170,168, 3, 0, 0, 0, 0, 0, 0, 2, 10, 42, 8, 0, 0, 0, 0, 0, 0, 1, 42,170,170,170,168,128, 0,
    170,170,170,170,169, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 18, 42,170,170,170,170,168, 0,
    170,170,170,170,168, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54,128, 0, 42,170,170,170,170,170, 0,
    170,170,170,168, 36, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,188, 96, 15,170,170,170,170,170,170, 0,
    170,170,170,170, 0,130, 14, 96, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 95, 0, 63,234,170,170,170,170,170,128,
    170,170,170,170,170,170,143,255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0,249,240, 63,234,170,170,170,170,170,128,
    170,170,170,170,170,170,144, 63,240, 0, 0, 0, 0, 65, 0, 0, 0, 15,192, 0, 63,144, 63,170,170,170,170,170,170,160,
    170,170,170,170,170,170,175,239,240, 0, 1, 0, 0, 2, 24, 0, 0, 15,252, 0, 7,228, 15,218,170,170,170,170,170,168,
    170,170,170,170,170,170,168,255,240, 48, 64, 0, 13,129, 1, 0, 0, 3,255, 0, 0,114, 15,250,170,170,170,170,170,170,
    170,170,170,170,170,170,170, 62,192,188, 0, 0, 63,126,192, 36, 0, 2,127,208, 0,185,191,250,170,170,170,170,170,170,
    };

    void setup() {

    Serial.begin(9600);

    pinMode(7, OUTPUT); // I/O 8
    pinMode(6, OUTPUT);
    pinMode(5, OUTPUT);
    pinMode(4, OUTPUT);
    pinMode(3, OUTPUT);
    pinMode(2, OUTPUT);
    pinMode(1, OUTPUT);
    pinMode(0, OUTPUT); // I/O 0

    pinMode(8, OUTPUT); // CLK

    for (byte k = 0; k < 200; k++) {
    myByte = pgm_read_byte_near(img_pirate_data + k);
    Serial.print(myByte);
    digitalWrite(8, LOW); //CLK LOW
    delay(1);
    PORTD = myByte;
    digitalWrite(8, HIGH); //CLK HIGH
    delay(1);
    }
    for (byte k = 0; k < 200; k++) {
    myByte = pgm_read_byte_near(img_pirate_data + 200+ k);
    Serial.print(myByte);
    digitalWrite(8, LOW); //CLK LOW
    delay(1);
    PORTD = myByte;
    digitalWrite(8, HIGH); //CLK HIGH
    delay(1);
    }
    for (byte k = 0; k < 200; k++) {
    myByte = pgm_read_byte_near(img_pirate_data + 200+ k);
    Serial.print(myByte);
    digitalWrite(8, LOW); //CLK LOW
    delay(1);
    PORTD = myByte;
    digitalWrite(8, HIGH); //CLK HIGH
    delay(1);
    }
    for (byte k = 0; k < 200; k++) {
    myByte = pgm_read_byte_near(img_pirate_data + 200+ k);
    Serial.print(myByte);
    digitalWrite(8, LOW); //CLK LOW
    delay(1);
    PORTD = myByte;
    digitalWrite(8, HIGH); //CLK HIGH
    delay(1);
    }

    Serial.print(“FINISHED”);
    }

    void loop() {

    }

     

    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    I have a different Arduino to trigger the memory on each pixel and generate the sync signals :
    /* TO TRIGGER MEMORY CLOCK EACH PIXEL AND GEN VGA SYNCS */

    #define LINE_CYCLES 508
    #define HSYNC_CYLCLES 60
    #define VSYNC_LINES 2
    #define FRAME_LINES 525
    #define PIXEL_FREQ 1

    volatile int linecount;

    void setup(){
    pinMode(7, OUTPUT); // VSync
    pinMode(9, OUTPUT); // HSync
    pinMode(6, OUTPUT); // Pixel frequency

    //inverted fast pwm mode on timer 1
    TCCR1A = _BV(COM1A1) | _BV(COM1A0) | _BV(WGM11);
    TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10);

    ICR1 = LINE_CYCLES; // Overflow at Cycles per line
    OCR1A = HSYNC_CYLCLES; // Compare high after HSync cycles

    //timer 0 in CTC mode
    TCCR0A = _BV(COM0A0) | _BV(WGM01) ; // Toggle pin on each cycle, no CPU clock prescaling/
    TCCR0B = _BV(CS00); // no clock prescaling
    OCR0A=PIXEL_FREQ;

    TIMSK1 = _BV(TOIE1); // Enable timer overflow interrupt
    }

    ISR(TIMER1_OVF_vect)
    {

    if (linecount == 0) PORTD = PORTD ^ 0x80; //Toggle the most significant bit of port D.;
    else if (linecount == 2) PORTD = PORTD ^ 0x80; //Toggle the most significant bit of port D.;
    else if (linecount == 3) PORTD = PORTD ^ 0x80; //Toggle the most significant bit of port D.;
    else if (linecount == FRAME_LINES) linecount = 0;
    linecount++;
    }

    void loop(){

    }

    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    UPDATE:
    I finally have a screen I can use to subtract the memory contents with :

    #include <VGAX.h>

    VGAX vga;

    void setup()
    {
    vga.begin();
    vga.clear(11);
    }
    void loop(){for (int y=0; y!=VGAX_HEIGHT; y++) {
    for (int x=0; x!=VGAX_BWIDTH; x++) {
    vga.putpixel(x, y, 3);
    }}}

     

    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    I now can use this with an AND chip and my own function gen frequency and output from the SRAM !

    And here are some of the images I’m getting (using an AND also for the clock coming from the signal gen) :

    And here I am trying to record VGA…
    …from VGAX (120×60):

     

    …and from a computer VGA at 800×600 passing along the sync signals:

    Here was what was onscreen :

    Test card - Wikipedia

    I can reproduce this reliably with :
    -op amp taking memory and amplifying it
    -a pixel clock at 1.007MHz (pixel clock for 640×480 of 25.175 MHz divided by 25)
    But it kinda turns on and off and also jumps around on the screen for some reason.
    I also found out I could use the vertical sync along with a counter (taking as input a 4MHz fucntion generated square wave) and a bunch of AND gates to essentially only record only every X frame and store it in memory. This meant I can save way more frames. Getting the right spacing for the frames will be key to be able to store a short video. 
    UPDATE 1:
    I can now save a short video : 695.45 kHz (This is the slowest I can go and still almost see an image) on the function gen AND’ed with the top 4 frequency divisions of the vertical sync. This makes for a burst of image recording every X number of frames.  I then amplify the output to make it visible on screen (and speed the clock up to 695.48 kHz). One problem is that it looks like everything is in fast forward and it’s barely possible to interpret the images. The other issue is once the video starts again from memory its frame moves with regards to the screen. 
    UPDATE 2:
    If the reset is connected to the inverse of the freq subdivision of the vertical sync signal AND’ed with the address 20, it will play the image in a loop and always place it in the same part of the screen ! 
    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    TESTING MAX ADC SPEED:
    I’m not sure what to make of this as the signal was super noisy but, I can “follow” a sine that is at 50Hz sampling it at 5MHz fine. I’m not sure what conclusions to draw from this…

    VGA controller board :

    -Attiny(?) 
    -several clock speeds to chose from
    -knob to select diff screen resolutions
    -PLL to sync to input VGA? Use an XOR to see delay with signal and then get closer to it ?
    -easy setup to pass input VGA syncs to an output VGA
    -filters to knock out certain frequencies to tune into what I want. 

     

    ANALOG BOARD:

    Based on the Analog Thing functionality (summing, multiplying, comparing, integrating, differentiating, etc.) along with counters to divide the screen by powers of two !

     

    UPDATE:

    Working now on a next version of the 16MB board. The idea is to fix the issues in the 16MB board, add more functionality, and also to move towards a finished board that is more plug-and-play with regards to recording VGA signals and less of a prepared instrument for testing. It’s a test to see if I could make something that behaves like a product.

    One question is if it requires an analog function generator or not, and to what degree the machine is mono-functional or not. (Though I think if it could record video reliably and display to a screen that would already be not bad.)

    Fixes :

    • A21 LED added
    • Top and bottom bias of ADC now controllable with pots
    • op amps on input and output both with variable gain and bias
    • fixed 5V and 3.3V power (ADC and op amps need 5V) with onboard LDO.
    • got rid of phase shifter and 8 pin dip switch
    • CS no longer tied to WR on SRAM.
    • various enables broken out so they can be turned on an off with external control 64KBSRAM
    • counters daisy chained with last address going to clock input of the following counter (no longer using RCO)
    • Replaced 74*541 with 74*245 (so it would have big footprint to let wires pass under but work with 3.3V)
    •  Added VGA in and out connectors and made pass thru mode for input.
    • Added f divider, AND, and NOT gates.

    This board should allow me to test the idea of having a control board chroreograph a sequence of memory operations, and allow me to begin testing the analog board with a stable (not breadborded) video recorder. 

     

    Sunflower Array

     

    The github for this project :

    https://github.com/merlinmarrs/tournesol

    I’ve made the PCB for with the 74AC240 based on this design from http://www.smfr.org/robots/robot_images/dualsolarhead_schematic.png :

    Hoping that it works better than the 540 version with the solar midpoint.

    IT DOES! It is far more responsive and efficient and works with the solar panel! It has a funny quirk where it will first turn the wrong way then correct itself in one direction though…Next i’ll make it on a super small extra compact board and try the other circuit option:

    It’s much more compact that the previous version. The photodiodes could be removed to make it even smaller. It took me around 25 minutes to assemble at a comfotable speed. By far the least efficient element of the assembly is the braided wire which is causing mini shorts :

    There is already some interesting interplay with the two machines side by side…

    3D model of fancy motor version:

    Here’s a version with a tiny gear motor. The motor appears to lock up at low currents however so it doesn’t work super well. It’s also very difficult to attach the motor axle to the bottom platform. 

    With the metal gearmotor it works much better:

    And this version with the panels lower down:

    Here is a tall version:

    Here’s a compact design with a “flipper” arm:

    The idea of pulling the solar panels from the board, exposing the electronics and creating the tilt naturally.

    The little metal cap is actually a nice part of the look of the machine:

    I have made the board thinner so that it fits perfectly over the gear motor:

    Here’s a shot of it looking pretty:

    Llama edition (it’s a heat sink). This photo makes me think I could have fun with shadows like in the 1970 Il Conformista film:

    I see a monocled mustachioed Monopoly man here somehow:

    This idea distributes the things to look at around the machine (one side has solar panels and the gear motor, the other has electronics and the underside gold lettering on the solar panels). When the machine is facing the sun we get to see the electronics. I guess the electronics is also sheltered from the heat of the sun a bit?:

    Here are some feet ideas for the resin printer using small set screws and (in the right model) Pogo pins:

    Here are two versions of the tripod design. One has the electronics as a backpack and hides it from the sun, the robot has two faces. The other has the “face” of the robot face the sun, in one photograph the whole robot is visible.

    Version 1:

    Version 2:

    ****

    Side to side comparisons:

     Another idea for pogo pin feet using the crowned tips:

    ***

    I made the barebones circuit in extra slim also:

    debugging the previous version, it appears that the solar panels are indeed producing the expected voltage and current (2 x 1.67V, 18.4 mA), the voltage trigger and mosfet are working, the capacitor is charging, and the voltage to the motors is spiking. However the motors aren’t so much turning as twitching. The motors appear to be identical to others that are working however. Changing the capacitor from .22F to .15F changed nothing. 

    EDIT:

    I had another stab at this:

    I noticed that the charging and triggering part of the circuit appeared to be working but that the motor was not firing. I assumed then that there was a soldering problem on the 74AC240 pins somewhere. I tested a copy of the same boards from the same batch to see if there were any problems with the etching itself, they all seemed good with no shorts and clean traces. I tested a blank 74AC240 as well and found that the only pins that were internally connected were 9 (Y1) and 10 (GND) – though I’m not sure why this is the case. I took a voltmeter to measure if there were any shorts between the pins on the IC and found that everything was mostly normal. Looking under the microscope it occured to me that the problem might be that the pins of the IC aren’t fully touching the pads below as they appeared to have been soldered quickly. In order to assume myself that everything was indeed well connected I reheated each of the pin connections and retested that I didn’t introduce any shorts. I then switched out the larger motor for a more efficient smaller DC motor. Testing with artificial light I now have normally functionality!

    The second malfunctioning solar head has a different issue: It charges up fine from having no power and spins the motor no problem. But after a few times it stops triggering at hovers around 3.6V…I resoldered the connections and had the same issue. The voltage trigger appears to be triggering despite the voltage staying high. In the end I switched the bigger metal gearmotor for a small vibe motor and it worked just fine. I think I can conclude from this that the circuit I used is not suitable for the metal gear motors but works fine with smaller ones.

    I am now looking into making this circuit even smaller using TSSOP-20 packages of the 74AC240 and maybe 0603 smd components too. I plan to make this double sided and to have the boards made at PCB way after testing a prototype circuit in the lab.

     

    The circuit works fine after I had to resolder some of the IC pins to the pads (they seem to hover just above sometimes despite the soldering) and fixing a short between the two sides of the MOSFET by lifting up the positive side of the SMD cap up.

     

    Testing with a single 3.4V panel and…it turns! I’m going to try to add the light detection now.

    And this is how it could be integrated into the 2DOF design: 

    This is a second option which would involve probably halving the above circuit and making it double sided. 

     

    Another idea is to see how far this minimalism and miniturization can go, for instance with a single solar panel capable of charging up the cap to 3.3V ish. It could be 1DOF or 2DOF. Testing with the power supply with 4,46V @ 5,9mA it works no problem with the small gear motor. We’ll see if that’s the case with the actual solar cell soon.

    Monocrystalline Solar Cell 24.5mW (4,46V Current – Short Circuit (Isc) 5,9mA)

    https://www.digikey.fr/product-detail/en/anysolar-ltd/KXOB25-01X8F-TR/KXOB25-01X8F-DKR-ND/10127250

    KXOB25-01X8F-TR ANYSOLAR Ltd | KXOB25-01X8F-DKR-ND DigiKey Electronics

    Monocrystalline Solar Cell 26.3mW 5.53V:

    https://www.digikey.fr/product-detail/en/anysolar-ltd/KXOB25-02X8F-TR/KXOB25-02X8FDKR-ND/9990483

    KXOB25-02X8F-TR ANYSOLAR Ltd | KXOB25-02X8FDKR-ND DigiKey Electronics

    Here is what it could look like 1DOF:

    …and 2DOF:

    If the solar panels are a bit offset from the boards then the light sensors could be directly on the board and not need to be offset themselves from the board. 

    ****

    I actually have one of these lying around to test the one panel idea (3,4V
    @ 4,4mA): 

    https://www.digikey.fr/product-detail/fr/ixys/KXOB22-01X8/KXOB22-01X8-ND/2754274

    Here it is working! (remember that the “GND” side of the photo bridge actually connects to the ENABLE of the 74HC240)

    some other panel configurations:

    I could have the light sensors on either end. 

    A little higher up…

    Satellite inspired:

    Here’s a quick 3D print:

    Not even sure if adding another DOF will have a big effect, over the course of a day how much will it actually tilt up or down?…

    Dual Solar Tracking Part III

    Another idea is to start with the actual solution (two small servos) and make it look better. It’s sturdy and already balanced. It just needs a hinge and a tilting arm:

    With a makeshift hinge and tilt arm:

    This would only require an Arduino mini pro and some super caps charged by a solar panel through a diode.

    Some other more simple options:

    For a miniature 2DOF.

    A mini 1 DOF.

      The 2 metal gear motor design I was working with early on.

    *****

    Here is a super simple two servo motor controller that recharges supercaps through a diode:

    This works with the code below as a test:

    #include <Servo.h>

    Servo myservo1; // create servo object to control a servo

    Servo myservo2; // create servo object to control a servo

    int pos = 0; // variable to store the servo position
    int threshold = 100;

    void setup()
    {
    myservo1.attach(5); // attaches the servo on pin 9 to the servo object
    myservo2.attach(6); // attaches the servo on pin 9 to the servo object
    }

    void loop()
    {

    if (analogRead(A2)-analogRead(A3)>threshold)
    {
    myservo1.write(90);
    delay(15);
    }

    if (analogRead(A3)-analogRead(A2)>threshold)
    {
    myservo1.write(-90);
    delay(15);
    }

    if (analogRead(A4)-analogRead(A5)>threshold)
    {
    myservo2.write(90);
    }

    if (analogRead(A5)-analogRead(A4)>threshold)
    {
    myservo2.write(-90);
    }
    }

    This is the monster in all its tentacularity:

    ****

    Testing the barebones circuit with the solarbotics white DC gearmotors and the SMD solar engine. It works with only two mini solar cells and the SMD cap as long as the sun is medium strong!

     

    This is exciting as a result (but I just needed the change the motor wire polarity):

    Here’s what the circuit looks like:

    This suddenly stopped working and I did the following things:

    Checked to see if the cap was charging, if the voltage monitor was triggering (and I manually triggered the MOSFET to see if the motor fired), the voltage at the midpoint between the two photodiodes, and if there were any shorts.

    In the end I replaced the zener with a normal SMD diode which I found, replaced the photodiodes with green LEDs because one lead was broken on the photodiode, and then discovered the motor was broken (or at least the blue wire was disconnected on the inside)! It gave me a chance to look inside the tiny gear boxes of the motors though: 

    Here is the, once again, working prototype:

     

    I would like to be able to tune the midpoint between the LEDs. I would also like smd light sensors. 

    Phototransistor Output Voltage Circuit connects the phototransistor and 2 k-ohm resistor in series

    Some options for solar panel and motor assemblies:

    Here’s with SMD LEDs soldered on:

    Not sure why but the thing is only turning clockwise…

    I tried the following things:

    1. A 10K trimpot (with each photodiode into each side of the resistor and the variable pin going to the logic chip). The trim pot at either extreme does indeed make the circuit turn in the opposite direction. However, in the middle it stops either side from firing.
    2. Replacing the photodiodes with Silicon PIN Photodiode BP34s, green LEDs 5mm, Green SMD LEDS, and LDRs.
    3. changing the ground of the photodiode pair to the ground of the capacitor instead of the ground connected to the floating connected to the MOSfet.

    Just found this image here (http://solarbotics.net/library/circuits/bot_popper_240.html) which seems to imply I could use phototransistors also:

    Looking at other Smart Head circuits, it looks like the + side of the photodiode pair is connected directly to the Vcc but that the negative side is connected to the “local” ground, not the negative of the capacitor. However, there are also counter examples…

    I tried just setting up the dual photodiode circuit on a breadboard. Two photodiodes , two LDRs etc. They each move from a midway value up or down depending on which device is in the dark. However, they don’t always have 1/2V as a midpoint, which appears to be the important threshold point for the oscillator. **EDIT** I think what they meant was half of VCC not 0.5V. I could try to find the exact threshold voltage that is the balance point with the power supply?

    2.25V for my desktop breadboard version of the circuit while supplying 4V for the solar panel. 2.85V was the threshold with solar panels at 5V. It also has a dead zone where neither motor will fire if it is perfectly in the middle. 

    For the soldered version the threshold is around 1.3-1.4V when being fed 4V as solar panel. 

    At 3.5V solar panel supply, I have a lower threshold bound of 1.25V and a higher bound of 1.4V. In the deadzone neither direction turns. 

    At 3V funny things happen. It will only turn one direction unless I suddenly make the input 0V. This might explain why my circuit is behaving strangely! I am using a 2.92V voltage supervisor so I don’t think my current circuit is ever going to work. 

    I should replace it with a higher voltage threshold like this one perhaps: https://www.mouser.fr/ProductDetail/968-ISL88001IH46ZT7A 

    In the meantime I can use a voltage divider like I did for the 1381. 

    Here’s the scope output attached to one lead of the motor. The fat, fuzzy part is when the motor is not turning and the threshold is reached. Either side it sends between 1.5-2V to the motor turning one way or the other.

    Setting up my own little trim pot between the LDRs I was able to tune them to the correct voltage threshold and everything works well on a breadboard at least.

    Here is the 74AC240 datasheet: 

    Checked out the 74AC240 datasheet, for 3.5V the threshold should be between 0.9V-2.1V.

    ****

    Version 2 of the board has trimpots for the voltage trigger and the light sensors (which are now SMD and on either side of the board):

    Here are the parts laid out with the new board:

    Post-soldering. The size of the board versus two small solar cells:

    I had to put electric tape under the trim pots because contacts were exposed underneath…  The full assembly:

    ****

    Found this online here (http://www.smfr.org/robots/robot_images/dualsolarhead_schematic.png): 

    It uses the solar panels as the light sensors! It also lays things out in an easy to understand way (the midpoint is the boundary between what the inverter sees as HIGH or LOW. Once the solar engine has enough power this decision of HIGH vs. LOW then powers the motor through six remaining gates – presumably to increase the current as each pin seems to be limited to 75mA according to the datasheet above?).

    ***

    Testing V.2:

    I can get 3.5+ volts (4V outside in full sunlight even) with the current setup of two solar cells + little cap!

    BUT…When I short the voltage supervisor 5K trim pot the motor fires, but even in its least resistance position the supervisor is not triggering…It is also only doing mini movements, not full shots. I removed the trim pot and now it behaves normally. I don’t understand why the trim pot doesn’t work when it was flawless with the benchtop power supply…

    With a 1M trimpot the variable voltage trigger does work just as expected, however! I moved it up to 3.5V ish.

    The 5K trim pot for fine tuning the light sensors also does not appear to work. Also doesn’t work with a 1M and two green LEDs…

    I tried using the two solar panels as sensors as suggested in the found circuit and it appears to work, there remains the same problem of how to tune the voltage level however if my trim pot solution doesn’t work. 

    ***

    I think I need to order 74AC240s (I think the 74LS540s I am using might be slightly different in terms of their HIGH/LOW thresholds) or voltage triggers for 3.5V+. This is a nicely tuned circuit that seems hard to mess with.

    Just a reminder of how much the complexity has been reduced in this project!:

    ***

    I have realized I need to understand the circuit I am working with better in order to tinker with it. 

    First thing, the 74LS540 that I am using has a minimum voltage of 4.5V! It also can only supply 45mA max as an ouput if I understand correctly. However, I also have a 74F244D octal buffer which works as low as 2V. However it is Bipolar and not CMOS technology like the 74AC240 AND more importantly, it has non-inverting outputs. Clearly getting the right logic chip and family is an important element and not a detail for this circuit…

    So, the LDR “photo bridge”. After testing 10 we had lying around I arrived at these average values:

     

    Here’s some R Thevenin calculations (Thanks to Learning the Art of Electronics!) to figure out what size pot I can afford to pull up or push down the midpoint from the LDR divider:

     

    And here’s the current logic circuit in a more understandable format:

    ****

    Did some tests, looks like I need to bring the midpoint DOWN in my circuit:

    Yellow is the cap voltage (3.42V) and green in the midpoint (2V) with equal light on both phototransistors. 

    This scope image shows first both photodiodes in light, then the left (connected to GND) in darkness, and finally the right (connected to VCC) in darkness:

    Without even needing to take any measurements it’s evident that the midpoint is too high. This causes the motors to always turn the same direction when the light intensity is equal between the two phototransistors. I flipped the photo transistors and observed the same effect so I think it’s the circuit not the difference between the phototransistors.  

    This scope image shows me adjusting the phototransistor trim pot. (Fully attenuating on the left, halfway in the middle and then fully open on the right). 

    And here’s testing with the middle threshold covering and uncovering each phototransistor:

    This shows that the 10K trimpot effectively drops the entire midpoint! I can effectively dail in the midpoint to exactly half of VCC now (3.42 Vcap, 1.71V threshold)!:

    Now the machine is not turning in only one direction! But it also might need some resistors for when the two photodiodes are both seeing bring light. I also need to replace the LS540 with an AC240 because I am currently operating outside the maximum minimum voltage of the IC. It would also be nice to use the solar panel as a sensor and thereby reduce the part count (I could still tune the midpoint in the same way once I determine which way the imbalance is – it would also solve the shorting problem in high light). 

    I varied the pot and everything is working as expected. I also added heat shrink to the phototransistors. Here is a video:

    I tried some 2DOF designs but I think this needs to stay MINIMAL and the force of the project, if it comes, will come from the array more than individual complexity. Plus they already seem imbalanced and more likely to malfunction…

    Some tests with the solar panel voltage divider:

    Here’s what it looks like when I change the solar panel midpoint with the 10K trimpot:

    Here is the solar panel midpoint trim pot all the way to one side:

    Here is the solar panel midpoint trim pot all the way to the other side (not sure why it goes all the way to the ground here only):

    Here is me putting one panel in the shade, then the other. The difference is not massive.

    The problem is that now I fall into a large deadzone where no movement happens in the middle. I’m trying to find the right combination of voltage trigger trim level and solar midpoint level but it’s not easy without sunshine…

    ****

    Here’s the cost per unit of this design:

    74AC240: 0,462 €

    0.2F cap: 1,21 €

    solar cell: 3.56 € (1.78 € x 2)

    micro gear motor: 4.25€

    voltage trigger: 0,356 €

    diode + 0.47uF cap: 0,1€

    PCB: ?

    Total: 9.938€ + PCB cost

    ****

    I have now a 1M trimpot on the solar midpoint and have added a 1M between the midpoint and VCC to try to balance things out.

    I think 3×3 is better than 4×4 ? 5×5 would be out of control.

    ****

    Working towards simplifying the dual servo sun seeker. Here is a post for controlling servos without a microcontroller:

    https://www.pololu.com/blog/18/simple-hardware-approach-to-controlling-a-servo

    Could use LDR pair to replace pots inside the servos, based on ideas from Hackaday post shared with me by Paolo Salvagione:

    Light Tracking Robot Relies on LDRs

     

    ***

    Went back to the super simple business card sun shaker and added some feet. I also tested the new 0.2F caps and they work with outdoor light but might be too tough to charge with indoor light (unless it’s actually bright then they work fine). After Paolo Salvagione’s comment about using a smaller motor to rotate the device, it occured to me that I could use the vibe motors in two directions to create movement that follows the sun:

     

    ****

    Ordered this motor: 

    Here is a new design with (human) adjustable tilt. It has more of a “pro” vibe. The motor adds 5 euros to the total cost of the machine bringing it up to 15 euros:

    ****

    Looks like the trick with the light sensing is just to put the photodiodes behind the board so that the shadow cast by the sun creates a clear preference for one side or the other. They can be bent around a little bit to be perfectly tuned but it also adds a bit of idiosyncracy to the ‘bot. So it doesn’t appear that I need a trim pot for this option. I’m not sure how to create the same contrast with the solar panels as putting either in the shade is obviously not a good idea. Pointing them in different directions creates some difference but not a great deal.

    ****

    I’ve redone the circuit for the 74AC240 and make it more compact:

    Here is my next design with the smaller DC gear motor. I’m imagining a soldering a pin to the PBC in order to attach the pivoting arm to it. Otherwise the issue is how to make this attachment without creating a whole frame and bumping into components etc. It has a small M2 bolt to fix the print to the motor and to adjust the angle:

    I’ve made a cleaner video of the first prototype:

    Dual Solar Tracking Part II

    Continuing the project of making a small solar tracking device.

    ****

    Idea to simplify the circuit drastically and make the 3D model a bit more robust and less fragile so it is far easier to assemble and won’t topple over (while hopefully maintaining some elegance…) 

    -Battery-powered (and possibly solar recharging through very simple circuit):

     

    plus Attiny with two steppers only powered directly from output pins (max 40mA and danger of kick back which might be solved with diodes) and no light sensing – just the almanac algorithm for sun following. *

    *(Remember you can test the stepper resistances to know which are pairs!)

    Tried powering a stepper directly with an Atmega using the Stepper library in Arduino with a bunch of different step and speed values – if it turns at all it’s extremely weak…So this doesn’t appear to be an option.

    Tried powering an atmega328 directly to cap and solar panel through diode, in medium sun there is no action. With bright sunlight it manages to power up despite blinking a blue LED every secon. I could try with the sleep timer I recently acquired (https://www.adafruit.com/product/3573). Or maybe a simple sleep code will be enough. This seems like a viable option which would simplify the circuit considerably.

    Another cheap and simple option is the ULN2003, but this requires 5V to function unlike the low power DRV8833 I have. 

    ***

    Tried driving the stepper gearmotor chain drive and it moves very smoothly and almost imperceptably. 

    I dug up some DC DVD raft drives, they are nice mechanisms:

    The black rack was attached to the raft. 

    I tried powering these with Wilf’s SPSH circuit and the bearbones solar head and they were too big a motor to be powered unfortunately. I could still try to increase the 1381 trigger level with a resistor though…

    I’ve redesigned the microchip version of the board to make the wiring to the stepper much easier this time. I’ve also added two caps to smooth out the motor supply. 

    And here is a more robust version of the previous two stepper, this one has two parallel bars, a more robust hinge, and the lower bearing is encased completely for more stability hopefully. I am also getting rid of the lead screw plastic piece and trying to replace that part with a thin metal rod. In general it’s simplified and a bit thicker all around :

    I am using a dremel to clear out the holes before inserting things and this is reducing shattering of the more fragile white resin. 

    The bottom bearing:

    Part of the solar panel hinge:

    Only one of the two stepper drivers worked on this board but I haven’t found the issue yet…I wonder if back reverse polarity I destroyed it by accident or over heated it during soldering. I’m going to replace it with a fresh one and see if that changes anything.

     

    Here’s the assembled machine:

    Here is a look at some of the technical details:

     

    A different panel orientation option: 

    Comparing the two versions (the newer is far more compact and stable but less playful and off-beat/asymmetrical):

    Check out the angle range, it’s better than I expected!

    ERRATA:

    1. The idea of putting a pin accross to act as the lead screw is not working with only one side screwed in. AND the lead screw platform is impossible to insert into position (I had to break it in half and glue it back together once in position). I should definitely not try to go under the lead screw, with the nut that holds the pin, it actually makes contact with other nuts holding the whole linear rail assembly. I think I should go back to integrating the existing plastic lead screw – aesthetically it adds more flavour and asymmetry.
    2. The part that attaches to the panel should be one connected part because this gives more surface to attach to and more rigidity. (X)
    3. There is a volume which enters into the bearing socket that I needed to remove with the dremel. (X)
    4. The three bottom holes for screws are not evenly spread out around the circle. (X)

    POSSIBLE CHANGES:

    1. Tensioner for bottom chain or larger bottom gear?
    2. The top hinge is too symmetrical for my liking but otherwise it’s super stable.
    3. Transparent resin is definitely nicer.
    4. The bottom nut needs a tiny bit more room, but it just works.
    5. The bolts are hitting the bottom stepper gearmotor.

    Here is a new version which solves the errata, but it looks hideous:

    I am considering returning to a one bar setup. I am also considering how I can make one version of this device that will work for the different linear actuating steppers and the different rotational motors (the micro steppers and DC gear motors have the same face plate thankfully). The top and bottom of device are also not connected (so varying heights of linear drives can be accomodated). Should one single design be able to work with belt drive or chain? I think I should now focus on producing a bunch of these.

    Here is how the little plastic parts that act as lead screws work:

     

    There are all kinds of shapes but in the end they all appear to have one main screw location and a bunch of other nibs and slots to help with alignement. I can include a sliding slot for the main screw in the 3D print but I may use a dremel to adapt it to different nib locations. 

    I’ve revisited the version 1 and have made the following changes:

    1. I’ve kept the more robust base from version 2.
    2. I’ve revised the lead screw plastic part holder and made the print compatible with the highest number of these peices and allowed for longer stroke.
    3. I’ve kept the magical setup that allowed for a great variation in the panel angle.
    4. I’ve kept the circular base which is more stable and made a larger base gear so it looks more stable. (The pitch of chain I am using is 0.1227″ https://www.mcmaster.com/miniature-roller-chain-sprockets/pitch~0-1227/)
    5. I adjusted the motor so the bolts are no loner hitting the bottom stepper gearmotor.

     

    ****

    Wire management:

    I like the ribon wires from the CD drives and the mini locking sockets and plan to use them:

    The top option seems sensible.

    Here the bottom motor ribbon is going to be super stretched when the panel is at full extension in angle…

    I like the asymmetry of the second option, it implies that the lead screw and hinge action is taking place on one side and the electrical connections on the other side.

    (I’m just realizing that some of the ribbon cables that come with the stepper linear drive are not very long + the brown/orange doesn’t go super well with the white. Should I replace those cables with white ones so that everything is the right length and homogenous?)

     

    There is also the possibility of folding the ribbon cable…

    I’m trying to find this product (it seems to be called “flexible flat ribbon cable”) but not having luck on Farnell or Mouser (*correction: https://www.mouser.fr/ProductDetail/Wurth-Elektronik/687606050002?qs=qR1qlUC5%2FYSp8nXHAtNchQ%3D%3D) …Here it is on Ebay and Amazon:

    The other option is to harvest wire from the old CD drives I have, the wire lenghts seem to vary from 8-11cm.

    Some solar panel options:

     

    ****

    Next version sucesses:

    orienting parts so that the supports don’t touch faces that will be seen is a good idea, it saved the bottom platform from pockmarks.

    Errata:

    1. The main issue is the lead nuts. They are massive and therefore reduce the stroke considerably. Most have a setup where they push against the leadscrew and twist the sliding cam which is now only fixed to one rod.  I should try to design the nut myself, if the solar panel is in the middle it is hidden in any case. The other option is to find another one in a million lead nut that works like the one in version one where it doesn’t push against the cam / use two bars. (X)
    2. Somehow the ratio of arm lengths is producing a totally different range of angles, mostly in the negative direction! (X)
    3. the layer on top and below of the bearing is too thin and comes out wavy. (X* I did the top visible part but not the bottom).
    4. missing a subtraction around the collar of the bottom stepper motor shaft. (X)

    Possible changes:

    1. all black hardware would be nice. Or perhaps all white?

    ******

    Modeling the lead screw:

    The threads themselves:

    I want it to be possible to adjust this thing so I am planning to use a stack of washers to accomplish this. I am also adding a notch in the purple volume to prevent the green volume from rotating. It should also mean that the green volume can be made to accomodate different threads and the purple volume will still work regardless (i.e. it’s modular).

    The backside leaves space for a nut to fix the green piece in place at the right height.

    I’ve also adjusted the angles to match the version 2 as exactly as possible this time:

    Here is the finished version 3:

    Some quick ideas about how this project could be displayed in an expo:

    1. I can make a bunch of solar critters that react to the sun in different ways (sweeping in circles, following the sun but staying in place, making sound by tapping the ground or playing a song, etc.). This is the kind of ludic, “diversity of nature” bio-inspired option. The robots are indifferent to one another but occupy the same space. I’m not sure how to chose the materials but maintain difference/cohension of the group but presumably I could pick a kind of 3D printing and use the same motors.

     

    2. Make one such critter (like the sun follower) and create an array of them in a given space and watch the group effect of their behaviour. This is kind of obvious but at least it’s abstract and sober, hopefully fitting in my portfolio with my other more abstract/representational work. It would also be easier to mass produce one design than to make a bunch of one-off designs I think.

    And here is the BOM so far:

    And here is the newest build:

    ERRATA:

    1. The lead screw does not work. It is not perfectly aligned with the threaded rod and the system for holding it tightly in place is not working. I think I need to put the lead screw on the bottom side of the threaded rod and have a tensioning mechanism on the front (accessible) side.
    2. The angles are still wrong. If I make the top arm (that is glued to the solar panel) shorter I think it will improve.

    I’ve put the lead screw on the back of the threaded rod and inserted alignment rods and increased the borders to hold the top piece in place:

    ****

    The solar panel angles are fixed! With two of the threaded nut sides making a sandwich it does actually work as a lead screw nut (even though it really doesn’t look nice) !

    ***

    Thoughts from artist Paolo Salvagione:

    1. Make a power budget (what does everything i.e. steppers, microchips, drivers use when not on, when on)
    2. Run motors 24/7 for weeks before to test that nothing falls apart.
    3. Replace bolt hinges with flanges or miniature bearings from McMaster Carr. (The smallest available at a reasonable price is 5mm OD no flange).
    4. Try pulling up everything to the top beneath the board and alternatively pushing everything else to the ground to create a sunflower.
    5. Think about the center of balance of the machine and how you can place it directly over the pivot point (or move it there with weights).
    6. What kind of choreography would I like to see here.
    7. Alibaba has super inexpensive solar panels that look great.
    8. Could the array relate to different light sources which exist in a kind of solar system around the plinth.
    9. How can visitors experience this piece at different distances (“layers” of experience)?
    10. Medium-runs of a finished design are easier than making a ton of one offs or mass producing.
    11. It’s possible to order flexible PCBs from PCB Way.

    ****

    Some thoughts on the layers possible:

    I have found a few 10mm OD bearings and will redesign the arm portion with these:

    I’m not totally satisfied with the bearings in the design (McMaster has perfect 5mm bearings that are reasonably priced but they don’t ship out of the U.S.).

    ****

    Calculating the balance point with help of this site: https://www.school-for-champions.com/science/gravity_center.htm#.X2B-cFUzaUk

    Calculating CG of weights 

    CG = (aM + bN + cP)/(M + N + P)

    Seems like I should try to keep the solar panel light in general (under 12 grams?), but that I have the option of adding some weight above the stepper in the rear. In the other axis I can shift the solar panel a bit to the side to compensate for the weight of the bearings in the arms. 

     

    ****

    New version with arm bearings:

    It was hard to attach the solar panel to that arm model so I switched it for one with mini bolts:

       

    I don’t like the look of the three wide and narrow bearings so I am trying to hide one under the panel and switch up the second by putting the black bolt through it. One of these only would look great but three is too much.

     

    A new design with McMaster 5mm bearings (I can in fact order them it would appear). In one I keep a single large bearing and in the other all the bearing are small:

    Making a third prototype to test the following things:

    1. Durable resin for everything but especially for the lead screw.
    2. Adding flanges to hold the current bearings in place.
    3. Slight tweak to the currently improvised lead screw design.
    4. Fix angles again with shorter arm.
    5. Hiding the other bearings a bit under the panel.
    6. Making a third so that I can begin testing the “swarm” effect of the robots actually moving.

    ****

    I began two stress tests based on Paolo’s advice:

    Some things to note:

    1. These are so much fun, people visiting see what you’re doing as Paolo suggested!
    2. It fights anxiety – you know if it will work or not.
    3. Working for 1 minute is not the same as working for two weeks 😉

    Unfortunately there is a serious issue: The linear drive is drawing 600mA at 5V to move up and down…I should try to mess with the steps and speeds to see if I can get this down. The rotating motor is drawing less than 150mA. 

    Looking on Alibaba, the most popular size of smaller panel is 156mmx156mm.  But also found some 47×47:

    and some 55mmx14mm

    37x21.8mm 6V 2mA outdoor used Thin Film Amorphous Silicon Solar Cells for Outdoor Products

    37×21.8×1.1mm 

    Here are the best links I’ve found so far:

    https://www.alibaba.com/product-detail/55x14mm-3-0V-7uA-dim-light_60585863880.html?spm=a2700.galleryofferlist.0.0.43be4630X6CXwJ

    https://www.alibaba.com/product-detail/Dim-Light-Amorphous-Silicon-Thin-Film_208238751.html?spm=a2700.details.deiletai6.5.561929devzX1BP

    https://www.alibaba.com/product-detail/3V-10uA-Dim-Light-Amorphous-Thin_62187655652.html?spm=a2700.details.deiletai6.1.561929devzX1BP

    https://www.alibaba.com/product-detail/37×21-8mm-6V-2mA-outdoor-used_60506651563.html?spm=a2700.galleryofferlist.0.0.2430367cO11E7R&s=p

     

    I sent my first email: 

    Hello,

    I’m a research engineer at the Universite of Paris Sud in France and an M.I.T. graduate.

    I’m working on a low-power solar follower product and reqiure small cells like yours to create a series of panels (with each an array of 5×2) to combine with an energy harvesting IC.

    I am interested in your product and would like to request a sample if possible to test with my setup.

    Thank you ,
    Jonah Marrs

    *********

    Easy stepper motor driver can drive both steppers at around 150mA at 5V with no load. 

    The DRV8833 with correct step and speed settings can drive the linear with the plastic lead screw found in the CD drive at around 360mA but has a super high idle current of 600mA. It gets super hot as a result. The DRV8833 cannot drive my lead screw setup however… Basically there is too much friction in my lead screw design currently. So, the conclusion is that it’s possible to drive this thing if I put the driver to sleep and I use the existing lead screw.

    I am leaning towards using the found CD drive mechanisms (because they are perfectly made to minimize friction etc. already and look super cool) and add a second bar parallel to the first to improve stability and compensate for the rotating that the plastic lead screw wants to do.

    I’m also adding another bolt to the bottom angle bearing, and looking for some 3mm bushings to add to the sliding portion. Here seem to be the two primary options:

    The side by side bars on the left are less flexible with different found lead screws as the bolt location can’t move much to either side. It also makes the front part flatter and longer, whereas the bar behind makes the design feel more three dimensional and compact. 

    I prefer the bar behind. 

    Bending joints options:

    I like the asymmetry of not having the top and bottom joints unaligned in elevation and in plan views, it feels more dynamic and optimized. I like the bottom bearing being centered with the cam. 

    Hopefully this version will allow me to do some stress testing with the tilt mechanism.

     

    Here are the parts laid out:

    The assembly turned out well:

     

    ERRATA:

    1. The lead screw is a tiny bit too high above the threaded rod, I had to carve out some material with the dremel…
    2. The elbow joint connected to the cam can’t work with a captive nut the way I originally concieved but it can work with the cap of the screw in the place of the nut.
    3. The set screw for the sprocket needs to be almost flush with the sprocket surface to not hit the bearing squeezing screw. The bearing squeezing screw between the parallel bars needs to come from the top not the bottom or else it interferes with the chain. 
    4. I think I need to shift the two bolts that hold in place the bottom motor 90 degrees. And I may need to add a little circular band to keep this motor straight.  A tiny drop of hot glue solves this…
    5. The solar panel surface is not flat but tilts inwards.

    I got the test set up working again with two Easy Stepper Motor Drivers (with Enables and 5V+ connected also) this time. Now the bottom motor is driving 100mA and the linear is pulling 200mA. Both are cool to the touch. However, there is a little bit of power lacking for the linear lifting motor and it is skipping some steps. Switching to 1/4 instead of 1/8 microstepping, and making sure all the bearings are set up smoothly, appears to mostly fix this though.

    Some experiments taking nicer photos:

    A with and without solar panel gif:

    *****

    I’m doing a next design based on the observation that the motor is struggling to pull up the solar panel and that the weight could be repositioned closer to the center of gravity and rotation axis. It’s more sunflower like, and the lead screw is now exposed as in version one. Nicer balance in terms of the bending joints which now aren’t all on the same side. One of the three bearings is hidden so the emphasis is more on the two side ones now. Far more sturdy rotation mechanism for the solar panel so no more warping and bending hopefully. The arm will have to travel far less distance to change the angle of the solar panel also.

    This experiment is interesting to me because it’s an attempt to move towards a more robust design while trying to keep it visually interesting and maintaining the attention to form.

     

    I adapted it for a mirrored version of the linear drive and new lead screws (it wasn’t too hard to do). Now I have right and left handed machines:

    This is interesting as it shows how easy or not it is to adapt to the repurposed CD drive mechanisms with the current design and how much variation can be created organically. 

    ***

     

    It looks like I should go with white Rigid resin and that I should use bushings for the sliding portions so no part of the print has friction.

    These appear to be the key characteristics of the lead screw/nut setup.

    ****

    Adding some grease to the rails:

    *****

    Here’s the tall version:

    It has great tilt range.

    It feels much taller and more slender. It also looks far more like a sunflower. It’s also lost its animate / cuteness quality that comes from being compact and now feels more like a machine. It does make more sense in terms of weight distribution, however.

    It proves that the idea of adjusting for found CD drives works in principle. 

    V.4 ERRATA:

    1. The Durable resin is too flexible to make rigid longer parts. The whole assembly is flopping all over the place.
    2. I need to modify the central solar panel hinge – it’s not possible with the hardware I have to make it function properly. Because the tilt arm pulls from the side, it has a tendancy to tweak the central hinge. I could use the large bottom bearing up top?

    ****

    The new version features a pole that pushes up to tilt the solar panel, and lets the panel rotate down when it descends. This means fewer bearings and maybe less strain on the linear actuator stepper motor:

    I’ve redesigned the control board. It now has a nicer spacing between the motor driver out pins and doesn’t have any other wires nearby to get in the way of these pins. It also has the motor driver sleep pins connected to the microchip, and can drive two steppers instead of one stepper and one DC motor as with the previous version. It also has more noise attenuating caps:

    I am also considering using an Arduino Nano with DRV8834s and a mini lithium ion just to get this prototype running!

    This works but it’s very heavy with the battery packs. I may need to glue the bearings in place or work with a more robust design for this phase.

     

    I’m using the StepperDriver Arduino library and this is what my loop looks like:

    if (analogRead(A0)-analogRead(A1)>threshold)
    {
    stepperTop.move(-MOTOR_STEPS*MICROSTEPS);
    }

    if (analogRead(A1)-analogRead(A0)>threshold)
    {
    stepperTop.move(MOTOR_STEPS*MICROSTEPS);
    }

    if (analogRead(A2)-analogRead(A3)>threshold)
    {
    stepperBottom.move(-MOTOR_STEPS*MICROSTEPS);
    }

    if (analogRead(A3)-analogRead(A2)>threshold)
    {
    stepperBottom.move(MOTOR_STEPS*MICROSTEPS);
    }

     

    And here’s the new print:

    ****

    Just discovered why I may have been having issues with the DRV8833s…Their max soldering temperature is 260C, I have been using 300C!

    ****

    I tried to get a full prototype running with the Arduino breakoutboard version but it’s surprisingly heavy and both attempts were unsuccessful. The second:

    Without the weight of the circuit board everything is fine however:

     

    I think I may have to admit that this thing is too janky to work beyond as a quick video. 

     

    *****

    Meanwhile I’m working on a DC prototype of the more complex 2DOF design:

     

    The idea here is to have 2 1DOF solar engine circuits + a dark activated pummer circuit. The machine would then spend its days searching for the sun and charging up a bigger capacitor to then blink at night like a lighthouse. I’m not sure if I should make the blinking synchronise with other nearby blinkers using this circuit:

    https://www.instructables.com/Synchronizing-Fireflies/

    One DC motor (controlling the tilt) is so slow it’s barely noticable at all while the other one swings the machine round dramatically. The design has less magic than the servo version but is far easier to control and has no issues with the weight of the solar panels. 

     

    Robot Arm

    Here is the final product:

     

     

    1 Common robot arm configurations | Download Scientific Diagram

    After the relative success of the foam cutting machine, I would like to build a medium-sized robot arm which can actually be a useful tool in the lab and not just a toy.

    The main questions appear to be: how to increase the torque of the stepper motors? Should we make a classic robot arm or a Selective Compliance Assembly Robot Arm SCARA?  Should the parts be 3D printed or CNC milled (or a combo)? and, Do I already have the parts necessary or do I need to order them in which case how much should I order?

    **********

    Stepper torque options:

    1. Use our super beefy stepper motors. Unfortunately, none of the other hardware (like belt sprockets) fit the diameters of the shafts.

    NEMA 34 Stepper Motor (6A , 12 Nm , 151mm) | DIYElectronics

    2. 3D print a planetary gear or buy one:

    (but these make the front of the stepper bulky and a bit ungainly)

    3. Get a large timing belt pully with a short belt drive: (unfortunately we don’t have anything like this lying around the lab).

    4.  3D print a large gear to turn directly with the stepper:

    A different concept that involves a motors not all at the base:

    **********

    SCARA vs. Conventional robot arm.

     

    Building SCARA Robot Arm pick and place using vision system - YouTube

    YK400XE

    #SCARAs fold up easily and are faster for certain tasks than conventional robot arms.

     

    pyBot: OPEN SOURCE and 3D printed Robotic Arm controlled with Python

    Custom SCARA printer finally taking shape. : 3Dprinting

    Scara arm solution

    A Desktop SCARA Robot using Stepper Motors

    298 Best CNC images in 2020 | Cnc, Diy cnc, Cnc machine

    But there are some neat conventional robot arm designs out there too:

    *******

    CNC milling vs. 3D printing:

    CNC milling some parts (like the large gears) seems possible:

    Nylon and ZMorph CNC PRO Milling Toolhead

    But I also need either to buy a large bearing or to make my own bearing…Unless I make a geared slew bearing:

    Single Row External Gear Slewing Bearing China Manufacturer

    Here’s a cool guide on designing gears: https://lcamtuf.coredump.cx/gcnc/ch6/

    Some DIY slew bearings:

    Project | Mammoth ARM | Hackaday.io

    A 2.5D Slew Ring | Hackaday.io

    ***********

    Robot background information: http://www.societyofrobots.com/robot_arm_tutorial.shtml

    Cool tutorial includes info about DOF, calculating torque for each joint (fewest joints possible with shortest lever arms the better): http://www.societyofrobots.com/robot_arm_calculator.shtml

    Some simple arm linkage ideas:

    Homemade Scara Robot Arm DIY Robotic Frame Projects Laser 3D Printer Chassis Draw Arduino Control d - YouTube

    3D Printer Technology and Innovation | Desktop cnc, Robotic arm diy, Diy robot

    **********

    And these Five-bar linkage machines (aka Parallel SCARA robots), they appear to be known for being super fast:

    https://en.wikipedia.org/wiki/Five-bar_linkage

    Homemade Scara Robot Arm DIY Robotic Laser 3D Printer Chassis Draw Arduino Control Frame Projects 2 - FutureTribe.Me

    SCARyllA: Dual (parallel) arm SCARA laser engraver build

    ÉTS : Laboratoire de commande et de robotique

    Related image

    Lightning-Fast SCARA Robot Prototype by Proto G - Hackster.io

    **********

    For the end effector I think either air pressure or electromagnet:

    Vacuum End Effectors VEE

    Robotics Industry Insights - Latest Trends in Intellig...

    ************

    Some early models:

    With only two rails (I’m not sure if this is sufficiently stable or not as many designs have 3 or even 4 rail):

    Similar but with a larger motor at the bottom and less ugly mounting plate. 

    A completely different SCARA design, I like the silhouette but it would involve tons of cut planar material that would need to slide into together and we might not have everything on hand to make this either: 

    Quick attempts at 3D printing planetary gears:

    https://www.thingiverse.com/thing:2114390

    https://www.thingiverse.com/thing:3231908

    (interesting belt option here: https://www.thingiverse.com/thing:2911407)

    Using the 0.8 nozzle was not ideal and none of the pieces fit properly. I would love to try this as a cnc cut project but I think it would be highly technical and difficult and at the end would end up in a tiny box. (I’m going for medium scale machines at the moment not tiny intricate things).

    We have 12mm HDPE in white and blue in the lab, I’m going to first 3D print then mill it. 

    I’ve come to a compromise with the design. It will give me the opportunity to design with a Nema 23 a complex peice (geared slew bearing), to work for the first time with a 5 linkage parallel robot design, to CNC mill HDPE for a more robust machine, but also builds on the syringe pump linear actuator and the foam cutter designs. Most importantly, I have all the components I need to build the full prototype already in the lab. 

    I added hardware to this model to make sure everything makes sense:

    *********

    Developement of the geared slew bearing:

    Outlined this drawing in Rhino and then applied it to a circle:

    To make everything fit (increments of 2mm) I changed the size slightly of the gear:

     

    Here is the first prototype:

    Here is a section showing the bearings cut through and how two layers of 6mm HDPE should come together to make the bearing. After assembling we’ll see if .1mm was too much spacing between the bearing and the walls, and also if there need to be two rows of 4mm bearings.

     

    *******

    Here are the 5 bar parallel robot 3D printed parts (view from underneath):

    A combination of nuts, washers, 16mm bearings and socket shoulder bolts:

    There is an offset in order to make everything work on the stepper motor shafts:

     

    *****

    With the final additions here is the final machine:

    Here’s the 3D print file with all the parts: 

    Here is the kit of parts (minus the parallel arm rods):

    The geared slew bearing assembly is tricky because the bearings want to fall within the inner moat.

    Adding the top bit:

    Finishing it off:

    Here is the drive mechanism with an idler I added:

    Assembling the parallel robot arm components:

    Hammering in the bearings caused splitting in the print…

    I sawed the metal bar and deburred before assembly. 

    The top threaded rod motor assembly (I broke one side hammering the nut in a little too vigorously)  

    Despite checking and rechecking I somehow forgot to put holes in the middle of the rod bearings (!)

    Here’s the linear actuator assembly:

     

    With the parallel arms attached, just waiting for the base to finish printing:

    With the base:

     

    Errata with the bottom part of the robot:

    -impossible to tighten hex nut to fasten gear to bottom motor axel. (Added slot for this purpose)

    -not nut subtractions to help hold bolts which fix geared slew bearing to base plate. (Added captive nut subtractions to bottom of base plate)

    -I subtrated a cylinder from the base for the motor gear but this makes no sense as it rotates around and does not stay fixed. (I filled this in)

    -With current arrangement the belt between the drive shaft and geared slew bearing was loose. (Either I add a spot for an adjustable bearing or I change the location of the motor to pull it further away…I chose the latter).

    ****

    CNC milling:

    The top motor and rail mount:

    I replaced one part of the 3D printed robot parts at a time:

    The middle component:

    Everything fits together nicely!

    And here is the final result:

    The CNC mill using HDPE is extremely fun to use. The only part that is not easy to make is the bearing assembly. This I will print in durable white resin on the Formlabs.

        

    Medium-sized CNC Foam Cutter (with Léon Reboul)

    Here is the finished product:

     

    And here is a quick video cutting foam:

     

    Another video showing the stage testing:

     

     

    Here are the files on Thingiverse: https://www.thingiverse.com/thing:4428184

    We’ll be harvesting parts from an old Ultimaker 2.

    The stuff we plan to use:

    Based on what we found, we plan on making two threaded rod actuators and two belt-driven actuators.

    Here is the prototype of the linear threaded rod actuator:

    Here is the prototype of the linear belt-driven actuator:

    Here is the prototype of the entire foam cutter assembly:

     Here are all the parts 3D printed:

    Here are the 3D printed parts along with the hardware:

    Here is the belt drive assembly:

     

    Here are the two axes completed:

    Here is the first of the two linear actuator drives:

    Slight differences between the two based on different hardware but essentially the same:

    Here is the full assembly minus electronics:

    The electrical connections to the TinyG:

    All plugged in and ready to go:

     

    Using the webpage CNC controller Chilippeper :

    Running local JSON script to allow the website to access the COM ports, if I understand correctly:

     

    Chilipeppr Configuration (https://github.com/synthetos/TinyG/wiki/TinyG-Configuration-for-Firmware-Version-0.97):

    To change the Motor – Axis assignment in Chilipeppr:

    $1ma=0 Maps motor 1 to the X axis
    $2ma=1 Maps motor 2 to the Y axis
    $3ma=0 Maps motor 3 to the X axis
    $4ma=1 Maps motor 4 to the Y axis

    To assign the same travel per revolution for axis 4 as for the other 3 axes:
    $4TR 1.25
    To swap polarity of a motor:

    $1PO

    • 0 = Normal motor polarity
    • 1 = Invert motor polarity

    To set X axis minimum and maximum end stop limit switches (the switches connect GND to XMIN or XMAX on the Tiny G).

    $XSN 3 and $XSX 3

    To change the distance for every movement of 1mm:

    $1tr VALUE

    To change max feedrate in X:

    $xfr

    *************

    Here is the video of the machine making its first moves:

    **************

    Here is a version two fixing some errors in the 3D modeling:

    Linear actuator redesign (forgot to subtract the motor and threaded rod previously):

    Here’s the finished belt-drive assembly:

    I reprinted this part with 40% density instead of 20% (which broke last time when I tightened), corrected the diameter of the rods (which destroyed the rigity of the actuator), reoriented the embedded nut, and used shorter bolts:

    Also 40% instead of 20%:

    This was a bit tricky but using two bolts with washers I replaced the hot glue to fix the belt in place. 

    I corrected the orientation of the holes and the two actuators line up perfectly:

    Here’s the final assembly version 2:

     

    *************

    I’ve added some limit switches and have a preliminary setup for the hot wire cutting fixtures:

    **************

    Here is the first test cut:

     

    Here’s what it looked like on the software side:

     

    I used CAMBAM to take in a DXF and output the Gcode. 

    I had to additionally make everything related to the Z axis zero, and set the start point.

    DIY Centrifuge

    Based on Hackteria’s DIY Centrifuge (https://hackteria.org/wiki/Hacked_Hard-disc_Centrifuge)

    Controlling a Three-Phase DC Brushless motor (BLDC) of a Hard Drive primer: https://www.monolithicpower.com/pub/media/document/Brushless_DC_Motor_Fundamentals.pdf

    Similar to a stepper motor (except a BLDC is meant to run smoothly not in steps) but with three stators (if it’s an inrunner, an outrunner has the permanent magnets around the shaft): 

    What are Brushless DC Motors | Renesas Electronics

     

    At the top are the signals we need to generate with signal phase 120 degrees offset (steppers are typically two phase with 90 degrees apart):

    BLDC Motor Control With Arduino, Salvaged HD Motor, and Hall ...

    I’m using the SN754410 Quadruple Half-H Driver IC based on this tutorial: https://elabz.com/bldc-motor-with-arduino-circuit-and-software/

    Here’s the circuit breadboarded (motor connection not shown) with a pot to change the speed:

    Here is the scope capture of the sigals generated:

    This is the 3D file I downloaded: https://www.thingiverse.com/thing:2539744

    Here’s the 3D print with two 1.5ml Eppendorf tubes screwed on to the BLDC hard disk motor. 

    I had difficulty distinguishing between which of the three wires were connected to coils and which on wasn’t and got inconsistent resistance measurements. My current thinking is that the motor was damaged and is not working.

    Testing with another kind of BLDC and still not working…so is most likely my circuit?

    EWOD (electro wetting on dialectric)

    This project is based on Gaudi Lab’s OpenDrop (https://www.gaudi.ch/OpenDrop/)

    Here is the github for Fablab Digiscope’s iteration of the project: https://github.com/merlinmarrs/OpenDrop

    We don’t have high voltage MOSFETs so we are using relays instead. In parallel we will be sourcing the components to make the high voltage power supply using a boost converter that takes 12V as input. In the meantime, we will be using a transformer that sources 100V directly to the board to test functionality. 

    Here is the board cut:

    To supply the minimum 100V necessary, I found this high voltage boosting circuit here: https://www.multisim.com/content/dUPNxLKfTuK3sYfGNjNxNg/9v-to-100v-boost-converter/

    With what we have in the lab, it’s peaking at just under 80V. 

    Testing the relay:

    Testing the relay with a motor and 9V battery:

    Here is the first full prototype:

     

    What we need now is some hydrophobic dialectric like Teflon…

    Fever monitor

    This device is intended to be installed within the 3D printed forehead mount of a visor. 

    It’s being developed at this github: https://github.com/merlinmarrs/Fever-Meter

    The top board is a boost regulator taking the 2V from a pair of miniature backup batteries, and the bottom side is an attiny85 with I2C temperature sensor and indication led. 

    This project necessitated the use of rivets. I used a dremel to make a hole in the board then inserted the rivet and gave it a tap with our riveting tool.

    The results are relatively clean:

    IR thermometer with POV display

    This contactless temperature sensor has a POV display for the temperature readout. 

    Here is the github: https://github.com/merlinmarrs/POV-fever-meter

    Here is what it looks like in a dark room with long exposure:

    The plan was to have the device spell out the message in reverse after displaying it normally to allow a certain frequency of waving the wand back and forth to display perfectly. Alas…this does not work well currently.

    I am still waiting for the IR temperature sensor to arrive in the mail.

    Dispositif Désinfection

    Developed by Fablab Digiscope.

    A board to sense the temperature and illumination, and act as an interface, inside a disinfection device:

    https://github.com/merlinmarrs/anti-viral-dispositif/

    A main board and secondary board to control a disinfection chamber based on this tutorial: http://www.needlab.org/face-masks-disinfection-device

    Here is the BOM:

    Standard components:

    7 segment display x2 595 Shift Register x2 LED x 2 Photocell Piezo Atmega 328p micro-swith (CHECK MAX VOLT + AMP RATING)

    exotic components:

    lampe UV-C à Amazon.fr:

    https://www.amazon.fr/Germicide-Ultraviolet-st%C3%A9rilisateur-Submersible-radiations/dp/B07Y82SM36/ref=sr_1_4?__mk_fr_FR=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=uv+aquarium+sterilizer&qid=1587383305&s=hi&sr=1-4-catcorr

    1. MLX90614 (pas en rayon a Mouser, Farnell, Sparkfun, Polulu ou Adafruit) à Digikey (ou c’est “hors prix”) ou Amazon.fr:

    https://www.digikey.com/product-detail/en/melexis-technologies-nv/MLX90614ESF-DCA-000-TU/MLX90614ESF-DCA-000-TU-ND/2025323

    https://www.amazon.fr/MLX90614ESF-MLX90614ESF-BAA-000-TU-ND-thermom%C3%A8tre-infrarouge-compatible/dp/B07JBKM2K3/ref=sr_1_1?__mk_fr_FR=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=MLX90614&qid=1587470750&s=hi&sr=1-1-catcorr

     

     

     

    Still waiting for the temperature sensor to arrive in the mail. 

    Syringe pump mechanism + electronics

     

    This is the stepper motor driver design we are hoping to use to control a syringe. Here is the PDF describing the assembly: etapes fab venti v2

    And here is the github repo:

    https://github.com/merlinmarrs/FabVenti

     

    This is the syringe pumping prototype I developed. It uses 8020, a NEMA stepper with built in threaded rod, NEMA motor brackets, and linear bearings. The rest is 3D printed and uses M3 and M4 screws. 

    Solar Electronics Primer

    The goal of this primer is to introduce people to mini DIY solar energy applications.

    New solar product I just found out about: 

    Solar Digital Calipers

                      

    Fab 15 Part VII

    Here are some videos of the current prototypes:

     

     

     

     

    I want to focus this project on the design of the 2 axis rotation mechanism. The electronics and code side has already been explored and I can’t offer anything new here as a designer.

    (I’ll abstract the sensing and radio side of thing for a now and design the PCB to be sent to manufacture later. This will be a good exercise in applying the new PCB design best practices that I have since learned and for overcoming the limitations of PCB making in the lab. I could imagine this board having a compass and accelerometer to find out its own direction, and possibly an wifi connection to send its data to the internet.

    To simplify things further, I could think of this design as an indoor weather station. Instead of the tpical arduino inside a plastic box though, this project would emphasize the dynamic quality of solar energy, turning solar tracking into an exciting technical spectacle. The design would make reference to off-grid technology and thereby embody the mythical appeal of the power-autonomous and the off-grid (tiny house movement, prepper phenomenon, etc.).

    *************

    I’m inspired by weather buoy design:

     

    And also the possibility of some kind of Wes Jones inspired multi solar panel actuated louver system:

    Louver Dampers / Industrial Dampers • Kelair Products Inc.

    It could look like the MIT solar panel project but it would have a lower center of gravity and be motor controlled.

    Hyperstealth's "Declipse™" Shadow Reduction Technology Solves MIT ...

    Some quarantine sketches:

    *************

    Problems with the previous prototypes:

    V.1

    Top heavy and always falling over.

    Middle connection to ball bearing not sufficiently robust

    Nothing keeping motor on track, it lifts up off the gear track.

    Center mast not easy to fix in place.

    V.2

    Will topple over in certain positions.

    Tilt cannot rotate 360 and is holding a lot of weight.

    No way to tell exactly what position reached.

    ****************

    V.3 Hinge tilt + 3D printed bearing with motor mount integrated

    The hinge will be based on this idea from https://www.generationrobots.com/en/402702-pan-tilt-kit-for-pixy-camera.html:

    Some detail shots of the assembly (from https://docs.pixycam.com/wiki/doku.php?id=wiki:v2:assembling_pantilt_mechanism):

    Here is the one sided threaded bracket:

    https://www.sparkfun.com/products/10228

    Angle Bracket - 4-40

    Here is a 3D printed version: https://www.thingiverse.com/thing:978300. I would be replacing the servo with the DC gear motor and changing the bolts:

    And this is how the servo arm fastening works:

    In combination with this is the idea to design a completely custom rotation system. This would combine Paolo’s 3D printed bearing mount (https://www.instructables.com/id/3D-Printed-Bearing-with-Driven-Miter-Gear/) with DIY stepper motor coils:

    Image result for paolo 3d printed bearing

    3D Printed Bearing With Driven Miter Gear

    And these are two 3D printed stepper motors based on wrapping wire around nails and using rare earth magnets. I could also incorporate feedback by printing stripes and counting them with a line follower.

    The only problem appears to be the voltage required to power these motors which seems to be between 5V and 20V. Perhaps I could take some industrially made coils (which would be presumably more efficient) and reuse them. Like from the inside of a real stepper motor:

    Image result for 3d printed stepper

    The magnetic field of a coil appears to be based on the coil density (number of turns per length of wire), the material in the middle of the coil (like iron), and the current passed through. I would need a dense coil if I didn’t want to drain the caps.

    I could also work with small stepper motor linear actuators like this:, but then I would need to convert linear to rotary motion:

    Image result for mini stepper motor

    As for the code:

    https://www.hindawi.com/journals/js/2019/3681031/

    According to the above article, loading the Astrologer’s Almanac onto a sensorless microchip appears to be even more efficient than giving a microchip light sensors in the classic approach (https://create.arduino.cc/projecthub/ioarvanit/dual-axis-solar-tracker-panel-with-auto-and-manual-mode-41cfd9).

    Code has already been optimized for arduino: https://pdfs.semanticscholar.org/ffd3/bb8b5e85c796da0ae3eac3be11117291289f.pdf

    *****

    Here is the next version of this design:

    The thinking is to look around and find existing parts of medium to high quality in the lab, and design something which works around those preexisting parts. (I have the gears, the chain, the 3mm rod, and the ball bearings. The bearings we have don’t have 3mm inner diameter so right now they just turn around a hole in the 3D print / CNC milled axle holders. 

    Here’s a right angle design with only one bearing and less hardware (there may be a weight distribution argument for one of these assemblies):

    Remaking the gear (less improperly this time) with Sweep1 and scaled outline which I bent into a circle:

    Here’s the model ready for print:

    lazy explosion:

    The 3D printed parts:

    The begining of the bearing assembly:

    The alignment was impossible to get right here:

     

     I ended up hacking together something with Paolo’s bearing and some old prints. After some sanding and forcing of parts together, here is the prototype:

     

    Errata: 

    -ball bearing spacing not great enough.The bearing did not fit together, I’m guessing because there wasn’t a big enough gap between the ball bearings and the two sides of the bearing.

    -the upper bearing needs more depth in order to comfortably rest in place, but it just bearly works.

    -the motor holders required many minutes of sanding and filing to fit the motors, but now it fits perfectly.

    -the gear should probably be a miter, also there is nothing holding the sprocket down in place.

    ******

    Took apart a bunch of small stuff to have small screws and rods:

    To fix the board to the bar I used a part I found in a floppy disk drive:

     

    Showing the M1.6 screws holding the top 3D print in place and some M3 black bolts to keep the inner bearing off the ground.

    I wired up the two motors as well to see how that would work:

    *******

    Here is an attempt at making something similar from stepper motors (of course they need to be powered to hold their position so they can’t really be weight bearing). The nice thing about steppers is the mini linear threaded drives which could be added to the pan-tilt to give the machine the ability to move around shadows? 

     

    3D modeling the pan tilt with two steppers:

    …and one stepper / one DC gearmotor:

    Here is the design worked a bit more and ready to print:

    Here is how the print and assembly turned out:

     

    I like how the translucent print blends with the different metal and plastic shades. For the electronics I’m planning four LRDs and a super simple program (with batt for super reactive demo?). One could either imagine a whole array of the same sun tracking devices, or a series of different families of devices mixed together in an array, which would all react in the same way to moving a light bulb into the space above the robots….

    Errata:

    -Everything is still a bit too snug with 0.1mm offsets. I should have made the spacing for the rail even bigger because it needs to actually slide…

    -I designed using a bearing I only have one of and was already using in another machine…

    -The holes for the read DC motor mounting didn’t come through.

    -The top part which holds the rod and attaches to the linear rail broke because it was super weak in the middle.

    -The bottom brace is not long enough to force the panel into more acute angles.

    -The tension in the rubber belt is not sufficient to turn the base…

    -The threaded rod nut plastic piece is not pushed sufficiently into the threaded rod to grip effectively. It needs to be closer to the rod so the built-in spring is in tension.

    ****************

    I have some new parts: M2 bolts and nuts as well as steppers with gear reductions.

    Taking apart more DVD roms I had the idea of remaking this device entirely from e-waste parts. I have six kits so far:

    The idea would be to make this design:

    There are about four sets of the same components available from the 8 DVD drives I took apart. I am redesigning the 3D model with these parts in mind.

    There is also the possibility of using the motor drivers from the boards themselves except that they require a 12V VCC…

    Here is a post describing how they could be hacked: https://electronics.stackexchange.com/questions/341519/i-need-help-controlling-the-sled-motor-of-a-cd-rom-based-off-of-a-datasheet

    Image of the BD7907FS Circuit Diagram

    Here are some details about this next design:

    -it incorporates another found motor of the DVD rom device instead of the geared DC motor ordered from Polulu. 

    -it has tracks instead of holes for sensitive spots (like the DC motor mount and the threaded rod nut) so that things can be adjusted and then bolted when they are just perfect.

    -I replaced the central bearing for the correct diameter.

    -I made the upper 3D printed peice more structurally sound so hopefully it won’t break this time. 

    -I made larger offsets for inserts (except for the rod holders which I want to be snug) 0.2mm all around instead of 0.1mm this time. 

    -I made a recessed track for the gear belt holder on the DC motor. 

    -I fiddled such that the angle range for the panel is greater now. 

     

    In parallel I’m working on the simplest version of a test board possible:

    -super cap will need to be manually charged

    -4 photodiodes for solar orientation will be manually wired to avoid challenging trace designs.

    -only the most essential stuff for the motor drivers and microchip. 

    The idea is that I can make a video showing the device tracking a light source in real time super “responsively”. This could then easily be modified to be the actual sun seeking circuit. 

    I will have four little directional shaders which will cast shadows if the four photodiodes are not all pointed directly at the same light source. 

    https://www.sciencedirect.com/science/article/abs/pii/S2213138818300080

    Open hardware/software test bench for solar tracker with virtual instrumentation - ScienceDirect

    I made a quick PCB then decided what I really need is an air wired arduino with motor drivers to test this.

    Errata from second stepper prototype:

    -The 3D printed piece that holds the leadscrew nut is too thick for my M2 bolts and so it cannot be bolted on.

    -I forgot to subtract the bottom toothed part of the black gear belt wheel from the base.

    -most of the offsets are too loose. 

    -with the wider heavier DC motor the base is no longer stable enough.

    -I forgot to subtract the flange of the DC motor (like a collar around the axle) from the bracket that it attached to.

    Next I will get a quick mock up with some light sensors mounted on the four corners of the solar panel enabling an arduino to follow a light source. This won’t be embedded on a board yet, it will just be a test.

     

    ***********

    I’m using a DRV8835 motor shield and an easy stepper motor driver for this mock up with the LDRs wired like this (but with 1Ks instead of 10Ks):

    Working with Light Dependent Resistor (LDR) - Arduino Project Hub

    Here is the code I’m using to control the LDR sensing sun seeker;

    #include <DRV8835MotorShield.h>

    #define LED_PIN 13

    DRV8835MotorShield motors;

    //Declare pin functions on Redboard
    #define stp 2
    #define dir 3
    #define MS1 4
    #define MS2 5

    #define BPHASE 10
    #define BEN 9

    #define EN 6

    int sensorPin1 = A0;
    int sensorPin2 = A1;
    int sensorPin3 = A2;
    int sensorPin4 = A3;
    int sensorValue1 = 0;
    int sensorValue2 = 0;
    int sensorValue3 = 0;
    int sensorValue4 = 0;

    //Declare variables for functions
    char user_input;
    int x;
    int y;
    int state;

    void setup() {

    Serial.begin(9600);
    pinMode(sensorPin1, INPUT);
    pinMode(sensorPin2, INPUT);
    pinMode(sensorPin3, INPUT);
    pinMode(sensorPin4, INPUT);

    pinMode(stp, OUTPUT);
    pinMode(dir, OUTPUT);
    pinMode(MS1, OUTPUT);
    pinMode(MS2, OUTPUT);
    pinMode(EN, OUTPUT);
    resetEDPins(); //Set step, direction, microstep and enable pins to default states

    pinMode(LED_PIN, OUTPUT);

    pinMode(BPHASE, OUTPUT);
    pinMode(BEN, OUTPUT);
    }

    //Main loop
    void loop() {

    sensorValue1 = (analogRead(sensorPin1) + analogRead(sensorPin1) + analogRead(sensorPin1))/3;
    sensorValue2 = (analogRead(sensorPin2) + analogRead(sensorPin2) + analogRead(sensorPin2))/3;

    sensorValue3 = (analogRead(sensorPin3) + analogRead(sensorPin3) + analogRead(sensorPin3))/3;
    sensorValue4 = (analogRead(sensorPin4) + analogRead(sensorPin4) + analogRead(sensorPin4))/3;

    if(sensorValue1 > 500 && sensorValue1 > sensorValue2)
    {
    StepForwardDefault();
    }

    if(sensorValue2 > 500 && sensorValue2 > sensorValue1)
    {
    ReverseStepDefault();
    }

    if(sensorValue3 > 500 && sensorValue3 > sensorValue4)
    {
    forward(10);
    nomove();

    }

    if(sensorValue4 > 500 && sensorValue4 > sensorValue3)
    {
    backward(10);
    nomove();

    }

    //StepForwardDefault();
    //ReverseStepDefault();

    //forward(50);
    //backward(50);
    //nomove();

    }

    void forward(int t)
    {

    digitalWrite(BEN, HIGH); //forward
    digitalWrite(BPHASE, LOW);
    delay(t);

    }

    void backward(int t)
    {

    digitalWrite(BEN, HIGH); //backward
    digitalWrite(BPHASE, HIGH);
    delay(t);

    }

    void nomove()
    {

    digitalWrite(BEN, LOW); //no movement
    digitalWrite(BPHASE, LOW);

    }

    //Reset Easy Driver pins to default states
    void resetEDPins()
    {
    digitalWrite(stp, LOW);
    digitalWrite(dir, LOW);
    digitalWrite(MS1, LOW);
    digitalWrite(MS2, LOW);
    digitalWrite(EN, HIGH);
    }

    //Default microstep mode function
    void StepForwardDefault()
    {

    digitalWrite(dir, LOW); //Pull direction pin low to move “forward”
    for(x= 0; x<100; x++) //Loop the forward stepping enough times for motion to be visible
    {
    digitalWrite(stp,HIGH); //Trigger one step forward
    delay(1);
    digitalWrite(stp,LOW); //Pull step pin low so it can be triggered again
    delay(1);
    }

    }

    //Reverse default microstep mode function
    void ReverseStepDefault()
    {

    digitalWrite(dir, HIGH); //Pull direction pin high to move in “reverse”
    for(x= 0; x<100; x++) //Loop the stepping enough times for motion to be visible
    {
    digitalWrite(stp,HIGH); //Trigger one step
    delay(1);
    digitalWrite(stp,LOW); //Pull step pin low so it can be triggered again
    delay(1);
    }

    }

    // 1/8th microstep foward mode function
    void SmallStepMode()
    {

    digitalWrite(dir, LOW); //Pull direction pin low to move “forward”
    digitalWrite(MS1, HIGH); //Pull MS1, and MS2 high to set logic to 1/8th microstep resolution
    digitalWrite(MS2, HIGH);
    for(x= 0; x<1000; x++) //Loop the forward stepping enough times for motion to be visible
    {
    digitalWrite(stp,HIGH); //Trigger one step forward
    delay(1);
    digitalWrite(stp,LOW); //Pull step pin low so it can be triggered again
    delay(1);
    }

    }

    //Forward/reverse stepping function
    void ForwardBackwardStep()
    {

    for(x= 1; x<5; x++) //Loop the forward stepping enough times for motion to be visible
    {
    //Read direction pin state and change it
    state=digitalRead(dir);
    if(state == HIGH)
    {
    digitalWrite(dir, LOW);
    }
    else if(state ==LOW)
    {
    digitalWrite(dir,HIGH);
    }

    for(y=0; y<1000; y++)
    {
    digitalWrite(stp,HIGH); //Trigger one step
    delay(1);
    digitalWrite(stp,LOW); //Pull step pin low so it can be triggered again
    delay(1);
    }
    }

    }

     

    ***********************

    To make an on-board version of the breadboard prototype I made, I think I can reuse a previous version of this circuit which has two motor drivers and even a couple of spots for LDRs (I would just ignore the radio and sensor side of things for the moment at least):

    (I may need to add a CS pull-up resistor and a 0.1uF cap to power as these were two erratta from this version of the board.) 

    This turned out to be a bad idea, there are approximately 3,590 jumpers between the two boards, so no practical at all.

    I am thinking of making miniature smd light sensor pairs (we have smd photodiodes in the lab) that would attach to the outside of the board on 3D printed T-shaped things:

    When light is straight ahead, difference between LDRs will be minimal. Moment that one is significantly darker than the other, the motor which turns the dark side towards the light needs to come on until they are equalized again. So more of a nested if loop?

    if(sensor1-sensor2 > 200){// difference in sensors

    if(sensor1>100&&sensor2<50) //turn motor CW

    else()//turn motor CCW

    ****************

    Because the board already has the radio built in, I wonder if I should reincorperate it into the project. I also recieved some female SMA board antenna connectors which I could incorperate into the new version.

    10Pcs SMA Female Solder Edge PCB Mount Straight RF Connector Plug ...

    ************

    New code:

    #include <Stepper.h>

    // change this to the number of steps on your motor
    #define STEPS 200

    // create an instance of the stepper class, specifying
    // the number of steps of the motor and the pins it’s
    // attached to
    Stepper stepper(STEPS, A2, A3, A5, A4);

    #define RED 3 // RED LED

    int sensorPin1 = A0;
    int sensorPin2 = A1;
    int sensorPin3 = A6;
    int sensorPin4 = A7;
    int sensorValue1 = 0;
    int sensorValue2 = 0;
    int sensorValue3 = 0;
    int sensorValue4 = 0;

    void setup()
    {

    pinMode(sensorPin1, INPUT);
    pinMode(sensorPin2, INPUT);
    pinMode(sensorPin3, INPUT);
    pinMode(sensorPin4, INPUT);

    pinMode(6, OUTPUT); //

    pinMode(7, OUTPUT); //

    // set the speed of the motor to 30 RPMs
    stepper.setSpeed(60);
    }

    void loop()
    {

    digitalWrite(6, LOW); //
    digitalWrite(7, LOW); //

    sensorValue1 = (analogRead(sensorPin1) + analogRead(sensorPin1) + analogRead(sensorPin1))/3;
    sensorValue2 = (analogRead(sensorPin2) + analogRead(sensorPin2) + analogRead(sensorPin2))/3;

    sensorValue3 = (analogRead(sensorPin3) + analogRead(sensorPin3) + analogRead(sensorPin3))/3;
    sensorValue4 = (analogRead(sensorPin4) + analogRead(sensorPin4) + analogRead(sensorPin4))/3;

    if(sensorValue1 > 500 && sensorValue1 > sensorValue2)
    {
    clockwise();
    delay(500);
    }

    if(sensorValue2 > 500 && sensorValue2 > sensorValue1)
    {

    counter_clockwise();
    delay(500);
    }

    if(sensorValue3 > 500 && sensorValue3 > sensorValue4)
    {
    stepper.step(STEPS);

    }

    if(sensorValue4 > 500 && sensorValue4 > sensorValue3)
    {
    stepper.step(-STEPS);
    }

    digitalWrite(6, LOW); //
    digitalWrite(7, LOW); //

    }

    int clockwise()
    {

    digitalWrite(6, HIGH); //
    digitalWrite(7, LOW); //

    }

    int counter_clockwise()
    {

    digitalWrite(6, LOW); //
    digitalWrite(7, HIGH); //

    }

    Circuit Protection + PCB Design Rules of Thumb

    I just destroyed a circuit I spent over a week preparing and I decided I would learn how to better protect my circuits.

    Reverse Polarity protection:

    A diode can be used to protect a circuit but it will drop 0.7V and will waste power. A shotky diode will only drop .3-.4V but it has the same issue. A P-Channel MOSFET set up where the gate is connected to ground will only turn on when the polarity is correct. If Vin is not greater than the maximum allowed voltage you can put accross the MOSFET from gate to source (Vgs max.), or the Vin is not less than the threshold required for the P-FET to turn on (Vgs th), then it doesn’t need any other components.

    Image result for how to protect circuits from reverse voltage polarity

    For overvoltage protection (https://circuitdigest.com/electronic-circuits/overvoltage-protection-circuit):

    When the voltage is below the Zener Diode’s 5.1V reverse threshold, Q2’s base is HIGH  (through the 2.2K resistor) so the PNP is off. This means that Q1 is ON (because it’s PNP base is connected to ground via 6.8K) and the circuit is powered.

    When the voltage is above the Zener Diode’s 5.1V reverse threshold, Q2 is connected to ground and is turned on. This connects Q1 with VCC and therefore turns it off, disconnecting the circuit from the power. 

    Overvoltage Protection Circuit Diagram

    For short circuit protection:

    Q2 is a PNP, Q1 is an NPN. Here is my understanding based on the site https://circuitdigest.com/electronic-circuits/short-circuit-protection-circuit-diagram

    First a small amount of current reaches the base of Q1 (via R5 and the D2), causing it to turn on Q2. Now current flows through Q2 into R4 and D1 while keeping Q1 on. Current is no longer flowing through D2.

    When a short occurs, current passes directly towards ground from Q2 and therefore no longer turns Q1 on. This turns off Q2 and now current passes via R5 and D2, skipping D1 and still skipping R2 towards Q1, directly to ground. Instead of having a short, we now have current passing through R5 and D2. 

    Short Circuit Protection Block Diagram

    PCB Design (from https://www.youtube.com/watch?time_continue=5&v=NJKZZArjdg8&feature=emb_logo):

    -rounded corner for logic levels, straight corners “round edges”. (Though not everyone seems to agree on this). 45 degree angles are good, 90 are bad.

    -minimize trace lengths, components electronically close should be physically close too. Longer traces have higher resistance, capacitance and inductance. 

    -Think in terms of a signal chain, with input on the left moving towards output on the right. Divide things into building blocks. Build each block separately and then throw it on the main board. 

    -VCC should be connected via a star-like formation to sub systems, with branches of equal length, NOT in a cascaded or serial way where the last sub system is furthest away from VCC. This will make the later sub systems vulnerable to noise produced by the upstream ones.

    -Mechanical parts (pots, switches, barrel connectors) fail before electrical parts.

    -watch out for your ground returns (the path that a component’s ground path with take to make it back to the power regulator). If it is zig zaggy and not short this is not ideal.

    -don’t forget to add test points! 

    This website helps to calculate the correct width of traces for a given current:

    http://circuitcalculator.com/wordpress/2006/01/31/pcb-trace-width-calculator/

    This resource looks good for more in depth: http://alternatezone.com/electronics/files/PCBDesignTutorialRevA.pdf

    Here is a table showing minimum trace widths for different thicknesses of copper:

    •••••••••••••••

    -work in mils, most components are designed with 100 mil spacing (0.1″). 

    -For your Eagle grid, had a 25 thou alt grid with a 50 thou main grid. Or a 25mil/10mil for finer work. Use a SNAP grid.

    -bigger traces are better generally, they have lower DC resistance and lower inductance.

    -25 thou for signal traces, 50 thou for power, 10-15 for traces going in between ICs is a good place to start. 

    -oval shaped pads for ICs, circular for leaded resistors and caps. 

    -minimize the number of drill bits that will be required by the board house to make your circuit.

    -check that when you actually add the components, screws, etc., it all fits and doesn’t cause potential shorts. 

    -do not mix analog and digital sub systems in the same circuit, nor high current or frequency and low current and frequency. 

    -leave a rectangle at the top of the solder mask so you can write something in pen on the board!

    -for a two sided board, the bottom can be a ground plane. You should not have the ground plane extend all the way to the edge of the board. The more copper in your ground path the lower the impedance. 

    -Use multiple vias to connect the same signal to ground to lower impedance. 

    -One bypass cap per IC: 10nF or 1nF for higher frequencies, and 1uF or 10uF for low frequencies

    -boards are typically made with 1oz. copper thickness and are 1.6mm thick fiberglass FR4.

    -don’t forget to add a signature/logo to your board!

    Visualizing your circuit before building:

    https://www.falstad.com/circuit/

    Fab 15 Part VI

    Here is my first attempt at making a video of this all working:

    I would like the next version of the video to show:-starting charging from zero.-the burst of packets sent at the begining and how it finds a balance afterwards. 
     -the sky in the background so it’s easy to understand how the clouds effect the charging rate.Here is me assembling the final boards:

     

    I tried to power the motors using the motor driver on the flip side, I got weird results until I unplugged the ICSP header. After that everything worked as expected except when the power supply was turned off for some reason the motor drivers stopped working.

    I have a problem of not having enough pins broken out.

    For the VEML7700, I downloaded the following Adafruit libraries:

    https://github.com/adafruit/Adafruit_VEML7700

    https://github.com/adafruit/Adafruit_BusIO

    For some reason I also needed to include the SPI.h file otherwise it would not compile.

    Adding the VEML7700 code somehow makes the original code no longer work… I should now try with a vanilla arduino just to make sure the test code works.

    The VOUT voltage sensing appears to work. This is a nice option because it means that just by taking the integral of the VOUT we can see if the solar panel position is getting more light (i.e. no need for multiple light sensors if we’re willing to spend some energy on motors in the spirit of trail and error sensing).

    I have noticed that LDO is not stable at 2.2V but dips to below 2V. I’m not sure how related this is to the power supply being connected to the LTC3105.

    I am working on a new minimal iteration of the sun seeking functionality.

    Here is another 3D model I’m working on. The idea is that it cannot destroy itself by accident (it can turn all the way around in both axes and not break anything). It is also independent of whatever surface it is placed on. The bearing at the center allows everything to rotate freely.

    Here are some sketches of me trying to figure out how to model the rotary thing:

    The resin prints were pretty disastrous… The bearing didn’t fit and neither did the motors or the central axis pin! After some filing and hot gluing things fit a bit better.

    P1000330

    Here is the full assembly. It’s extremely inelegant. Here are some issues:

    -stiff wires.

    -the weight of things…Everything is straining the central axis pin, and the main mast supporting the solar panel board is not being held straight up.

    -The tilt arm is hitting the rotary gear, it needs to be smaller. 

    -everything is incredibly fragile and finicky.

     

    Replacing the mast with just a simple arm is less inelegant:

    Of course now the machine can destroy itself by just turning into the board hits something…It also needs a better solution for the solar panel being attached to the board somehow that can be easily removed for programming. 

    The main axis which fits into the bearing is still problematic. 

    This beautiful object was made by Mr. Paulo Salvagione at Pier 9. This would make a better base for the rotating part of this project I think. It could be made so that it fits the motor very snugly with no play.

    I’ve decided to make my life easier and to go towards a more obvious solution for the next iteration. It will at least give me a chance to see how the balance of the object behaves over the course of a day. I’ve printed this version before in PLA but never in resin.

    I’m taking the offset of .1mm all around to make the motors fit snugly. 

    Here is the Arduino code I have developed so far:

    /*

    */

    const int pgood = 3;
    const int cap_voltage = A2;
    const int delay_time = 100;
    const int motor_time = 500;

    float cap_reading_0;
    float cap_reading_1;
    float cap_reading_2;
    float cap_reading_3;
    float cap_reading_4;

    float cap_reading_average;

    int integral_0;
    int integral_1;
    int integral_2;
    int integral_3;
    int integral_4;

    int integral_total;

    int current_reading;
    int last_reading;

    // the setup function runs once when you press reset or power the board
    void setup() {

    // motor driver pins
    pinMode(A4, OUTPUT);
    pinMode(A5, OUTPUT);

    pinMode(A0, OUTPUT);
    pinMode(7, OUTPUT);

    pinMode(cap_voltage, INPUT); //
    pinMode(pgood, INPUT); //
    }

    // the loop function runs over and over again forever
    void loop()
    {
    if (pgood==HIGH)
    {
    evaluate_east_west();
    evaluate_north_south();
    }
    }
    int evaluate_east_west()
    {
    last_reading = integral();
    clockwise();
    delay(motor_time);
    current_reading = integral();

    if(last_reading>current_reading) // move back if less sun in new position
    {
    counter_clockwise();
    delay(motor_time);
    }

    last_reading = integral();
    counter_clockwise();
    delay(motor_time);
    current_reading = integral();

    if(last_reading>current_reading) // move back if less sun in new position
    {
    clockwise();
    delay(motor_time);
    }
    }

    int evaluate_north_south()
    {
    last_reading = integral();
    tilt_up();
    delay(motor_time);
    current_reading = integral();

    if(last_reading>current_reading) // move back if less sun in new position
    {
    tilt_down();
    delay(motor_time);
    }

    last_reading = integral();
    tilt_down();
    delay(motor_time);
    current_reading = integral();

    if(last_reading>current_reading) // move back if less sun in new position
    {
    tilt_up();
    delay(motor_time);
    }
    }

    int cap_voltage_read()
    {
    cap_reading_0 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_1 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_2 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_3 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_4 = analogRead(cap_voltage);
    delay(delay_time);

    return cap_reading_average = (cap_reading_0 + cap_reading_1 + cap_reading_2 + cap_reading_3 + cap_reading_4) / 5;
    }

    int integral()
    {

    integral_0 = (int)cap_voltage_read(); // convert to int
    delay(delay_time);
    integral_1 = (int)cap_voltage_read(); // convert to int
    delay(delay_time);
    integral_2 = (int)cap_voltage_read(); // convert to int
    delay(delay_time);
    integral_3 = (int)cap_voltage_read(); // convert to int
    delay(delay_time);
    integral_4 = (int)cap_voltage_read(); // convert to int
    delay(delay_time);

    return integral_total = integral_0 + integral_1 + integral_2 + integral_3 + integral_4;
    }

    int clockwise()
    {
    digitalWrite(A5, HIGH); //
    digitalWrite(A4, LOW); //

    digitalWrite(A0, LOW); //
    digitalWrite(7, LOW); //
    }

    int counter_clockwise()
    {
    digitalWrite(A5, LOW); //
    digitalWrite(A4, HIGH); //

    digitalWrite(A0, LOW); //
    digitalWrite(7, LOW); //
    }

    int tilt_up()
    {
    digitalWrite(A5, LOW); //
    digitalWrite(A4, LOW); //

    digitalWrite(A0, HIGH); //
    digitalWrite(7, LOW); //
    }

    int tilt_down()
    {
    digitalWrite(A5, LOW); //
    digitalWrite(A4, LOW); //

    digitalWrite(A0, LOW); //
    digitalWrite(7, HIGH); //
    }

     

    The current issue I’m having is with PGOOD which is for some reason hovering around 1V instead of 2.2V. When I remove the PGOOD test things appear to work.

    Here is the resin print, it’s not bad! I think I will turn the top arm outwards so that no matter what happens the machine won’t destroy itself (at least during the testing phase).

    And here is with the board attached:

    And here is a video of the thing rotating:

    P1000390

    PGOOD is not working so I’m just making the code test the voltage of the capacitor when it wakes up. I’ve also added a motor_stop() function because I forgot to stop the motors turning during the time consuming voltage checking functions. This appears to work.

    void loop()
    {
    if(((int)cap_voltage_read()) > 410)

    // this is 1/3 – 20K/10K R divider of 2.7V out of a 2.2V LDO scale, mapped into 1023
    {
    evaluate_east_west();
    evaluate_north_south();
    }
    }

    I was noticing that there was considerable leakage from the capacitor without serious sun. I decided this was probably from having the motor driver sleep pin connected to PGOOD. I have disconnected PGOOD from the micro-controller, and now used that pin to turn on and off the motor sleep. If this doesn’t solve the problem the other candidate is the leakage from the resistor divider which could be replaced by a mosfet as per the JeeLabs zero current measuring post. This would require another pin from the microchip and a bit more space on my already crammed board…

    (The next version of this board may need to be manufactured at a board house, not being able to easily make two sided boards is becoming very frustrating. I also want to use the fancy RF connectors and antennae I ordered.)

    Hunting for the cause of the leaking current. The voltage seems to stabilize at 1.29V, not sure what that tells us though..

    I’m using our super fancy Keithley DMM7510 7 1/2 Digit Multimeter. Check it out:

    I added sleep mode to the code and now once the voltage hits 2.6V it stays essentially stable. (The motor driver uses 1.6-2.5uA @ 5V, the atmega 328p 1uA @ 3V, and the 3V/30K voltage divider draws 100uA.)

    Already mentioned blog posts from Jeelabs on measuring battery voltage:

    https://jeelabs.org/2013/05/15/what-if-we-want-to-know-the-battery-state/

    https://jeelabs.org/2013/05/16/measuring-the-battery-without-draining-it/

    https://jeelabs.org/2013/05/17/zero-powe-battery-measurement/

    I’m wondering if I want to make things easier and have four mini solar panels and two comparators like this (http://www.ti.com/lit/ds/sbos589/sbos589.pdf) so that only two pins are required to determine which direction to move in. I could also possibly use the BEAM solarbotics “suspended bicore” solution (http://www.beam-online.com/Robots/Circuits/circuits.html#Phototropic%20Bicore).

    There is a flaw in my system, if suddenly the sun comes out at the perfect time, the robot can think that turning away from the sun led to finding more sun whereas in fact it was just the sun that changed. I could solve this by having the robot do multiple experiments before committing to actually changing its angle. 

    I should also include in the code a moment where the machine decides if the difference between the past and current reading is sufficiently great to necessitate moving. 

    I have another problem. There is some give in the gearmotors, therefore they do not turn the same amount when they switch directions. This is bad but it’s critical when combined with the code not working very well. This is more an issue for the tilt motor, so if I could replace this with an earlier design rotating a metal rod and using a mast to take the weight of the board perhaps that would solve my problem. 

    I’m hoping I wouldn’t need these: https://www.pololu.com/product/4761…

    Just realized my code is not doing what I want it to do. The integral() function is absolute, it is adding bigger and bigger numbers instead of looking at the difference between relative values…Fixed this. 

    I find the machine spends a lot of time moving back and forth between the same positions. It is rarely deciding that a new orientation is better than an old. I should get the radio set up so I can see the values that are being sent.

    I also need to replace the tilt mechanism with one that holds the weight of the board like the mast/rotation system I tried earlier. I should also do east/west rotation before moving on to doing both axes at once.

    Did a quick test, analogRead() has 10 bit resolution, giving a value between 0-1023. The resolution is barely good enough for taking a reading every 10 seconds and seeing a dropping voltage value in the cap. I think I should be taking measurements every few minutes to be able to detect a difference in charging. 

    I think I need to turn the radio off for long delays, otherwise it doesn’t work. I’m trying radio.sleep(). 

    I also realized it would make far more sense to sense the solar panel voltage rather than the capacitor voltage to sense the solar aspect. However this would add another input pin…

    *I think I might need to update the below code to include the floor() function which stops arduino from rounding? https://www.nongnu.org/avr-libc/user-manual/group__avr__math.html#ga0f0bf9ac2651b80846a9d9d89bd4cb85

    Here is the far from optimal code so far:

    // Include the RFM69 and SPI libraries:
    #include <SPI.h>
    #include <avr/wdt.h>
    #include <RFM69.h>
    #include <avr/sleep.h>
    #include “LowPower.h”

    // Addresses for this node. CHANGE THESE FOR EACH NODE!

    #define NETWORKID 0 // Must be the same for all nodes
    #define MYNODEID 2 // My node ID
    #define TONODEID 1 // Destination node ID

    // RFM69 frequency, uncomment the frequency of your module:

    //#define FREQUENCY RF69_433MHZ
    #define FREQUENCY RF69_915MHZ

    // AES encryption (or not):

    #define ENCRYPTKEY “TOPSECRETPASSWRD” // Use the same 16-byte key on all nodes

    // Use ACKnowledge when sending messages (or not):

    #define USEACK true // Request ACKs or not

    // Packet sent/received indicator LED (optional):

    #define LED A3 // LED positive pin

    #define PGOOD 3 // PGOOD

    #define MOSFET 9//

    // Create a library object for our RFM69HCW module:

    const int cap_voltage = A2;
    const int delay_time = 100; //30 x delay_time (?) is how long it takes to take an integral of cap voltage
    const int long_delay_time = 7000; //30 x delay_time (?) is how long it takes to take an integral of cap voltage

    double T;

    const int motor_sleep = 3;
    const int motor_time = 200;

    int current_reading;
    int last_reading;

    RFM69 radio;

    void setup()
    {
    // Open a serial port so we can send keystrokes to the module:

    pinMode(LED,OUTPUT);
    digitalWrite(LED,LOW);
    pinMode(MOSFET,OUTPUT); //mosfet
    // pinMode(PGOOD, INPUT); // PGOOD

    // motor driver pins
    pinMode(A4, OUTPUT);
    pinMode(A5, OUTPUT);

    pinMode(A0, OUTPUT);
    pinMode(7, OUTPUT);

    pinMode(motor_sleep, OUTPUT);
    pinMode(cap_voltage, INPUT); //

    }

    void loop()
    {

    wdt_enable(WDTO_8S);

    digitalWrite(MOSFET, LOW); // turn off MOSFET

    if(((int)cap_voltage_read()) > 410)
    {
    digitalWrite(motor_sleep, LOW); // sleep motor driver
    Radio_Send(); //includes init and mosfet turn on
    digitalWrite(MOSFET, LOW); // turn off radio

    T = integral();

    Radio_Send();
    digitalWrite(MOSFET, LOW); // turn off MOSFET
    evaluate_east_west();
    }
    else
    {
    digitalWrite(motor_sleep, LOW); // sleep motor driver
    digitalWrite(MOSFET, LOW); // turn off MOSFET
    sleep(); // sleep microchip
    }
    }

    int evaluate_east_west()
    {
    last_reading = integral();
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    motors_off(); //also sleeps driver
    wait_long();
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    clockwise();
    delay(motor_time);
    motors_off();
    current_reading = integral();
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset

    if(last_reading>=current_reading) // move back if less sun in new position
    {
    counter_clockwise();
    delay(motor_time);
    motors_off();
    }
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset

    wait_long();

    last_reading = integral();
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    counter_clockwise();
    delay(motor_time);
    motors_off();
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    delay(long_delay_time);
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    current_reading = integral();
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset

    if(last_reading>=current_reading) // move back if less sun in new position
    {
    clockwise();
    delay(motor_time);
    motors_off();
    }
    digitalWrite(motor_sleep, LOW);
    }

    int Radio_Send()
    {
    char Tstr[10];

    digitalWrite(MOSFET, HIGH); // turn on MOSFET
    delay(100);
    radio.initialize(FREQUENCY, MYNODEID, NETWORKID);
    radio.setHighPower(); // Always use this for RFM69HCW

    // Turn on encryption if desired:

    radio.encrypt(ENCRYPTKEY);

    char buffer[50];

    dtostrf(T, 5,5, Tstr);

    static int sendlength = strlen(buffer);

    sprintf(buffer, ” T:%s”, Tstr);

    radio.sendWithRetry(TONODEID, buffer, sendlength);

    Blink(LED,100);

    }

    int integral()
    {
    int integral_0;
    int integral_1;

    //int integral_total;

    int integral_total_1;

    integral_0 = (int)cap_voltage_read(); // convert to int
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    wait_long();
    wait_long();
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    integral_1 = (int)cap_voltage_read(); // convert to int
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset

    integral_total_1 = integral_1 – integral_0;

    return integral_total_1;
    }

    int cap_voltage_read()
    {
    float cap_reading_0;
    float cap_reading_1;
    float cap_reading_2;
    float cap_reading_3;
    float cap_reading_4;

    float cap_reading_average;

    cap_reading_0 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_1 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_2 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_3 = analogRead(cap_voltage);
    delay(delay_time);
    cap_reading_4 = analogRead(cap_voltage);
    delay(delay_time);

    return cap_reading_average = (cap_reading_0 + cap_reading_1 + cap_reading_2 + cap_reading_3 + cap_reading_4) / 5;
    }

    void Blink(byte PIN, int DELAY_MS)
    // Blink an LED for a given number of ms
    {
    digitalWrite(PIN,HIGH);
    delay(DELAY_MS);
    digitalWrite(PIN,LOW);
    }

    void sleep(void)
    {
    digitalWrite(MOSFET, LOW); // turn on MOSFET
    set_sleep_mode(SLEEP_MODE_PWR_DOWN); //select PWR DOWN, the most power savings
    sleep_enable(); //set SE bit
    sei(); // enable global interrupts
    sleep_cpu(); //actually sleep
    sleep_disable(); //code reaches this point after interrupt
    }

    int motors_off()
    {
    digitalWrite(motor_sleep, LOW); //put driver to sleep
    digitalWrite(A5, LOW); //
    digitalWrite(A4, LOW); //

    digitalWrite(A0, LOW); //
    digitalWrite(7, LOW); //
    }

    int clockwise()
    {
    digitalWrite(motor_sleep, HIGH); //wake up driver
    digitalWrite(A5, HIGH); //
    digitalWrite(A4, LOW); //

    digitalWrite(A0, LOW); //
    digitalWrite(7, LOW); //
    }

    int counter_clockwise()
    {
    digitalWrite(motor_sleep, HIGH); //wake up driver
    digitalWrite(A5, LOW); //
    digitalWrite(A4, HIGH); //

    digitalWrite(A0, LOW); //
    digitalWrite(7, LOW); //
    }

    int tilt_up()
    {
    digitalWrite(motor_sleep, HIGH); //wake up driver
    digitalWrite(A5, LOW); //
    digitalWrite(A4, LOW); //

    digitalWrite(A0, HIGH); //
    digitalWrite(7, LOW); //
    }

    int tilt_down()
    {
    digitalWrite(motor_sleep, HIGH); //wake up driver
    digitalWrite(A5, LOW); //
    digitalWrite(A4, LOW); //

    digitalWrite(A0, LOW); //
    digitalWrite(7, HIGH); //
    }

    int wait_long()
    {

    for(int i=0;i<10;i++)
    {
    wdt_reset(); // do this before 8 seconds has elapsed so we don’t reset
    digitalWrite(motor_sleep, LOW); //put driver to sleep
    digitalWrite(MOSFET, LOW); // turn off radio MOSFET
    LowPower.idle(SLEEP_4S, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF,
    SPI_OFF, USART0_OFF, TWI_OFF);
    }

    }

    DIY Mini Drone

    For a change, this is a video of me working on the boards for this project:

     

     

    Radios are working, I’m struggling with the best way to poll the joysticks. I think I need to use Pin Change Interrupts (Interrupts for pins other than those dedicated for interrupting). The other option is just to have polling:

    if (UP == HIGH){ Send(UP);}

    if (DOWN == HIGH){ Send(DOWN);}

    etc.

    *Later realized that I messed this up, what I want is to check if the pin is LOW (i.e. if it is connected to ground and not internally pulled up) and then have an else at the end which turns to HIGH.

    *I forgot to put pull-up resistors on the actual board so I used the avr’s internal ones. In arduino you do this like so:

    pinMode(A0, INPUT_PULLUP);

    I reprinted the drone frame with .1mm extra space around the circle and now the motors fit snuggly. 

    Dissapointed that the joysticks only register an up or down when also pushed down…

    Here is the joystick sending code:

    ********************************************************************************

    // RFM69HCW Example Sketch
    // Send serial input characters from one RFM69 node to another
    // Based on RFM69 library sample code by Felix Rusu
    // http://LowPowerLab.com/contact
    // Modified for RFM69HCW by Mike Grusin, 4/16

    // This sketch will show you the basics of using an
    // RFM69HCW radio module. SparkFun’s part numbers are:
    // 915MHz: https://www.sparkfun.com/products/12775
    // 434MHz: https://www.sparkfun.com/products/12823

    // See the hook-up guide for wiring instructions:
    // https://learn.sparkfun.com/tutorials/rfm69hcw-hookup-guide

    // Uses the RFM69 library by Felix Rusu, LowPowerLab.com
    // Original library: https://www.github.com/lowpowerlab/rfm69
    // SparkFun repository: https://github.com/sparkfun/RFM69HCW_Breakout

    // Include the RFM69 and SPI libraries:

    #include <RFM69.h>
    #include <SPI.h>

    // Addresses for this node. CHANGE THESE FOR EACH NODE!

    #define NETWORKID 0 // Must be the same for all nodes (0 to 255)
    #define MYNODEID 1 // My node ID (0 to 255)
    #define TONODEID 2 // Destination node ID (0 to 254, 255 = broadcast)

    // RFM69 frequency, uncomment the frequency of your module:

    //#define FREQUENCY RF69_433MHZ
    #define FREQUENCY RF69_915MHZ

    // AES encryption (or not):

    #define ENCRYPT true // Set to “true” to use encryption
    #define ENCRYPTKEY “TOPSECRETPASSWRD” // Use the same 16-byte key on all nodes

    // Use ACKnowledge when sending messages (or not):

    #define USEACK true // Request ACKs or not

    // joystick and leds

    #define LED1 A0 // LED positive pin
    #define UP1 A2//
    #define LEFT1 A3//
    #define RIGHT1 A4//
    #define DOWN1 A5//

    #define LED2 A1 // LED positive pin
    #define UP2 8//
    #define LEFT2 9//
    #define RIGHT2 7//
    #define DOWN2 6//

    // Create a library object for our RFM69HCW module:
    RFM69 radio;

    void setup()
    {
    // leds and joystick init

    pinMode(LED1,OUTPUT);
    pinMode(LED2,OUTPUT);

    pinMode(UP1,INPUT_PULLUP);
    pinMode(LEFT1,INPUT_PULLUP);
    pinMode(RIGHT1,INPUT_PULLUP);
    pinMode(DOWN1,INPUT_PULLUP);

    pinMode(UP2,INPUT_PULLUP);
    pinMode(LEFT2,INPUT_PULLUP);
    pinMode(RIGHT2,INPUT_PULLUP);
    pinMode(DOWN2,INPUT_PULLUP);

    // Initialize the RFM69HCW:

    radio.initialize(FREQUENCY, MYNODEID, NETWORKID);
    radio.setHighPower(); // Always use this for RFM69HCW

    // Turn on encryption if desired:

    if (ENCRYPT)
    radio.encrypt(ENCRYPTKEY);
    }

    void loop()
    {
    //setting up variables for button states

    int sensorVal0 = digitalRead(UP1);
    int sensorVal1 = digitalRead(LEFT1);
    int sensorVal2 = digitalRead(RIGHT1);
    int sensorVal3 = digitalRead(DOWN1);
    int sensorVal4 = digitalRead(UP2);
    int sensorVal5 = digitalRead(LEFT2);
    int sensorVal6 = digitalRead(RIGHT2);
    int sensorVal7 = digitalRead(DOWN2);

    // SENDING

    // In this section, we’ll gather serial characters and
    // send them to the other node if we (1) get a carriage return,
    // or (2) the buffer is full (61 characters).

    // If there is any serial input, add it to the buffer:

    char buffer[5] = “z”;

    //BUTTON READING AND SENDING

    if (sensorVal0 == LOW) {
    buffer[0] = ‘a’;
    digitalWrite(LED2, HIGH);
    }

    else if (sensorVal1 == LOW) {
    buffer[0] = ‘b’;
    digitalWrite(LED2, HIGH);
    }

    else if (sensorVal2 == LOW) {
    buffer[0] = ‘c’;
    digitalWrite(LED2, HIGH);
    }

    else if (sensorVal3 == LOW) {
    buffer[0] = ‘d’;
    digitalWrite(LED2, HIGH);
    }

    else if (sensorVal4 == LOW) {
    buffer[0] = ‘e’;
    digitalWrite(LED1, HIGH);
    }

    else if (sensorVal5 == LOW) {
    buffer[0] = ‘f’;
    digitalWrite(LED1, HIGH);
    }

    else if (sensorVal6 == LOW) {
    buffer[0] = ‘g’;
    digitalWrite(LED1, HIGH);
    }

    else if (sensorVal7 == LOW) {
    buffer[0] = ‘h’;
    digitalWrite(LED1, HIGH);
    }

    else {
    buffer[0] = ‘z’;
    digitalWrite(LED2, LOW);
    digitalWrite(LED1, LOW);
    }

    // END OF BUTTON STUFF

    if(buffer[0]!=’z’)
    {

    static int sendlength = 3;

    radio.sendWithRetry(TONODEID, buffer, sendlength);
    }

    }

    ********************************************************************************

     

    And here is the receiver code:

     

    *********************************************************************************

    // RFM69HCW Example Sketch
    // Send serial input characters from one RFM69 node to another
    // Based on RFM69 library sample code by Felix Rusu
    // http://LowPowerLab.com/contact
    // Modified for RFM69HCW by Mike Grusin, 4/16

    // This sketch will show you the basics of using an
    // RFM69HCW radio module. SparkFun’s part numbers are:
    // 915MHz: https://www.sparkfun.com/products/12775
    // 434MHz: https://www.sparkfun.com/products/12823

    // See the hook-up guide for wiring instructions:
    // https://learn.sparkfun.com/tutorials/rfm69hcw-hookup-guide

    // Uses the RFM69 library by Felix Rusu, LowPowerLab.com
    // Original library: https://www.github.com/lowpowerlab/rfm69
    // SparkFun repository: https://github.com/sparkfun/RFM69HCW_Breakout

    // Include the RFM69 and SPI libraries:

    #include <SPI.h>
    #include <RFM69.h>

    // Addresses for this node. CHANGE THESE FOR EACH NODE!

    #define NETWORKID 0 // Must be the same for all nodes
    #define MYNODEID 2 // My node ID
    #define TONODEID 1 // Destination node ID

    // RFM69 frequency, uncomment the frequency of your module:

    //#define FREQUENCY RF69_433MHZ
    #define FREQUENCY RF69_915MHZ

    // AES encryption (or not):

    #define ENCRYPT true // Set to “true” to use encryption
    #define ENCRYPTKEY “TOPSECRETPASSWRD” // Use the same 16-byte key on all nodes

    // Use ACKnowledge when sending messages (or not):

    #define USEACK true // Request ACKs or not

    // Packet sent/received indicator LED (optional):

    #define LED 1 // LED positive pin

    // Create a library object for our RFM69HCW module:

    RFM69 radio;

    void setup()
    {
    // Open a serial port so we can send keystrokes to the module:

    pinMode(LED,OUTPUT);
    digitalWrite(LED,LOW);

    radio.initialize(FREQUENCY, MYNODEID, NETWORKID);
    radio.setHighPower(); // Always use this for RFM69HCW

    if (ENCRYPT)
    radio.encrypt(ENCRYPTKEY);

    }

    void loop()
    {

    // RECEIVING

    // In this section, we’ll check with the RFM69HCW to see
    // if it has received any packets:

    if (radio.receiveDone()) // Got one!
    {
    // Print out the information:

    // The actual message is contained in the DATA array,
    // and is DATALEN bytes in size:

    // char message = radio.DATA[0];

    // RSSI is the “Receive Signal Strength Indicator”,
    // smaller numbers mean higher power.

    // Send an ACK if requested.
    // (You don’t need this code if you’re not using ACKs.)

    if (radio.ACKRequested())
    {
    radio.sendACK();
    }
    Blink(LED,10);
    }

    }

    void Blink(byte PIN, int DELAY_MS)
    // Blink an LED for a given number of ms
    {
    digitalWrite(PIN,HIGH);
    delay(DELAY_MS);
    digitalWrite(PIN,LOW);
    }

    *********************************************************************************

     

    Now just waiting for some new pager motors to arrive…

    I’ve got some old drones which I have taken apart for batteries, motors and propellers. The motors are slightly larger to I have redesigned the 3D print. The motors are 8.5mm in diameter and I found that subtracting with an 8.8mm cylinder make for the snuggest fit.

    Binary Visualizing

    Using the tool bin vis, which simply assigns a shade of grey for each byte in a file, it’s possible to represent the structure of pieces of a file. Check it out, these are found 3D files from various software programs:

     

    Found a cool surprise when I uploaded a .BMP file, the bytes map almost perfectly onto the image;

    I want to try other uncompressed formats like RAW. Loading PNGs and JPEGs are uninteresting so far, they are just noise.

    I have tried some experiments processing this data. These stem from the observation that changing the width of the viewing window, which causes the binary data to wrap around the screen, changes the representation of the data dramatically. 

    In this experiment I tried to adjust the window of the binary visualizing screen to get the data to make columns, to the extend that this was possible. Some of this info must repeat at a point in the middle of a byte and therefore not map onto a grid of pixels perfectly (?).

    Here is an attempt to isolate just the modules which repeat in the above image and to display only them;

    I am imagining a program which goes through the file and figures out the proper width for each chunk of data so that this process can be automated. 

    Some experiments I would like to try:

    -what does the same form look like (say, a sphere) in different software formats?

    -is it possible to identify which part of the binary file links up with which part of the 3D file? Could you isolate the repeating element and figure out exactly what it’s composed of?

    -what are the similarities and differences between different 3D objects saved by the same software? (I.e. what is the software grain?)

    -what do the Rhino.exe, Adobe Illustrator.exe and Revit.exe files look like?

    -show a before and after compression image.

    -somehow look at a program’s operation by examining it’s buffer memory live somehow?

    and here’s the view of just the pixels in the same file just changing the window width:

    Essentially each eight bits (eg. 01101001) are transformed into a pixel with a value of grey between black (0) and white (255):

    I just visited the Glasgow Botanical Garden and watched the film Aquarela. Both experiences reminded me about the diversity of patterns and permutation of simple rules at play in the cosmos.

    Image result for aquarela film"Image result for aquarela film"

    Aquerela (2019) Screenshot

    Image result for botanical garden glasgow"

    Glasgow botanical gardens (image from http://martinbrookes.blogspot.com/2018/06/the-botanical-gardens-glasgow.html)

     

    Looking at a Rhino file in a text editor you get that same “grain” feel as with bin vis:

    this is from https://developer.rhino3d.com/api/RhinoCommon/html/N_Rhino_FileIO.htm

    but there is also: https://developer.rhino3d.com/guides/#opennurbs

    It would seem a lot easier to start with a file format that is ASCII encoded though…

    This is a RAW file opened in binview, it has several images contained in it, one for each color channel I guess:

     

    Here is a Bitmap file saved with interleave:

    An IGS file format, ASCII readable, visualized. Pretty boring unfortunately.

    I found a head inside an example Rhino file :D!

    Some tests with a single image saved in different formats:

     

    Sphere test:

    Cube test:

    Zooming in to some patterns:

    Some patterns I found in 3D files (would be cool to compare to image file observations!):

    With red to help identify the patterns:

    For comparison here are some samples from image files:

    Comparing an all white vs. all black file:

    Next experiment is to copy and paste pieces of one file into others. Possibly from a compressed file into a raw file! (Wait – why?)

    Insight into what we’re seeing in these files: http://www.rumint.org/gregconti/publications/taxonomy-bh.pdf

    when things line up into a structure, data is fixed length. When things don’t line up we get variable length data chunks. Repeating values seem to help align data regions. Nois is encrypted in some way typically which has scrambled the structure. 

    *****

    The problem with this visualization is that it does not represent TIME, like my other ones. It would be cool to stretch and compress these images based on the speed with which the files were written somehow. 

    **************

    Update: This software called HeapMemory (https://www.nirsoft.net/utils/heap_memory_view.html) allows you to see memory created by active programs. You can output the data and then visualize it with binvis. If you did this regularly while you worked on a 3D model, you could have a representation of the file you’re working on through the eyes of the computer program. 

    Here is a gif of a rhino operation and the change in the 3dm file:

    and here’s a timelapse of a rhino file with transformations taking place:

    UPSI Lecture Prep

     

    To “present my projects or any other insights on digital fabrication, education and architecture.” The context; “The class is the second part of an intensive course on 3d modelling and CNC milling to make an 1:1 architectural structure based on simple modules.”

    Here are some questions I could respond to: What are the seams, the gaps, and the moments of translation, between various subsystems in our contemporary digital design workflow?
    How has software engineering culture given form to our software?
    How does the computer internally represent our work – how does it “see” our design files and “understand” our design work?
    Does software have a “grain”, just like wood and other materials? What is the ontology of Revit and what is the world according to Rhino 3D, for instance?
    Do technological artifacts, and the objects that designers make, have innate force in themselves, as Bruno Latour and Jane Bennett seem to suggest?

    I am planning a revised lecture from my UdK workshop. I would also like to present some new research but my compression research is not leading to a tangible visualization yet, I need to ask for help from programmers to accelerate this process perhaps. The other solution appears to be to go towards simpler technology from further back in history. This has the added bonus of me not working on visualizing something that a million other people are already working on as with image compression visualization. Taking a look at my map of gaps diagram…

    I would like to make a GIF of the Revit startup elements. I also want to incorporate Schlossman lecture material like the number of software programs that used to exist that have all been eaten by Autodesk:

    OMG here is the mother lode for all things memory visualization, this is incredibly impressive: https://reverseengineering.stackexchange.com/questions/6003/visualizing-elf-binaries

    downloaded bin vis from this link, it has an .exe in the debug file: http://www.rumint.org/gregconti/publications/binviz_0.zip

    I could use the techniques from the following video to compare Rhino to Revit live, or look at types of files that architects use. At the very least I could make a nice slide showing the “grain” of these different programs! I could also make the argument that because computers are so much faster than us, they can see more data at a time than we can and therefore it looks to them like watching an image (I could get the speed of their reading to equal the number of pixels we can see at a given time). 

    Here is a lecture which outlines the method of mapping binary to pixel shades and how you can begin to identify species of data: https://www.youtube.com/watch?v=h68VS7lsNfE

    keywords:

    memory map, visual reverse engineering

    https://reverseengineering.stackexchange.com/questions/6003/visualizing-elf-binaries:

    word document:

    Windows PE visualization

    Documents Format Files

    enter image description here

    enter image description here

    pdf:

    http://actinid.org/vix/

    http://binvis.io/

    …I could look at things like scanners, or floppy disks?

     

    In the illustration above, you can see how the disk is divided into tracks (brown) and sectors (yellow).