Euklidischer Sequencer (mit Klangbeispiel)

[PySeq]

Hi,

wie sind Musiker auf die tollen Rhythmus-Sequenzen in Synth-Pop- oder Trance-Stücken gekommen, auf lebendig klingende Percussion- und Basslinien? - Das habe ich mich schon immer gefragt. Mit diesem Thema könnte man der Antwort vielleicht näher kommen.
Man kann einen Algorithmus des alten Griechen Euklid dazu benutzen, um Noten in einem Taktraster so gleichmäßig wie möglich zu verteilen. Was sich manchmal rhythmisch schön anhören kann, so daß man damit schöne Polyrhythmen erzeugen kann.
Will man z.B. 4 Noten auf 16 Stellen möglichst gleichmäßig verteilen (man denke an 1/16tel in einem Sequencer), dann hätte man die "Four on the Floor", binär also "1000 1000 1000 1000" (ich mache mal willkürlich 4er-Blöcke zur besseren Lesbarkeit).
Interessanter wird es bei "krummeren" Werten wie z.B. 3 Noten auf 16 Stellen. Dann hätte man laut Algorithmus "1000 0100 0010 0000". Das könnte man für Percussion nutzen oder auch für Synth-Basslinien. Und man kann die Werte verschieben, z.B. um 1. Dann hätte man im Beispiel, also "3 auf 16, um 1 verschoben": "0100 0010 0001 0000".
Und man kann mehrere solcher Sequenzen übereinanderlegen.
Der Witz ist, daß sich das (wie gesagt) manchmal schön anhören kann, und man auf diese Weise offenbar an die tollen Polyrhythmen kommt, die man aus vielen Stücken kennt.

VSTs, die das alles auch noch grafisch darstellen sind "Euclidean Sequencer Pro" - aber nur für Ableton, das ich nicht habe. Außerhalb von Ableton gibt es "HY-RPE2" (kommerziell), und von denen auch noch ein kostenloses kleineres Gate-Teil. Außerdem noch "Euklid" (Freeware).
Das sind also Plugins, die Midi senden. Irgendwie funktioniert das damit bei mir alles nur so leidlich.
Also dachte ich, kann man das nicht auch einfach von Hand machen?

Aus diesem Video


https://www.youtube.com/watch?v=11bv8bcva3k

hab' ich die Binärwerte rausgeschrieben für das, was da gezeigt wurde. Ich habe also:

- 3 auf 16: "1000 0100 0010 0000"
- 7 auf 16: "1010 1010 0101 0100"
- 10 auf 16: "1101 1010 1101 1010"

- 5 auf 12: "1010 1001 0100"

Wie gesagt, kann man diese Binärdaten dann auch verschieben, z.B. um 1 Stelle oder um 2.

Das ist schonmal was. Damit konnte ich die Stelle im Video von 08:30 nachstellen. Ich füge mal ein mp3 an. Klingt ein bißchen wie Erasure, finde ich. Ist doch nicht schlecht!

Was ich gern hätte, wären alle Binärwerte (im Format wie oben) für alle gängigen Fälle. Ja gut, Manches wäre ja gar nicht so interessant, "2 auf 16" oder "4 auf 16" z.B.. Und bei über 10 wird es eigentlich auch schon zu voll im Takt. Wahrscheinlich kann ich auch das Plugin "Euklid" oben nutzen, um die Werte zu finden. Aber wäre trotzdem schön, wenn ihr noch was dazu posten würdet, was euch aufgefallen ist.

Viele Grüße

PySeq

 

[betadecay]

Das hier mal als Ergänzung zum Thema:

Understanding Euclidean Rhythms

Here’s an easy to understand discussion of Euclidean Rhythms – a way of using math to describe beats that are distributed as evenly as possible, and how this is a feature of many common…

www.synthtopia.com

 

[mooncast]

ich bin in dem Thema nicht mehr drin aber ich hatte das mal gemacht und es war
relativ simpel, und man kann das dann in ner Handvoll Tabellen unterbringen,
es gibt gar nicht so viele Variation (weswegen es auch schnell langweilig und vorhersehbar wird).
Wenn du zufäliig auch Reaktor hast wirst du da sicher auch ein paar Umsetzungen finden.

