def getSections(self):
def sect():
self.refreshTable()
self.thresh = self.envAr.mean()
self.sectList = []
self.difAr = np.zeros(self.envAr.shape)
'''division en sections'''
for i in range(self.envAr.size):
x = self.envAr[i] - self.envAr[i - 1]
self.difAr[i] = x
if x > self.thresh:
self.sectList.append(i)
self.sectMean = np.float(np.mean(self.difAr))
self.sectAr = np.split(self.envAr, self.sectList)
'''suppression des sections > self.length pour plus de densite'''
if self.length > self.sectMean:
for i in reversed(range(len(self.sectAr))):
if self.sectAr[i].size > self.length:
del self.sectAr[i]
else:
for i in reversed(range(len(self.sectAr))):
if self.sectAr[i].size < self.length:
del self.sectAr[i]
self.pat = sect()
self.pat = pyo.Pattern(sect, self.dur).play()
return self.sectAr
def __init__(self):
self._ticks: int = 0
self.pulse_0: PulseChannel = PulseChannel()
self.pulse_1: PulseChannel = PulseChannel()
self.triangle: TriangleChannel = TriangleChannel()
self.noise: NoiseChannel = NoiseChannel()
self.pattern: pyo.Pattern = pyo.Pattern(self.clock, time=0.004)
def play(self):
def call():
self.refreshTable()
self.datar[:] = self.envAr
self.pat = call()
self.pat = pyo.Pattern(call, self.refreshRate).play()
self.mul = pyo.TableRead(self.tab, 1 / self.dur, 1, 3).play()
return self.mul
def play(self):
def hist():
self.refreshTable()
self.hist, self.bin = np.histogram(self.envAr,
density=True,
bins=self.nbin)
self.hist = np.round(self.hist, 8)
self.hist = self.hist / self.hist.sum()
self.bins = self.bin[0:self.nbin]
self.pat = hist()
self.pat = pyo.Pattern(hist, self.refreshRate).play()
def call():
randHist = np.float(np.random.choice(self.bins, p=self.hist))
self.datar[:] = randHist
self.patHist = pyo.Pattern(call, 1 / self.res).play()
self.mul = pyo.TableRead(self.tab, 1 / self.dur, 1, 3).play()
return self.mul
def play(self):
def call():
self.avList = []
self.refreshTable()
self.envarMo = self.envAr
for i in range(self.envarMo.size):
x = i + self.period
self.avList.append(self.envarMo[x - self.period:x].mean())
self.datar[:] = np.asarray(self.avList)
self.pat = pyo.Pattern(call, self.refreshRate).play()
self.mul = pyo.TableRead(self.tab, 1 / self.dur, 1, 3).play()
return self.mul
def analysis(self):
self.pitchList = []
self.pitch = pyo.Yin(self.read)
s.setStartOffset(self.table.getDur())
self.x = 0
def pitchFunc():
self.x += 1
if self.x <= 5:
self.pitchList.append(round(self.pitch.get()))
self.pitchPat = pyo.Pattern(pitchFunc, .1).play()
return self.pitchList
def play(self):
self.devList = []
def deviation():
self.devList.clear()
self.refreshTable()
for i in range(self.envAr.size):
x = self.envAr[i] - self.envAr[i - 1]
self.devList.append(x)
self.mul += pyo.Choice(self.devList, self.res)
self.pat = deviation()
self.pat = pyo.Pattern(deviation, self.refreshRate).play()
return self.mul
def play(self):
self.sectOG = self.sect = self.getSections()
self.sectDum = np.concatenate(self.sect)
time = np.size(self.sectDum) / self.dur
def call():
self.refreshTable()
self.sect = self.getSections()
self.sect = np.random.permutation(self.sect)
self.sect = np.concatenate(self.sect)
self.sect = np.resize(self.sect, self.datar.shape)
self.datar[:] = np.asarray(self.sect)
self.sect = self.sectOG
self.patSect = call()
self.patSect = pyo.Pattern(call, self.refreshRate).play()
self.mul = pyo.TableRead(self.tab, 1 / self.dur, 1, 3).play()
return self.mul
def play(self):
def call():
self.refreshTable()
self.envList = self.envAr.tolist()
self.envLen = len(self.envList)
self.tempEnv = []
self.playedEnv = []
for val in self.envList:
self.tempEnv.append(val)
for i in range(self.order):
self.tempEnv.append(self.envList[i])
self.playedEnv = self.envList[self.envLen - self.order:]
self.newVal = 0
self.condition = False
self.probTable = []
self.markEnv = []
for val in range(self.envLen):
for i in range(len(self.tempEnv) - self.order):
for iord in range(self.order):
if self.playedEnv[len(self.playedEnv) -
(iord + 1)] != self.tempEnv[
(self.order - 1) + i - iord]:
self.condition = False
break
else:
self.condition = True
if self.condition:
self.probTable.append(self.tempEnv[i + self.order])
self.newVal = self.probTable[random.randint(
0, (len(self.probTable) - 1))]
self.markEnv.append(self.newVal)
self.playedEnv.append(self.newVal)
self.markEnv = np.asarray(self.markEnv)
self.datar[:] = np.asarray(self.markEnv)
self.pat = call()
self.pat = pyo.Pattern(call, self.refreshRate).play()
self.mul = pyo.TableRead(self.tab, 1 / self.dur, 1, 3).play()
return self.mul
def playback2(self):
print('pb2')
fade = pyo.Fader(fadein=.1, fadeout=0.1, dur=10).play()
glissando = pyo.SigTo(value=200, time=0.1, init=200)
sinewave = pyo.SineLoop(
freq=[glissando, glissando * 4 / 5, glissando * 4 / 3],
feedback=.2,
mul=fade)
panner = pyo.Pan(sinewave,
outs=2,
pan=random.random(),
spread=random.random()).out()
def pick_new_freq():
glissando.value = pyo.Choice(choice=self.message_translation,
freq=[1, 3])
pattern = pyo.Pattern(function=pick_new_freq, time=[.25, 1]).play()
time.sleep(fade.dur + .05)
def playback2(self):
print('pb2')
fader = pyo.Fader(fadein=0.2, fadeout=0.2, dur=5, mul=.2)
table = pyo.HarmTable([1, 2, 2, 5, 9])
glissando = pyo.SigTo(value=self.message_translation[0],
time=0.1,
init=self.message_translation[0])
osc = pyo.Osc(
table=table,
freq=[glissando / 2, (glissando - 1) / 2, (glissando + 100) / 2],
mul=fader)
panner = pyo.Pan(osc,
outs=2,
pan=random.random(),
spread=random.random()).out()
def pat():
freq = random.choice(self.message_translation)
glissando.value = freq
p = pyo.Pattern(pat, [self.message_length, .25, .75]).play()
fader.play()
time.sleep(fader.dur + .05)
osc.stop()
SIGNAL.mul = FADER
# red & bold printing
print(
"\033[91m",
"\033[1m",
"\n",
)
def _loop() -> None:
speaker = next(_speaker_cycle)
print(
"SPEAKER: ",
"{}".format(speaker + 1),
sep="",
end="\r",
flush=True,
)
SIGNAL.out(speaker, dur=TIME)
FADER.play(dur=TIME)
LOOP = pyo.Pattern(_loop, TIME + 0.075)
LOOP.play()
# starting server & gui
SERVER.start()
SERVER.gui(locals(), title="test-speaker", exit=False)
# -----exiting
subprocess.run("performance_off.sh", shell=True, stdout=subprocess.DEVNULL)
pulse_ctr += 1
if pulse_ctr >= len(_PULSE_REG0):
pulse_ctr = 0
if __name__ == '__main__':
server = pyo.Server(48000, nchnls=1).boot()
apu = APU()
# DEBUG
# test = pyo.LFO(freq=200, type=2, mul=0.5).out()
# 240 Hz clock
pattern = pyo.Pattern(function=apu.clock, time=0.004).play()
# Period = $3F8 -> Frequency should be 110 Hz
apu.pulse_0.write_reg0(0x30)
# apu.pulse_0.write_reg1(0x00)
apu.pulse_0.write_reg2(0x20)
apu.pulse_0.write_reg3(0x01)
apu.triangle.write_reg0(0xFF)
apu.triangle.write_reg2(0xFB)
apu.triangle.write_reg3(0xF1)
apu.noise.write_reg0(0x3F)
apu.noise.write_reg2(0x04)
apu.noise.write_reg3(0x01)
s = PyoServer()
m = pin.SimpleBeep()
s.start()
n = Note(550, 0.9, 0.4)
m.play(n)
class TT(object):
def __init__(self, scale, instr):
x0 = list(scale.notes)
x1 = list(scale.notes)
shuffle(x0)
shuffle(x1)
notes = [scale.notes[i] for j in zip(x0, x1) for i in j]
self.notes = itertools.cycle(notes)
self.instr = instr
def __call__(self):
freq = self.notes.next()
self.instr.play(Note(freq, 0, 0))
tt = TT(scale, m)
p = pyo.Pattern(tt, 0.2)
p.play()
