Pular para conteúdo

Maneira de Usar🔗

A costrução de padrões de acordes é feita usando a classe __chord__.

Importe o module FoxDotChord:

import FoxDotChord

Isso irá injetar no namespace do executor a instância c usada para manipular os acordes.

Você também pode fazer: from FoxDotChord import c

Progressões de acordes🔗

Os acordes podem ser passados no mesmo objeto e pode ser usados das seguintes maneiras:

  • [] com string separada por espaço 
    c['B# Cb E# Fb']
  • () com string separada por espaço 
    c('B# Cb E# Fb')
  • [] com lista de strings 
    c['B#', 'Cb', 'E#', 'Fb']
  • () com lista de strings 
    c('B#', 'Cb', 'E#', 'Fb')

Acordes maiores (C)🔗

A criação de acordes maiores é feita passando a cifra do acorde.

  • Acorde de Dó maior 
    c['C']

Todas as cifras válidas são:

Naturais Bemóis Sustenidos
A Ab A#
B Bb B#
C Cb C#
D Db D#
E Eb E#
F Fb F#
G Gb G#

Acordes menores (Cm)🔗

A criação de acordes menores é feita passando a letra m após a cifra do acorde.

  • Acorde de Dó menor 
    c['Cm']

Acordes diminutos (C⁰)🔗

A criação de acordes diminutos é feita passando o símbolo ⁰ após a cifra do acorde. Tradicionalmente também pode ser usado a apreviação dim após a cifra. A biblioteca também permite outros modos de difinir acordes diminutos.

  • ⁰ 
    c['C⁰']
  • dim 
    c['Cdim']
  • o - letra o minúsculo 
    c['Co']
  • O - letra O maiúscula 
    c['CO']
  • 0 - zero 
    c['C0']

Acordes suspensos (Csus4)🔗

Os acordes com a terça suspensa podem ser criados com as seguintes cifras:

  • sus - segunda maior suspensa 
    c['Csus']
c['Csus2']
  • sus4 - quarta justa suspensa 
    c['Csus4']
c['Csus3+']
c['Csus3#']

Acordes com extensão (Cm7/9b/11#)🔗

Os acordes, tanto maiores quanto menores, podem conter a extensão de um determinado intervalo. Para extender o acorde com mais de um intervalo separe-os com /, por exemplo, Cm7M/9.

Os intervalos aceitos são os seguintes.

2 - segunda maior🔗

  • maior 
    c['C2']
  • menor 
    c['Cm2']

4 - quarta justa🔗

  • maior 
    c['C4']
  • menor 
    c['Cm4']

5 - power chord🔗

  • 5 - power chord 
    c['C5']

5- | 5+ - quinta🔗

  • quinta diminuta

    c['C5-']
c['C5b']

    c['Cm5-']
c['Cm5b']

  • quinta aumentada

    c['C5+']
c['C5#']

    c['Cm5+']
c['Cm5b#]

6 - sexta maior🔗

  • maior 
    c['C6']
  • menor 
    c['Cm6']

7 - sétima🔗

  • 7 - sétima menor

    c['C7']

    c['Cm7']

  • 7M - sétima maior

    c['C7M']
c['C7Maj']
c['C7maj']

    c['Cm7M']
c['Cm7Maj']
c['Cm7maj']

9 - nona🔗

  • 9 - nona menor

    c['C9-']
c['C9b']

    c['Cm9-']
c['Cm9b']

  • 9 - nona aumentada

    c['C9+']
c['C9#']

    c['Cm9+']
c['Cm9#']

  • 9 - nona

    c['C9']

    c['Cm9']

11 - décima primeira🔗

  • 11 - décima primeira diminuta

    c['C11-']
c['C11b']

    c['Cm11-']
c['Cm11b']

  • 11 - décima primeira aumentada

    c['C11+']
c['C11#']

    c['Cm11+']
c['Cm11#']

  • 11 - décima primeira

    c['C11']

    c['Cm11']

13 - décima terceira🔗

  • 13 - décima terceira diminuta

    c['C13-']
c['C13b']

    c['Cm13-']
c['Cm13b']

  • 13 - décima terceira aumentada

    c['C13+']
c['C13#']

    c['Cm13+']
c['Cm13#']

  • 13 - décima terceira

    c['C13']

    c['Cm13']

Arpejos🔗

Os arpejos podem ser criados diretos na definição dos acordes colocando um @ no final dele, por exemplo:

  • Arpejo com @ 

    c['C@']

  • Arpejo em apenas um acorde de uma sequência 

    c['C@ G']

Também é possível usar o método .arp() para fazer o arpejo de todos os acordes da sequência.

  • Método .arp() 
    c['C G'].arp()

O método .arp() pode receber uma lista de inteiros. Isso terá o mesmo comportamento do método .arp(seq) dos Patterns do renardo ou dos Patterns do FoxDot se você estiver usando ele.

  • Método .arp(seq) 
    c['C G'].arp([0, 3])

Repetição🔗

É possível usar a sintaxe !N para repretar que um determinado acorde deve ser repetido N vezes, onde N será o número de vezes que aquele acorde deve soar.

  • Repetindo os acordes usando !

    c['C!4 Dm!2 G7!2']

    var(c['C Dm G7'], [4, 2, 2])

    Tocará 4 vezes o primeiro e 2 vezes os outros

  • Repetindo os arpegios (@) usando !

    c['C!4 Dm!2 G7@!2']

    var(c['C Dm G7@'], [4, 2, 2, 2, 2, 2])

    Irá tocar cada nota do arpégio duas vezes

  • Repetir (!) o acorde e arpegiar (@) o que foi duplicado

    c['C!4 Dm!2 G7!2@']

    var(c['C Dm G7@ G7@'], [4, 2, 2, 2, 2, 2, 2, 2, 2, 2])

    Irá duplicar o acorde e arpegiar as duplicatas

Atenção

Quando você usar ao menos um ! com um valor maior que 1, o objeto retornado será um var.

Portanto, alguns métodos como o .arp() não iram mais existir.

Patrones de strings🔗

Também é possível usar padrões aninhados dentro da string, assim como no play() synth.

  • Sequência simples ()

    >>> c['(D7 Cm)']
P[Chord('D7'), Chord('Cm')]

  • Na mesma batida []

    >>> c['[D7 Cm]']
P[P*(Chord('D7'), Chord('Cm'))]

  • Aleatório {}

    >>> c['{D7 Cm}']
P[PRand(P[Chord('D7'), Chord('Cm')])]

  • Sequências de camadas <><>

    >>> c['<D7><Cm>']
P[P(Chord('D7'), Chord('Cm'))]