Die Patterns sind brauchbar aks Grundgerüst, das man dann editieren muss damits interessant wird, sonst bleibt es das Equivalent von 4/4 Basedrum Beat was Musikalität an geht.

 

[Cosmo Profit]

In einem Modularsytem ganz schön, wenn man ein Element auf die Schnelle rhythmisieren will, 2 Drehs und es groovt.
Aber wie schon geschrieben, die Vielfalt verwertbarer Patterns hält sich in Grenzen, es ist also etwas,
was man auch in sein Repertoire übernehmen kann / sollte und bei Bedarf auch flott in den Sequenzer programmieren oder gar einspielen kann.
Klar, durch die Verschiebungsmöglichkeiten wird es nochmal mehr, aber wenn man das Prinzip dahinter etwas verinnerlicht hat, braucht man eigentlich keine Tabellen.
Aber zum probieren und zum Entdecken schöner Patterns eine schöne Sache.

 

[einseinsnull]

oben nutzen, um die Werte zu finden. Aber wäre trotzdem schön, wenn ihr noch was dazu posten würdet, was euch aufgefallen ist.

ich finde die frage falsch.

die frage sollte umgekehrt eher lauten: "wie kam jemand auf die idee, einen euklid sequencer zu bauen?"

die antwort würde dann lauten: "das prinzip kommt aus afrika, wo schon seit mehreren tausend jahren beats genau so gebaut werden."

Was ich gern hätte, wären alle Binärwerte (im Format wie oben) für alle gängigen Fälle

das kann man machen, dass man das in eine tabelle schreibt, aber im grunde genommen kannst du es genauso gut in dem moment ausrechnen wo du es brauchst - vor allem dann, wenn du bis 16 oder darüber hinaus gehst, denn dann wird so eine tabelle relativ groß.

ich mach das bis 64^^

du suchst bjorklund distribution oder brensenham line algorithm.

 

[einseinsnull]

ach so, du willst das wegen deinem "von hand machen". bis 8 gibt es das bestimmt irgenwo im netz (?) oder du missbrauchst eines der plug-ins dafür dir das selbst zu exportieren.

 

[PySeq]

Z.B. diese Verschiebungen wären in einer Programmiersprache relativ leicht zu machen (list.pop(), list.insert(0, element)). Zur Zeit mache ich mit Cakewalk als DAW rum (es ist kostenlos und wie ich finde gar nicht schlecht). Kann sein, daß ich da mal was in dieser antiken Sprache "cal script" baue, vielleicht könnte man damit per Makro Noten in den Stepsequenzer eintragen. Ein VST zu programmieren, wäre glaube ich zu viel, das hab' ich auch noch nie gemacht. Schau'n wir mal.

 

[einseinsnull]

wenn du ein midi plug-in step sequencer hättest, bei dem man "start" zur host synchronisieren kann aber das tempo frei einstellen kann, dann könntest du mehrere instanzen davon benutzen und die sequenzen einfach als preset/bank abspeichern. auswendig kenn ich jetzt auch keines, schon gar nicht für windows or linux. aber mit ->plugdata wären das nur ein paar handgriffe.


was mir noch einfällt:

- 5 auf 12: "1010 1001 0100"

je nach algorithmus können unterschiedliche muster entstehen, die je nach x aus y stehts unterschiedlich verdreht zueinander stehen.

das ist allerdings realtiv egal, da der beginn musikalisch egal ist.

sie fangen aber immerhin alle mit einer 1 an, was irgendwie irritert, weil auch das musikalisch irrelevant ist.


wichtig ist nachher nur, wie man die sequenzen nutzt. denn um die eigenschaft der möglichst gleichförmigen verteilung überhaupt zu erreichen, muss man so eine sequenz natürlich grundsätzlich mindestens einmal - oder mehrfach - komplett durchspielen und sie nicht mitten drin abbrechen, denn dann verlässt man die idee.

daraus ergibt sich automatisch, dass man verhindern muss, dass die einstellungen zu einem anderen zeitpunkt geändert werden als zu beginn einer sequenz.


und dann gibt es noch eines zu sagen zu dem thema: du kannst die dinger nicht nur rotieren, du kannst sie auch vorwärts und rückwärts abspielen.

bei einer richtungsänderung bleibt ja die eigenschaft wie die schläge verteilt sind auch immer erhalten.

neben der rotation ist die spiegelung also gerne der vierte parameter des sytems - und der zweite, der genau wie die rotation natürlich gerne auch auf das gleiche x aus y angewendet werden könnte wie auf einer anderen spur auch bereits verwendet wurde.

 

[einseinsnull]

so ich mach dir grad mal, momentele.

 

[einseinsnull]

jetzt bist du vergessen worden. da kam neulich nachts ein stück @apfelkuchen dazwischen, das war einfach wichtiger als @PySeq

Spoiler

1, 0;
2, 1;
3, 0 0;
4, 1 0;
5, 1 1;
6, 0 0 0;
7, 1 0 0;
8, 1 0 1;
9, 1 1 1;
10, 0 0 0 0;
11, 1 0 0 0;
12, 1 0 1 0;
13, 1 0 1 1;
14, 1 1 1 1;
15, 0 0 0 0 0;
16, 1 0 0 0 0;
17, 1 0 0 1 0;
18, 1 0 1 0 1;
19, 1 0 1 1 1;
20, 1 1 1 1 1;
21, 0 0 0 0 0 0;
22, 1 0 0 0 0 0;
23, 1 0 0 1 0 0;
24, 1 0 1 0 1 0;
25, 1 0 1 1 0 1;
26, 1 0 1 1 1 1;
27, 1 1 1 1 1 1;
28, 0 0 0 0 0 0 0;
29, 1 0 0 0 0 0 0;
30, 1 0 0 0 1 0 0;
31, 1 0 0 1 0 1 0;
32, 1 0 1 0 1 0 1;
33, 1 0 1 1 0 1 1;
34, 1 0 1 1 1 1 1;
35, 1 1 1 1 1 1 1;
36, 0 0 0 0 0 0 0 0;
37, 1 0 0 0 0 0 0 0;
38, 1 0 0 0 1 0 0 0;
39, 1 0 0 1 0 0 1 0;
40, 1 0 1 0 1 0 1 0;
41, 1 0 1 0 1 1 0 1;
42, 1 0 1 1 1 0 1 1;
43, 1 0 1 1 1 1 1 1;
44, 1 1 1 1 1 1 1 1;
45, 0 0 0 0 0 0 0 0 0;
46, 1 0 0 0 0 0 0 0 0;
47, 1 0 0 0 0 1 0 0 0;
48, 1 0 0 1 0 0 1 0 0;
49, 1 0 0 1 0 1 0 1 0;
50, 1 0 1 0 1 0 1 0 1;
51, 1 0 1 1 0 1 1 0 1;
52, 1 0 1 1 1 0 1 1 1;
53, 1 0 1 1 1 1 1 1 1;
54, 1 1 1 1 1 1 1 1 1;
55, 0 0 0 0 0 0 0 0 0 0;
56, 1 0 0 0 0 0 0 0 0 0;
57, 1 0 0 0 0 1 0 0 0 0;
58, 1 0 0 0 1 0 0 1 0 0;
59, 1 0 0 1 0 1 0 0 1 0;
60, 1 0 1 0 1 0 1 0 1 0;
61, 1 0 1 0 1 1 0 1 0 1;
62, 1 0 1 1 0 1 1 0 1 1;
63, 1 0 1 1 1 1 0 1 1 1;
64, 1 0 1 1 1 1 1 1 1 1;
65, 1 1 1 1 1 1 1 1 1 1;
66, 0 0 0 0 0 0 0 0 0 0 0;
67, 1 0 0 0 0 0 0 0 0 0 0;
68, 1 0 0 0 0 0 1 0 0 0 0;
69, 1 0 0 0 1 0 0 0 1 0 0;
70, 1 0 0 1 0 0 1 0 0 1 0;
71, 1 0 0 1 0 1 0 1 0 1 0;
72, 1 0 1 0 1 0 1 0 1 0 1;
73, 1 0 1 0 1 1 0 1 1 0 1;
74, 1 0 1 1 0 1 1 1 0 1 1;
75, 1 0 1 1 1 1 0 1 1 1 1;
76, 1 0 1 1 1 1 1 1 1 1 1;
77, 1 1 1 1 1 1 1 1 1 1 1;
78, 0 0 0 0 0 0 0 0 0 0 0 0;
79, 1 0 0 0 0 0 0 0 0 0 0 0;
80, 1 0 0 0 0 0 1 0 0 0 0 0;
81, 1 0 0 0 1 0 0 0 1 0 0 0;
82, 1 0 0 1 0 0 1 0 0 1 0 0;
83, 1 0 0 1 0 1 0 0 1 0 1 0;
84, 1 0 1 0 1 0 1 0 1 0 1 0;
85, 1 0 1 0 1 0 1 1 0 1 0 1;
86, 1 0 1 1 0 1 1 0 1 1 0 1;
87, 1 0 1 1 1 0 1 1 1 0 1 1;
88, 1 0 1 1 1 1 0 1 1 1 1 1;
89, 1 0 1 1 1 1 1 1 1 1 1 1;
90, 1 1 1 1 1 1 1 1 1 1 1 1;
91, 0 0 0 0 0 0 0 0 0 0 0 0 0;
92, 1 0 0 0 0 0 0 0 0 0 0 0 0;
93, 1 0 0 0 0 0 0 1 0 0 0 0 0;
94, 1 0 0 0 0 1 0 0 0 1 0 0 0;
95, 1 0 0 0 1 0 0 1 0 0 1 0 0;
96, 1 0 0 1 0 0 1 0 1 0 0 1 0;
97, 1 0 0 1 0 1 0 1 0 1 0 1 0;
98, 1 0 1 0 1 0 1 0 1 0 1 0 1;
99, 1 0 1 0 1 1 0 1 0 1 1 0 1;
100, 1 0 1 1 0 1 1 0 1 1 0 1 1;
101, 1 0 1 1 1 0 1 1 1 0 1 1 1;
102, 1 0 1 1 1 1 1 0 1 1 1 1 1;
103, 1 0 1 1 1 1 1 1 1 1 1 1 1;
104, 1 1 1 1 1 1 1 1 1 1 1 1 1;
105, 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
106, 1 0 0 0 0 0 0 0 0 0 0 0 0 0;
107, 1 0 0 0 0 0 0 1 0 0 0 0 0 0;
108, 1 0 0 0 0 1 0 0 0 0 1 0 0 0;
109, 1 0 0 0 1 0 0 1 0 0 0 1 0 0;
110, 1 0 0 1 0 0 1 0 0 1 0 0 1 0;
111, 1 0 0 1 0 1 0 1 0 0 1 0 1 0;
112, 1 0 1 0 1 0 1 0 1 0 1 0 1 0;
113, 1 0 1 0 1 0 1 1 0 1 0 1 0 1;
114, 1 0 1 0 1 1 0 1 1 0 1 1 0 1;
115, 1 0 1 1 0 1 1 1 0 1 1 0 1 1;
116, 1 0 1 1 1 0 1 1 1 1 0 1 1 1;
117, 1 0 1 1 1 1 1 1 0 1 1 1 1 1;
118, 1 0 1 1 1 1 1 1 1 1 1 1 1 1;
119, 1 1 1 1 1 1 1 1 1 1 1 1 1 1;
120, 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
121, 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
122, 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0;
123, 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0;
124, 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0;
125, 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0;
126, 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0;
127, 1 0 0 1 0 1 0 1 0 1 0 1 0 1 0;
128, 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1;
129, 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1;
130, 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1;
131, 1 0 1 1 0 1 1 1 0 1 1 1 0 1 1;
132, 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1;
133, 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1;
134, 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1;
135, 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;
136, 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
137, 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
138, 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0;
139, 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0;
140, 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0;
141, 1 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0;
142, 1 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0;
143, 1 0 0 1 0 1 0 1 0 0 1 0 1 0 1 0;
144, 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0;
145, 1 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1;
146, 1 0 1 0 1 1 0 1 1 0 1 0 1 1 0 1;
147, 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1;
148, 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1;
149, 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1;
150, 1 0 1 1 1 1 1 1 1 0 1 1 1 1 1 1;
151, 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1;
152, 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;

 

[Turing]

In Software mache ich das mit dem kostenlosen HATEFISh RhyGenerator.
Er beherrscht euklidische Sequenzen mit bis zu 32 Steps.
Man kann aber in jeder Lane eine unterschiedliche Basis-Notenlänge einstellen
und so noch komplexere Gebilde bauen, die sich nicht so schnell wiederholen.
Die "abgerollte" Darstellung in Form von Lanes finde ich persönlich wesentlich
übersichtlicher als die Kreisbahn/-segment-Darstellung bei den meisten
anderen euklidischen Sequencern.

 

[Scenturio]

jetzt bist du vergessen worden. da kam neulich nachts ein stück @apfelkuchen dazwischen, das war einfach wichtiger als @PySeq

Spoiler

1, 0;
2, 1;
3, 0 0;
4, 1 0;
5, 1 1;
6, 0 0 0;
7, 1 0 0;
8, 1 0 1;
9, 1 1 1;
10, 0 0 0 0;
11, 1 0 0 0;
12, 1 0 1 0;
13, 1 0 1 1;
14, 1 1 1 1;
15, 0 0 0 0 0;
16, 1 0 0 0 0;
17, 1 0 0 1 0;
18, 1 0 1 0 1;
19, 1 0 1 1 1;
20, 1 1 1 1 1;
21, 0 0 0 0 0 0;
22, 1 0 0 0 0 0;
23, 1 0 0 1 0 0;
24, 1 0 1 0 1 0;
25, 1 0 1 1 0 1;
26, 1 0 1 1 1 1;
27, 1 1 1 1 1 1;
28, 0 0 0 0 0 0 0;
29, 1 0 0 0 0 0 0;
30, 1 0 0 0 1 0 0;
31, 1 0 0 1 0 1 0;
32, 1 0 1 0 1 0 1;
33, 1 0 1 1 0 1 1;
34, 1 0 1 1 1 1 1;
35, 1 1 1 1 1 1 1;
36, 0 0 0 0 0 0 0 0;
37, 1 0 0 0 0 0 0 0;
38, 1 0 0 0 1 0 0 0;
39, 1 0 0 1 0 0 1 0;
40, 1 0 1 0 1 0 1 0;
41, 1 0 1 0 1 1 0 1;
42, 1 0 1 1 1 0 1 1;
43, 1 0 1 1 1 1 1 1;
44, 1 1 1 1 1 1 1 1;
45, 0 0 0 0 0 0 0 0 0;
46, 1 0 0 0 0 0 0 0 0;
47, 1 0 0 0 0 1 0 0 0;
48, 1 0 0 1 0 0 1 0 0;
49, 1 0 0 1 0 1 0 1 0;
50, 1 0 1 0 1 0 1 0 1;
51, 1 0 1 1 0 1 1 0 1;
52, 1 0 1 1 1 0 1 1 1;
53, 1 0 1 1 1 1 1 1 1;
54, 1 1 1 1 1 1 1 1 1;
55, 0 0 0 0 0 0 0 0 0 0;
56, 1 0 0 0 0 0 0 0 0 0;
57, 1 0 0 0 0 1 0 0 0 0;
58, 1 0 0 0 1 0 0 1 0 0;
59, 1 0 0 1 0 1 0 0 1 0;
60, 1 0 1 0 1 0 1 0 1 0;
61, 1 0 1 0 1 1 0 1 0 1;
62, 1 0 1 1 0 1 1 0 1 1;
63, 1 0 1 1 1 1 0 1 1 1;
64, 1 0 1 1 1 1 1 1 1 1;
65, 1 1 1 1 1 1 1 1 1 1;
66, 0 0 0 0 0 0 0 0 0 0 0;
67, 1 0 0 0 0 0 0 0 0 0 0;
68, 1 0 0 0 0 0 1 0 0 0 0;
69, 1 0 0 0 1 0 0 0 1 0 0;
70, 1 0 0 1 0 0 1 0 0 1 0;
71, 1 0 0 1 0 1 0 1 0 1 0;
72, 1 0 1 0 1 0 1 0 1 0 1;
73, 1 0 1 0 1 1 0 1 1 0 1;
74, 1 0 1 1 0 1 1 1 0 1 1;
75, 1 0 1 1 1 1 0 1 1 1 1;
76, 1 0 1 1 1 1 1 1 1 1 1;
77, 1 1 1 1 1 1 1 1 1 1 1;
78, 0 0 0 0 0 0 0 0 0 0 0 0;
79, 1 0 0 0 0 0 0 0 0 0 0 0;
80, 1 0 0 0 0 0 1 0 0 0 0 0;
81, 1 0 0 0 1 0 0 0 1 0 0 0;
82, 1 0 0 1 0 0 1 0 0 1 0 0;
83, 1 0 0 1 0 1 0 0 1 0 1 0;
84, 1 0 1 0 1 0 1 0 1 0 1 0;
85, 1 0 1 0 1 0 1 1 0 1 0 1;
86, 1 0 1 1 0 1 1 0 1 1 0 1;
87, 1 0 1 1 1 0 1 1 1 0 1 1;
88, 1 0 1 1 1 1 0 1 1 1 1 1;
89, 1 0 1 1 1 1 1 1 1 1 1 1;
90, 1 1 1 1 1 1 1 1 1 1 1 1;
91, 0 0 0 0 0 0 0 0 0 0 0 0 0;
92, 1 0 0 0 0 0 0 0 0 0 0 0 0;
93, 1 0 0 0 0 0 0 1 0 0 0 0 0;
94, 1 0 0 0 0 1 0 0 0 1 0 0 0;
95, 1 0 0 0 1 0 0 1 0 0 1 0 0;
96, 1 0 0 1 0 0 1 0 1 0 0 1 0;
97, 1 0 0 1 0 1 0 1 0 1 0 1 0;
98, 1 0 1 0 1 0 1 0 1 0 1 0 1;
99, 1 0 1 0 1 1 0 1 0 1 1 0 1;
100, 1 0 1 1 0 1 1 0 1 1 0 1 1;
101, 1 0 1 1 1 0 1 1 1 0 1 1 1;
102, 1 0 1 1 1 1 1 0 1 1 1 1 1;
103, 1 0 1 1 1 1 1 1 1 1 1 1 1;
104, 1 1 1 1 1 1 1 1 1 1 1 1 1;
105, 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
106, 1 0 0 0 0 0 0 0 0 0 0 0 0 0;
107, 1 0 0 0 0 0 0 1 0 0 0 0 0 0;
108, 1 0 0 0 0 1 0 0 0 0 1 0 0 0;
109, 1 0 0 0 1 0 0 1 0 0 0 1 0 0;
110, 1 0 0 1 0 0 1 0 0 1 0 0 1 0;
111, 1 0 0 1 0 1 0 1 0 0 1 0 1 0;
112, 1 0 1 0 1 0 1 0 1 0 1 0 1 0;
113, 1 0 1 0 1 0 1 1 0 1 0 1 0 1;
114, 1 0 1 0 1 1 0 1 1 0 1 1 0 1;
115, 1 0 1 1 0 1 1 1 0 1 1 0 1 1;
116, 1 0 1 1 1 0 1 1 1 1 0 1 1 1;
117, 1 0 1 1 1 1 1 1 0 1 1 1 1 1;
118, 1 0 1 1 1 1 1 1 1 1 1 1 1 1;
119, 1 1 1 1 1 1 1 1 1 1 1 1 1 1;
120, 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
121, 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
122, 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0;
123, 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0;
124, 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0;
125, 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0;
126, 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0;
127, 1 0 0 1 0 1 0 1 0 1 0 1 0 1 0;
128, 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1;
129, 1 0 1 0 1 1 0 1 0 1 1 0 1 0 1;
130, 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1;
131, 1 0 1 1 0 1 1 1 0 1 1 1 0 1 1;
132, 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1;
133, 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1;
134, 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1;
135, 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;
136, 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
137, 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
138, 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0;
139, 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0;
140, 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0;
141, 1 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0;
142, 1 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0;
143, 1 0 0 1 0 1 0 1 0 0 1 0 1 0 1 0;
144, 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0;
145, 1 0 1 0 1 0 1 0 1 1 0 1 0 1 0 1;
146, 1 0 1 0 1 1 0 1 1 0 1 0 1 1 0 1;
147, 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1;
148, 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1;
149, 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1;
150, 1 0 1 1 1 1 1 1 1 0 1 1 1 1 1 1;
151, 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1;
152, 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;

schön sichtbar diese "Spiralen" auf vertikalem Graustufenverlauf in den höher aufgelösten Rastern:

 

[einseinsnull]

dito, kreise sind total banane, zum programmieren wie zum benutzen. ich selbst benutze auch nur noch horizontale "spuren". click-drag auf die anzeige macht längs dann die rotation und hoch/runter die anzahl der besetzten schritte, das funktioniert prima.