IlPuntoTecnico

Hardware e Software => Raspberry & Automazione => Topic aperto da: Plasmodium - 03 Marzo 2019, 19:38

Titolo: Creare l'antenato dell'HAL9000 con Kalliope
Inserito da: Plasmodium - 03 Marzo 2019, 19:38
Visto che qualcuno sembrava interessato alla sintesi vocale posto questa, traduzione che avevo hatto per un corso e dimenticata sino a oggi, parziale wiki di kalliope
Nota importante prima di iniziare l'installazione. È necessario disporre di un Raspberry Pi di seconda o terza generazione.
Gli step per una board Raspberry sono davvero pochi:
Codice: [Seleziona]
rec test.wav
Codice: [Seleziona]
mplayer test.wavCon un auricolare dovrebbe funzionare direttamente. Ma, se non funziona o se vuoi una configurazione più specifica, come l'uscita audio sul jack e l'ingresso sulla micro USB, segui le istruzioni qui sotto.
Mostriamo i nostri dispositivi di output
Codice: [Seleziona]
aplay -lQuale dà un'uscita come questa
Codice: [Seleziona]
**** List of PLAYBACK Hardware Devices ****
card 0: ALSA [bcm2835 ALSA], device 0: bcm2835 ALSA [bcm2835 ALSA]
  Subdevices: 7/8
  Subdevice #0: subdevice #0
  Subdevice #1: subdevice #1
  Subdevice #2: subdevice #2
  Subdevice #3: subdevice #3
  Subdevice #4: subdevice #4
  Subdevice #5: subdevice #5
  Subdevice #6: subdevice #6
  Subdevice #7: subdevice #7
card 0: ALSA [bcm2835 ALSA], device 1: bcm2835 ALSA [bcm2835 IEC958/HDMI]
  Subdevices: 1/1
  Subdevice #0: subdevice #0
card 1: Headset [Logitech USB Headset], device 0: USB Audio [USB Audio]
  Subdevices: 0/1
  Subdevice #0: subdevice #0
Qui possiamo identificare quello che abbiamo

Ora mostriamo gli input audio
Codice: [Seleziona]
arecord -lChe dà un'uscita del genere
Codice: [Seleziona]
Subdevices: 0/1 
Qui vediamo che abbiamo una scheda micro USB 1 e dispositivo 0 (scheda 1, dispositivo 0)
Creeremo un file di configurazione in modo che:
   
Quindi creiamo un file /home/pi/.asoundrc con il seguente contenuto
Codice: [Seleziona]
pcm.!default {
   type asym
   playback.pcm {
     type plug
     slave.pcm "hw:1,0"
   }
   capture.pcm {
     type plug
     slave.pcm "hw:1,0"
   }

Qui, playback.pcm è l'output e capture.pcm è l'input.
La configurazione viene applicata riavviando il servizio
Codice: [Seleziona]
sudo /etc/init.d/alsa-utils restartPuoi anche regolare il volume e la sensibilità del microfono con il comando:
Codice: [Seleziona]
alsamixerche ti mostrerà un menu grafico. Il tasto F6 per passare da un dispositivo a un altro.

Di seguito la wiki tradotta

Saluti
Titolo: Re:Creare l'antenato dell'HAL9000 con Kalliope
Inserito da: Plasmodium - 03 Marzo 2019, 19:41
Kalliopé è un programma che ti permetterà di creare il tuo assistente vocale personale sul tuo Raspberry Pi.

Tradotto dalla Kalliope doc originale: https://kalliope-project.github.io/kalliope/

    Home
    Installation
        Raspberry
        Debian
        Ubuntu
    Getting-started
    Settings
        settings.yml
        Trigger
            Snowboy
        Player
            mplayer
            pyalsaaudio
            pyaudioplayer
            sounddeviceplayer
        STT
            api.ai
            Bing
            CMUSphinx
            Google
            Houndify
            wit.ai
        TTS
            espeak
            googletts
            marytts
            pico2wave
            voicerss
            watson
    Brain
        brain.yml
        Core signals
            event
            geolocation
            mqtt_subscriber
            order
        Core neurons
            ansible_playbook
            brain
            debug
            kalliope_version
            kill_switch
            mqtt_publisher
            neurotimer
            neurotransmitter
            say
            script
            settings
            shell
            signals
            sleep
            systemdate
            uri
        Community modules
    CLI
    API
    Contribute
        Core
        Neuron
        STT
        TTS
        Documentation
        install.yml
        dna.yml


Home

Benvenuti nella documentazione di Kalliope

Kalliope è un framework  che ti aiuterà a creare il tuo assistente personale.

Il concetto è quello di creare il cervello https://kalliope-project.github.io/kalliope/brain/brain/  (https://kalliope-project.github.io/kalliope/brain/brain/)del tuo assistente collegando un signal di input (ordine vocale, evento programmato, messaggio MQTT, evento GPIO, ecc.) a una o più azioni chiamate neurons .

Puoi creare il tuo bot Kalliope, semplicemente scegliendo e componendo con i neuroni esistenti https://kalliope-project.github.io/neurons_marketplace.html (https://kalliope-project.github.io/neurons_marketplace.html)  senza scrivere alcun codice. Ma se hai bisogno di un modulo particolare, puoi scriverlo da solo, aggiungerlo al tuo progetto e proporlo alla comunità.

Kalliope può funzionare su tutte le distribuzioni Linux basate su Debian incluso Raspberry Pi ed è multi-lingua. L'unica cosa di cui hai bisogno è un microfono.

Kalliope è facile da usare, guarda quest'hello world:

Codice: [Seleziona]
  - name: "Ciao-puntotecnico"
    signals:
      - order: "dire    Ciao"
    neurons:
      - say:
          message: "Ciao    puntotecnico!"

Installation

Raspberry

Requisiti di Kalliope per Raspbian

Kalliope può essere installato:


Installa tramite l'immagine del disco precompilata

Scarica l'ultima immagine dalla pagina di rilascio di Kalliope https://github.com/kalliope-project/kalliope/releases (https://github.com/kalliope-project/kalliope/releases)  e caricala come al solito su una scheda SD.

Codice: [Seleziona]
    [b]Login[/b]: pi
    [b]Password[/b]: raspberry

Una volta avviato, usare il comando raspi-config per espandere il file system e riempire lo spazio disponibile sulla scheda SD. Il server SSH è abilitato di default. Ottieni l'IP con il comando ip a e quindi connettiti tramite il tuo client SSH preferito.

Troverai alcune cartelle denominate "starter_kit_<language>" situate in /home/pi . Queste cartelle sono la configurazione di base che ti aiuterà a iniziare con Kalliope.

Installa tramite script

Basta eseguire il seguente comando bash per installare Kalliope su un Raspberry Pi:

Codice: [Seleziona]
  bash -c "$ (curl -sL https://raw.githubusercontent.com/kalliope-project/kalliope/master/install/rpi_install_kalliope.sh)"

Installazione manuale

Codice: [Seleziona]
    Nota: Si raccomanda di utilizzare un'installazione Lite di Raspbian senza alcuna interfaccia grafica per un'esperienza migliore.

    Nota: Il primo Raspberry Pi non è ufficialmente supportato. L'installazione funzionerà ma un singolo core con soli 700Mhz questo potrebbe produrre latenza.

Ometto per ora.

Configurazione Raspberry Pi

Questa sezione tratta della configurazione necessaria per far funzionare kalliope su un RPi.

Configurazione del microfono

Ottieni info sull'output con:

Codice: [Seleziona]
  aplay -l

Esempio di output con una cuffia USB collegata:

Codice: [Seleziona]
**** List of PLAYBACK Hardware Devices ****
card 0: ALSA [bcm2835 ALSA], device 0: bcm2835 ALSA [bcm2835 ALSA]
  Subdevices: 7/8
  Subdevice #0: subdevice #0
  Subdevice #1: subdevice #1
  Subdevice #2: subdevice #2
  Subdevice #3: subdevice #3
  Subdevice #4: subdevice #4
  Subdevice #5: subdevice #5
  Subdevice #6: subdevice #6
  Subdevice #7: subdevice #7
card 0: ALSA [bcm2835 ALSA], device 1: bcm2835 ALSA [bcm2835 IEC958/HDMI]
  Subdevices: 1/1
  Subdevice #0: subdevice #0
card 1: Headset [Logitech USB Headset], device 0: USB Audio [USB Audio]
  Subdevices: 0/1
  Subdevice #0: subdevice #0

Qui vediamo che:


Ottenere info sull'input (microfono):

Codice: [Seleziona]
  arecord -l

Esempio di output con una cuffia USB collegata:

Codice: [Seleziona]
**** List of CAPTURE Hardware Devices ****
card 1: Headset [Logitech USB Headset], device 0: USB Audio [USB Audio]
  Subdevices: 0/1
  Subdevice #0: subdevice #0

Qui vediamo una periferica su card 1 e device 0

Creiamo quindi un file di configurazione che applichi la seguente configurazione:


Creiamo un file in /home/pi/.asoundrc con il contenuto sottostante

Codice: [Seleziona]
pcm.!default {
   type asym
   playback.pcm {
type plug
slave.pcm "hw:0,0"
   }
   capture.pcm {
type plug
slave.pcm "hw:1,0"
   }
}

Dove playback.pcm è l'audio in uscita e capture.pcm è l'audio in ingresso.

Riavvia ALSA per applicare le modifiche:

Codice: [Seleziona]
  sudo /etc/init.d/alsa-utils restart

Regola la sensibilità del microfono eseguendo alsamixer:

[code]
  alsamixer

Seleziona il microfono premendo F6 e regola il livello di sensibilità del mic :

(https://kalliope-project.github.io/kalliope/images/alsamixer_mic_level.png)

HDMI / Audio analogico

Per impostazione predefinita, se qualcosa è collegato a questa porta, il flusso audio utilizzerà HDMI . Controlla la documentazione ufficiale https://www.raspberrypi.org/documentation/configuration/audio-config.md per passare da HDMI ad analogico.

Codice: [Seleziona]
  sudo raspi-config

Configura le tue impostazioni locales (lingua)

Le impostazioni locales definiscono impostazioni specifiche per lingua e paese per i tuoi programmi e la sessione di shell. Per impostare le impostazioni internazionali del sistema è necessario utilizzare la variabile di shell. Ad esempio, la variabile LANG può essere utilizzata per impostare la lingua it_IT (italiano).

Controlla le impostazioni locales in uso:

Codice: [Seleziona]
  locale

Per aggiornare le impostazioni internazionali, digitare il comando seguente:

Codice: [Seleziona]
  sudo dpkg-reconfigure locales

Seleziona nell'elenco il locales del tuo paese, selezionando il codice con UTF8, esempio:


Quindi, aggiorna il tuo file /home/pi/.bashrc esportando la lingua. Esempio:

Codice: [Seleziona]
  export LC_ALL = "en_US.UTF-8"
  export LANG = "en_US.UTF-8"
  export LANGUAGE = "en_US.UTF-8"

Esegui source per applicare le modifiche

Codice: [Seleziona]
  source /home/pi/.bashrc

Testa il tuo marchingegno

Controlla il microfono e la configurazione degli speaker

Per assicurarti di poter registrare la tua voce, esegui il seguente comando per catturare l'input audio dal tuo microfono:

Codice: [Seleziona]
  rec test.wav

Premi CTRL-C dopo aver catturato un campione della tua voce.

Quindi riproduci il file audio registrato

Codice: [Seleziona]
  mplayer test.wav

La tua installazione è ora completa, diamo ora un'occhiata alla documentazione introduttiva   https://kalliope-project.github.io/kalliope/getting-started/ per imparare come usare Kalliope.

(Optional) Avviare Kalliope automaticamente dopo un riavvio

Se si vuole avviare automaticamente Kalliope all'avvio poni il seguente script in /etc/systemd/system/kalliope.service.

Aggiorna il percorso <my_config_path> con il percorso in cui hai inserito i file brain.yml e settings.yml.

Aggiorna <username> con il nome di un utente non root. Ad esempio, su Raspbian puoi impostare pi.

Codice: [Seleziona]
[Unit]
Description=Kalliope

[Service]
WorkingDirectory=<my_config_path>

Environment='STDOUT=/var/log/kalliope.log'
Environment='STDERR=/var/log/kalliope.err.log'
ExecStart=/bin/bash -c "/usr/local/bin/kalliope start > ${STDOUT} 2> ${STDERR}"
User=<username>

[Install]
WantedBy=multi-user.target

E.g

[Unit]
Description=Kalliope

[Service]
WorkingDirectory=/home/pi/my_kalliope_config

Environment='STDOUT=/var/log/kalliope.log'
Environment='STDERR=/var/log/kalliope.err.log'
ExecStart=/bin/bash -c "/usr/local/bin/kalliope start > ${STDOUT} 2> ${STDERR}"
User=pi

[Install]
WantedBy=multi-user.target

Quindi, ricarica systemctl, avvia il servizio creato e abilitalo all'avvio

Codice: [Seleziona]
sudo systemctl daemon-reload
sudo systemctl start kalliope
sudo systemctl enable kalliope

Iniziare con Kalliope

Kalliope ha bisogno di due file per funzionare, un settings.yml e un brain.yml. Poiché i file sono scritti con sintassi YAML, ti consigliamo vivamente di utilizzare un editor (IDE) come VS Code o Atom.

Se stai usando kalliope da un Rpi, l'idea sarebbe quella di configurare il tuo assistente dal tuo computer con un IDE e poi inviare la configurazione al tuo RPI.

Quando avvii kalliope usando la CLI ( kalliope start ), il programma proverà a caricare settings.yml e brain.yml nel seguente ordine:


Questo è l'albero di default della cartella di configurazione di Kalliope:

Codice: [Seleziona]
kalliope_config/
├── brains
│   └── included_brain.yml
├── brain.yml
├── files
│   └── kalliope-EN-13samples.pmdl
└── settings.yml

Abbiamo creato uno starter kits che deve solo essere clonato, inserito nell'RPI e lanciato. Troverai l'intero elenco di start kits disponibili sul sito web di Kalliope https://kalliope-project.github.io/starter_kit.html. Questi repository forniscono una struttura per iniziare a imparare le basi di Kalliope. Scarica il kit di partenza a tua scelta e apri la cartella con il tuo IDE.

Tutti i file sono espressi in formato YAML (vedi Sintassi YAML https://learnxinyminutes.com/docs/yaml/ ) e hanno un minimo di sintassi, che tenta intenzionalmente di non essere un linguaggio o uno script di programmazione, ma piuttosto un modello di una configurazione o di un processo.

Apriamo il file principale dello starter kit Italiano. Vedrai che ci sono alcuni file di sub brains inclusi.

Codice: [Seleziona]
- includes:
- brains/say.yml

Se apri il file say.yml dalla cartella brains, vedrai una sinapsi di base che usa il neurone https://kalliope-project.github.io/kalliope/brain/brain/#neurons" Say " e fa parlare Kalliope ad alta voce "Ciao signore" quando dici "hello".

Codice: [Seleziona]
- name: "say-hello-it"
  signals:
- order: "Hello"
  neurons:
- say:
message: "Ciao    signore"

Dividiamo il tutto in sezioni in modo che possiamo capire come viene costruito il file e cosa significa ogni parte.

I pezzi che iniziano con - sono considerati come elementi di questo elenco. I pezzi hanno il formato key: value il cui il valore può essere una semplice stringa o una sequenza di altri sotto elementi.

Al livello più alto abbiamo un tag "name". Questo è l'identificatore univoco della sinapsi. Deve essere univoca e accetta unicamente i caratteri alfanumerici e trattino. ([a - zA - Z0 - 9-])

Codice: [Seleziona]
- name: "Say-hello"

La prima parte, denominata signals, è una lista di azioni di input. Puoi aggiungere quante azioni vuoi nella sezione "signals". Se uno di questi viene attivato, la lista dei neuroni verrà eseguita.

Codice: [Seleziona]
signals:
  - order: "say-hello"

Nell'esempio seguente, usiamo solo una azione, un "order", ma può anche essere:


Vediamo ora le dichiarazioni dei neurons. I neuroni sono moduli che verranno eseguiti quando l'azione di input (signal) viene attivata. È possibile definire quanti neuroni si desidera per la stessa azione di input (ad esempio: dire qualcosa, quindi fare qualcosa ecc ...). Questa contiene un elenco (perché inizia con un "-") di neurons

Codice: [Seleziona]
neurons:
  - neuron_1_name
  - neuron_2_name
  - another_neuron

L'ordine di esecuzione dei neuroni è definito dall'ordine in cui sono elencati nella dichiarazione dei neurons.

Alcuni neuroni hanno bisogno di parametri che possono essere passati come argomenti seguendo la seguente sintassi:

Codice: [Seleziona]
neurons:
  - neuron_name:
  parameter1: "value1"
  parameter2: "value2"

Nota che i parametri necessitano di una tabulazione sotto il nome del neurone (requisito di sintassi YAML).

In questo esempio, il neurone chiamato "say" farà sì che Kalliope pronunci ad alta voce la frase nel parametro message.

I neuroni possono essere Core (installati di default) o community based (devono essere installati).

È ora di avviare Kalliope. Spostati nella cartella e avvia Kalliope:

Codice: [Seleziona]
cd /path/to/the/starter_kit
kalliope start

    Nota: Non avviare Kalliope come utente root o con sudo

Kalliope caricherà le settings e il brain, l'output dovrebbe apparire come segue

Codice: [Seleziona]
Starting event manager
Events loaded
Starting Kalliope
Press Ctrl+C for stopping
Starting REST API Listening port: 5000
Waiting for trigger detection

Ora pronuncia l'hotwork ad alta voce e vedrai che Kalliope (con la pronuncia corretta a seconda del tuo starter kit. "Kalliopé" in Francese, "Kalliopee" in Inglese, ecc.). Se pronunciato correttamente, vedrai "say something" nella console.

Codice: [Seleziona]
  Say something!

Quindi potrai dire "hello" e ascoltare la risposta di Kalliope.

Codice: [Seleziona]
Say something!
Google Speech Recognition thinks you said hello
Order matched in the brain. Running synapse "say-hello"
Waiting for trigger detection

Questo è tutto! Sei pronto per personalizzare il tuo assistente!

Settings

settings.yml

Codice: [Seleziona]
Table of contents

    Triggers configuration
        default_trigger
        triggers
        Settings example
        Available trigger engine
    Players configuration
        default_player
        players
        Settings example
        Available players
    Speech to text configuration
        default_speech_to_text
        speech_to_text
        Settings example
        Available STT
    Text to speech configuration
        default_text_to_speech
        text_to_speech
        cache_path
        Settings example
        Available TTS
    Hooks
        Settings example
    Rest API
    Resources directory
    Global Variables
    Options
        energy_threshold
        adjust_for_ambient_noise_second
    send_anonymous_usage_stats

Questa parte della documentazione spiega la configurazione principale di Kalliope inserita nel file settings.yml .

Kalliope cercherà il file delle impostazioni nell'ordine seguente:


Configurazione dei trigger

default_trigger

Il trigger è l'engine che ha il compito di rilevare l'hotword che risveglierà Kalliope.
Alcune hotword comuni sono "Alexa" su Amazon Echo, "OK Google" su alcuni dispositivi Android e "Hey Siri" su iPhone.

Specificare il nome del modulo trigger che si desidera utilizzare.

Codice: [Seleziona]
  default_trigger : "trigger_name"

Per esempio

  default_trigger : "snowboy"

trigger

Il rilevatore di hotword (detto anche wake word o trigger word) è il motore che ha il compito di svegliare Kalliope.

Ogni trigger ha una propria configurazione. Questa configurazione è passata come argomento seguendo la seguente sintassi

Codice: [Seleziona]
  trigger :
   - trigger_name :
       parameter_name : "valore"

Ad esempio, la configurazione predefinita di Snowboy è

Codice: [Seleziona]
  trigger :
   - Snowboy :
       pmdl_file : "trigger/snowboy/resources/model.pmdl"

Esempio d'impostazioni

  default_trigger : "snowboy"
  trigger :
   - Snowboy :
       pmdl_file : "trigger / snowboy / resources / model.pmdl"

Trigger disponibili

| Doc                            | Note                                                  |
| ------------------------------ | ----------------------------------------------------- |
| [snowboy](triggers/snowboy.md) | Basato sul [software Snowboy](https://snowboy.kitt.ai/) |
Titolo: Re:Creare l'antenato dell'HAL9000 con Kalliope
Inserito da: Plasmodium - 03 Marzo 2019, 19:51

Configurazione dei Players

Il Players è la libreria/software usato per far parlare Kalliope.
In un progetto Kalliope, puoi impostare qualsiasi lettore audio che desideri utilizzare.

default_player

Specificare il nome del modulo Players che si desidera utilizzare.

Codice: [Seleziona]
  default_player : "player_name"

Per esempio

  default_player : "mplayer"

players

Ogni players ha la propria configurazione.
Questa configurazione è passata come argomento seguendo la seguente sintassi

Codice: [Seleziona]
  players:
   - player_name:
       parameter_name: "value"

Quando non sono richiesti parametri, imposta un oggetto vuoto:

  players:
   - mplayer: {}

Esempio d'impostazioni

Codice: [Seleziona]
players:
  - mplayer: {}
  - pyalsaaudio:
device: "default"
convert_to_wav: True
  - pyaudioplayer:
convert_to_wav: True
  - sounddeviceplayer:
convert_to_wav: True

    Nota: A volte, i parametri saranno necessari per utilizzare un engine.
Fai clic sul link del Player scelto nella sezione "Current CORE Available Players" per sapere quali parametri sono richiesti.

    Nota: Un player che non richiede Parametri d'input deve essere dichiarato con un dict vuoto. Ad esempio: - player_name: {}

    Nota: I player principali sono inclusi nell'installazione di Kalliope e sono pronti all'uso.

    Nota: La maggior parte dei TTS basati su cloud genera un file in formato MP3. Alcuni players non sono in grado di leggere questo formato e quindi è necessaria una conversione in wav.

Players disponibili

I player principali sono già stati confezionati con Kalliope e possono essere utilizzati sin da subito.

| Doc                                               | Note                                                                                          |
| ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| [mplayer](players/mplayer.md)                     | Basato sul [software mplayer](http://www.mplayerhq.hu/design7/news.html)                      |
| [pyalsaaudio](players/pyalsaaudio.md)             | Basato sula lib di [pyalsaaudio](https://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html) |
| [pyaudioplayer](players/pyaudioplayer.md)         | Basato sula lib di [pyaudio](https://people.csail.mit.edu/hubert/pyaudio/docs/)               |
| [sounddeviceplayer](players/sounddeviceplayer.md) | Basato sula lib di [sounddevice](https://pypi.python.org/pypi/sounddevice)                    |

Configurazione della Sintesi Vocale

default_speech_to_text

Uno Speech To Text(STT) è un engine utilizzato per tradurre ciò che dici in un testo che può essere elaborato dal core di Kalliope.
Per impostazione predefinita, Kalliope utilizza il motore Google STT.

La seguente sintassi viene utilizzata per fornire il nome dell'engine:

  default_speech_to_text: "stt_name"

Per esempio

  default_speech_to_text: "google"

speech_to_text

Ogni STT ha la propria configurazione. Questa configurazione è passata come argomento che viene mostrato di seguito

Codice: [Seleziona]
  speech_to_text:
   - stt_name:
       parameter_name: "value"

Per esempio:

  speech_to_text:
   - google :
       language: "it-IT"
   - Bing

Esempio d'impostazioni

  default_speech_to_text: "google"
  speech_to_text:
   - google:
       language: "it-IT"
   - wit:
       key: "MYKEYS"
   - bing:
       key: "MYKEYS"
   - apiai:
       key: "MYKEYS"
       language: "it"
   - houndify:
       key: "MYKEYS"
       client_id: "MYCLIENTID"

STT disponibili

I principali STTs sono già stati inclusi con l'installazione di Kalliope e sono pronti all'uso.

| Nome                          | Tipo                  |
| ----------------------------- | --------------------- |
| [apiai](stt/api.ai.md)        | Basato su cloud       |
| [Bing](stt/bing.md)           | Basato su cloud       |
| [CMUSphinx](stt/CMUSphinx.md) | Self hosted (Offline) |
| [Google](stt/google.md)       | Basato su cloud       |
| [Houndify](stt/houndify.md)   | Basato su cloud       |
| [wit.ai](stt/wit.ai.md)       | Basato su cloud       |

Configurazione Sintesi Vocale

default_text_to_speech

Il Text To Speech è utilizzato per tradurre il testo scritto in un flusso audio.
Per impostazione predefinita, Kalliope utilizza l'engine TTS Pico2wave.

La seguente sintassi viene utilizzata per fornire il nome dell'engine TTS

Codice: [Seleziona]
  default_text_to_speech: "tts_name"

Per esempio

  default_text_to_speech: "pico2wave"

text_to_speech

Ogni TTS ha la propria configurazione. Questa configurazione è passata come argomento seguendo la seguente sintassi

Codice: [Seleziona]
  text_to_speech :
   - tts_name :
       parameter_name: "value"

Per esempio

  text_to_speech :
   - pico2wave :
       language: "it-IT"
   - googletts :
       language: "it-IT"

cache_path

Gli engines TTS funzionano tutti allo stesso modo, gli diamo un testo, restituiscono un file audio e riproducono il file audio. Il file audio generato viene inserito nella cache fino a quando non
viene riprodotto dal lettore audio. Prima di generare un nuovo file audio, Kalliope darà un'occhiata alla cache per caricarla direttamente senza dover chiamare il
motore TSS se il file è gia stato generato in precedenza.

È necessario impostare, nel tag `cache_path`, un percorso in cui la cache verrà salvata. Di default il percorso è /tmp.

Codice: [Seleziona]
  cache_path: "/ tmp / kalliope_tts_cache"

    Nota: Il percorso deve essere valido e l'utente deve averne i permessi di lettura e scrittura.

    Nota: Lo spazio occupato aumenta notevolmente a causa della cache. Si consiglia di impostare un neurone che cancelli automaticamente i file audio
generati che non verrano più riprodotti.

Esempio d'impostazioni

Codice: [Seleziona]
  default_text_to_speech: "voicerss"

  cache_path: "/tmp/kalliope_tts_cache"

 text_to_speech :
   - pico2wave :
       language: "it-IT"
       cache: True
   - acapela:
       language: "sonid15"
       voce : "Manon"
       cache : False
   - googletts :
       language: "it"
   - voicers :
       language: "it-IT"
       cache: True

TTS disponibili

I principali TTS sono già inclusi nell'installazione di Kalliope e possono essere utilizzati immediatamente.

| Name                          | Tipo                  |
| ----------------------------- | --------------------- |
| [espeak](tts/espeak.md)       | Self hosted (Offline) |
| [googletts](tts/googletts.md) | Basato su cloud       |
| [marytts](tts/marytts.md)     | Self hosted (Offline) |
| [pico2wave](tts/pico2wave.md) | Self hosted (Offline) |
| [voicerss](tts/voicerss.md)   | Basato su cloud       |
| [watson](tts/watson.md)       | Basato su cloud       |

Hooks

L'Hooking consente di associare le azioni agli eventi in base al lifecycle di Kalliope.
Ad esempio, è utile sapere quando Kalliope ha rilevato l'hotword dal trigger engine e farle pronunciare ad alta voce che è pronta ad ascoltare il tuo ordine.

Per utilizzare un hook, collega il nome dell'hook a una sinapsi (o un elenco di sinapsi) esistenti nel tuo brain.

Sintassi:

Codice: [Seleziona]
  hooks:
    hook_name1 : sinapse_name
    hook_name2 :
      - synapse_name_1
      - synapse_name_2

Per esempio

  hooks:
    on_start : "on-start-synapse"

Elenco degli hook disponibili

| Nome dell'hook         | Descrizione                                                            |
| ---------------------- | ---------------------------------------------------------------------- |
| on_start               | Quando viene avviato kalliope. Questo hook si attiva una sola volta    |
| on_waiting_for_trigger | Quando Kalliope attende il rilevamento di hotword                      |
| on_triggered           | Quando è stata rilevata l'hotword                                      |
| on_start_listening     | Quando il motore di sintesi vocale è in ascolto di un ordine           |
| on_stop_listening      | Quando il motore di sintesi vocale interrompe l'attesa di un ordine    |
| on_order_found         | Quando l'ordine pronunciato è stato trovato nel brain                  |
| on_order_not_found     | Quando l'ordine pronunciato non è stato trovato nel brain              |
| on_processed_synapses  | Quando tutti i neuroni nelle sinapsi sono stati elaborati              |
| on_deaf                | Quando Kalliope passa da non udente a udente                           |
| on_undeaf              | Quando Kalliope passa da udente a non udente                           |
| on_mute                | Quando Kalliope passa da non muto a muto                               |
| on_unmute              | Quando Kalliope passa da muto a non muto                               |
| on_start_speaking      | uando Kalliope inizia a parlare attraverso il motore di sintesi vocale |
| on_stop_speaking       | Quando Kalliope smette di parlare                                      |
| on_stt_error           | Quando avviane un errore durante l'elaborazione dell'STT               |

Esempio d'impostazioni

Esempio: vuoi sentire una risposta casuale quando è rilevata l'hotword

settings.yml

Codice: [Seleziona]
  hooks:
    on_triggered : "on-triggered-synapse"

[b]brain.yml[/b]

  - name: "on-triggered-synapse"
   signals: []
   neurons:
     - say:
         message:
           - "si    signore?"
           - "Sto    ascoltando"
           - "Sto    ascoltando    te"
           - "signore?"
           - "cosa    posso    fare    per    te?"
           - "Parlare"
           - "come    posso    Aiutare    te?"

Esempio: vuoi sapere che il tuo ordine non è stato trovato

settings.yml

Codice: [Seleziona]
  hooks:
    on_order_not_found: "order-not-found-synapse"

[b]brain.yml[/b]

  - name: "order-not-found-synapse"
     signals: []
     neurons:
       - say:
           message:
             - "I    non ho    compreso"
             - "I    non    conosco    Questo    ordine"
             - "Per favore    ripetere    il tuo    ordine"
             - "Per favore    riformulare    il tuo    ordine"
             - "Io    non    riconosco    quello    ordine"

Esempio: stai usando Kalliope su un Rpi. Hai realizzato uno script che attiva o disattiva un led.
Puoi chiamare questo script ogni volta che kalliope inizia o smette di parlare

settings.yaml

Codice: [Seleziona]
  hooks:
   on_start_speaking : "turn-on-led"
   on_stop_speaking : "turn-off-led"

[b]brain.yml[/b]

  - name: "turn-on-led"
   signals: []
   neurons:
     - script:
         path: "/path/to/script.sh on"

  - name: "turn-off-led"
   signals: []
   neurons:
     - script:
         path: "/path/to/script.sh off"

    Nota: non è possibile utilizzare un neurotrasmettitore all'interno di una sinapsi chiamata da un hook.
Non puoi usare il neurone "say" all'interno di "on_start_speaking" o "on_stop_speaking" o creerà un loop infinito

Rest API

È possibile attivare una Rest API per:


Per la lista completa delle API vedi la documentazione REST API https://kalliope-project.github.io/kalliope/rest_api/ (https://kalliope-project.github.io/kalliope/rest_api/)

Esempi di impostazioni:

Codice: [Seleziona]
rest_api:
  active: True
  port: 5000
  password_protected: True
  login: admin
  password: secret
  allowed_cors_origin: "*"

| Parametro           | Tipo     | Commento                                                                                                   |
| ------------------- | -------- | ---------------------------------------------------------------------------------------------------------- |
| active              | booleano | Per abilitare il server rest api                                                                           |
| port                | intero   | La porta in ascolto del server web. Deve essere un numero intero compreso tra 1024-65535                   |
| password_protected  | booleano | Se `True`, l'intera API sarà protetta da password                                                          |
| login               | stringa  | Accesso protetto dall'autenticazione HTTP di base. Deve essere fornito se `password_protected` è `True`    |
| password            | stringa  | Password utilizzata dall'autenticazione HTTP di base. Deve essere fornito se `password_protected` è `True` |
| allowed_cors_origin | stringa  | Consenti richiesta da applicazione esterna. Vedi gli esempi qui sotto                                      |

Richieste Cors

Se si desidera consentire le richieste da un'applicazione esterna, è necessario abilitare le impostazioni delle richieste CORS definendo le origini autorizzate.
Per fare ciò, basta indicare l'origine a cui è consentito sfruttare l'API. I valori autorizzati sono:

False per vietare la richiesta CORS.

Codice: [Seleziona]
  allowed_cors_origin : False

o anche una stringa o un elenco:

  allowed_cors_origin: "*"

(in caso di "*", tutte le origini sono accettate).

  allowed_cors_origin:
   - 'http://mydomain.com/*'
   - 'http://localhost:4200/*'

Ricorda che un'origine è composta dallo schema (http(s)), dalla porta (es.:80, 4200,…) e dal dominio (mydomain.com, localhost).

Directory delle risorse

La directory delle risorse è il percorso in cui Kalliope proverà a caricare moduli della community come Neuroni, STT o TTS.
È necessario impostare un percorso valido se si desidera installare dei "community neuron". Il percorso può essere relativo o assoluto.

Codice: [Seleziona]
  resource_directory :
   resource_name: "path"

Per esempio

  resource_directory :
   neuron: "resources/neurons"
   stt: "resources/stt"
   tts: "resources/tts"
   trigger: "/full/path/to/trigger"

Variabili Globali

I percorsi delle Variabili Globali elencano dove caricare le suddette.
Queste variabili possono essere riutilizzate nei parametri dei neuroni dentro parentesi doppie.

Per esempio

Codice: [Seleziona]
  var_files:
   - variables.yml
   - variables2.yml

    Nota: Se una variabile è definita in file diversi, l'ultimo file definisce il valore.

Nei file le variabili sono definite da key/value:

  variable: 60
  baseURL: "http://blabla.com/"
  password: "secret"

E cosi si usano nei tuoi neurons:

Codice: [Seleziona]
  - name: "run-simple-sleep"
    signals:
      - order: "Aspettami"
    neurons:
      - uri:
          url: "{{baseURL}}get/1"
  user: "admin"
          password: "{{password}}"

    Nota: poiché il formato YAML non consente doppie parentesi non circondate da virgolette: è necessario utilizzare la variabile tra virgolette.

Una variabile globale può essere un dizionario. Esempio:

Codice: [Seleziona]
  contatti :
   nico : "1234"
   francesco : "5678"

E una sinapsi che usa questo dizionario:

  - name: "test-var"
    signals:
      - order: "dammi il numero di {{ contact_to_search }}"
    neurons:
      - say:
        message:
        - "il numero è {{ contacts[contact_to_search] }}"

Opzioni

Opzioni che possono essere definite per Kalliope.

Esempio di configurazione

Codice: [Seleziona]
options:
  mute: True
  deaf: False

Opzioni disponibili:

| Opzione                         | Descrizione                                                                                          |
| ------------------------------- | ---------------------------------------------------------------------------------------------------- |
| mute                            | Quando è muto, l'STT engine non sarà usato per far parlare Kalliope durante l'esecuzione dei neuroni |
| deaf                            | Quando è sordo, il trigger engine non viene avviato. Kalliope non aspetterà la wake up word          |
| energy_threshold                | [energy_threshold](#energy_threshold)                                                                |
| adjust_for_ambient_noise_second | [adjust_for_ambient_noise_second](#adjust_for_ambient_noise_second)                                  |
| stt_timeout                     | Numero di secondi prima di interrompere automaticamente l'esecuzione dell'STT                        |

energy_threshold

Rappresenta la soglia del rumore ambientale. Di default è impostato su 4000 .
I valori al di sotto di questa soglia sono considerati silenzio e i valori superiori a questa soglia sono considerati voce.
Questo viene regolato automaticamente se le soglie dinamiche sono abilitate con il parametro adjust_for_ambient_noise_second .

Questa soglia è associata al volume percepito del suono, ma è una relazione non lineare.
La soglia di energia effettiva necessaria dipende dalla sensibilità del microfono o dai dati audio.
I valori tipici per una stanza silenziosa sono compresi tra 0 e 100 e i valori tipici per la conversazione sono compresi tra 150 e 3500.
Il rumore ambientale (non parlato) ha un impatto significativo su quali valori funzioneranno meglio.

Se hai problemi con il riconoscimento che cerca di riconoscere le parole anche quando non parli, prova a modificarlo con un valore più alto.
Se hai problemi di non riconoscimento delle tue parole mentre parli, prova a modificarlo con un valore più basso.
Ad esempio, un microfono sensibile o un microfono in stanze più rumorose potrebbe avere un livello di energia ambientale maggiore di 4000.

Codice: [Seleziona]
  options:
    energy_threshold: 4000

    Nota: Il valore predefinito, se non impostato, è 4000

adjust_for_ambient_noise_second

Se definito, calibra la soglia in modo dinamico acquisendo il rumore ambientale della stanza per la durata in secondi impostata nel parametro.
Quando è impostato, il parametro energy_threshold viene sovrascritto dal valore restituito dalla calibrazione del rumore.
Questo valore dovrebbe essere almeno 0,5 per ottenere un campione rappresentativo del rumore ambientale.

  options:
    adjust_for_ambient_noise_second: 1

    Nota: Il numero di secondi qui rappresenta il tempo tra il risveglio di Kalliope e il momento in cui puoi darle il tuo ordine.

send_anonymous_usage_stats

Questo flag consente a Kalliope di inviare alcune statistiche per valutare in modo anonimo l'utilizzo globale dell'app Kalliope da parte degli utenti.

Sintassi:

Codice: [Seleziona]
  send_anonymous_usage_stats: <boolean>

Per esempio:

  send_anonymous_usage_stats: False

Trigger

Snowboy

Codice: [Seleziona]

Sommario

    parametri
    Impostazioni d'esempio
    Modelli disponibili di Snowboy

Parametri

Puoi creare la tua hotword collegandoti a Snowboy https://snowboy.kitt.ai/ (https://snowboy.kitt.ai/) e poi scaricare il file generato che fungerà da modello.

Una volta scaricato, posiziona il file nella tua cartella config personale e imposta snowboy con la seguente tabella

| parametro   |necessario|  tipo  | default | valori possibili| commento                                                                                                                         |
|-------------|----------|--------|---------|-----------------|----------------------------------------------------------------------------------------------------------------------------------|
| pmdl_file   | TRUE     | stringa|         |                 | Percorso del file del modello Snowboy. Il percorso può essere assoluto o relativo al file brain                                  |
| sensitivity | FALSE    | stringa| 0.5     |    tra 0 e 1    | Aumentando il valore di sensibilità si ottiene una migliore velocità di rilevamento, ma anche un più alto tasso di falsi allarmi |

Impostazioni d'esempio

Codice: [Seleziona]
  # Questo è il trigger che catturerà la tua hotword per svegliare Kalliope. Solo Snowboy è disponibile finora
  default_trigger: "snowboy"

  # Caricare la configurazione del trigger
  triggers:
    - snowboy:
      pmdl_file: "trigger/snowboy/resources/kalliope-FR-40samples.pmdl"

Modelli Snowboy disponibili

Se vuoi mantenere "Kalliope" come nome del tuo bot, ti consigliamo di migliorare il modello Snowboy esistente per la tua lingua .

Aggiorneremo il seguente elenco con tutti i modelli che la comunità ha creato per Kalliope. Se il modello non esiste, crearne uno con la seguente sintassi:

Codice: [Seleziona]
  kalliope-<language_code>

Per esempio

 Kalliope-FR
 Kalliope-IT
 Kalliope-RU
 Kalliope-DE
 Kalliope-IT

Quindi, apri una "issue" o crea una "pull request" per aggiungere il modello all'elenco seguente.

    Nota importante: Non migliorare un modello nella lingua sbagliata. Controlla la pronuncia prima di registrare la tua voce!

| Nome                                                 |  lingua  |  Pronuncia   |
|------------------------------------------------------|----------|--------------|
| [kalliope-FR](https://snowboy.kitt.ai/hotword/1363)  | Francese | Ka-lio-pé    |
| [kalliope-EN](https://snowboy.kitt.ai/hotword/2540)  | Inglese  | kə-LIE-ə-pee |
| [kalliope-RU](https://snowboy.kitt.ai/hotword/2964)  | Russo    | каллиопа     |
| [kalliope-DE](https://snowboy.kitt.ai/hotword/4324)  | Tedesco  | Ka-lio-pe    |
| [kalliope-IT](https://snowboy.kitt.ai/hotword/10650) | Italiano | Ka-lljo-pe   |

Player

Codice: [Seleziona]
Sommario

    Parametri d'input
    Esempio d'impostazioni
    Note

mplayer

Player predefinito di kalliope. Questo  Player è basato suli'engine mplayer

Parametri d'input

Nessun parametro richiesto

Esempio d'impostazioni

Codice: [Seleziona]
default_player: "mplayer"

players:
  - mplayer: {}

Note

    Nota: Questo lettore gestisce sia il formato mp3 che wav.

pyalsaaudio

Questo Player è basato sul engine alsa

Parametri d'input

| parametro      |necessario|  default  |valori possibili| commento                                                  |
|----------------|----------|-----------|----------------|-----------------------------------------------------------|
| device         | no       | "default" |                | Seleziona il dispositivo da usare per alsa                |
| convert_to_wav | no       | TRUE      | True, False    | Converti il ​​file generato dal TTS in wav prima di leggere |

Esempio d'impostazioni

Ecco un esempio di configurazione che useresti se il tuo TTS fosse acapela. Poiché questo TTS genera un file MP3, quest'ultimo deve essere convertito in wav.

Codice: [Seleziona]
  default_player: "pyalsaaudio"

  players:
    - pyalsaaudio:
       device: "default"
       convert_to_wav: True

Note

    Nota: Definire la scheda predefinita da utilizzare nel parametro device . Ad esempio, su un Raspberry Pi, la scheda predefinita può essere sysdefault:CARD=ALSA

    Nota: Questo lettore non gestisce il formato mp3, la conversione da mp3 in wav potrebbe essere necessaria se il engine TTS selezionato genera file mp3.

pyaudioplayer

Questo lettore è basato sull'engine pyaudio

Parametri d'input

| parametro      |necessario| default |valori possibili| commento                                                  |
|----------------|----------|---------|----------------|-----------------------------------------------------------|
| convert_to_wav | no       | TRUE    | True, False    | Converti il ​​file generato dal TTS in wav prima di leggere |

Esempio d'impostazioni

Codice: [Seleziona]
  default_player: "pyaudioplayer"

  players:
    - pyaudioplayer:
       convert_to_wav: True

Note

    Nota: Questo lettore non gestisce il formato mp3, potrebbe essere richiesta la conversione da mp3 in wav.

sounddeviceplayer

Questo lettore è basato su engines sounddevice e soundfile

Parametri d'input

| parametro      |necessario| default |valori possibili| commento                                                  |
|----------------|----------|---------|----------------|-----------------------------------------------------------|
| convert_to_wav | no       | TRUE    | True, False    | Converti il ​​file generato dal TTS in wav prima di leggere |

Esempio d'impostazioni

Codice: [Seleziona]
  default_player: "sounddeviceplayer"

  players:
    - sounddeviceplayer:
       convert_to_wav: True

Note

    Nota: Questo lettore non gestisce il formato mp3, è richiesta la conversione da mp3 in wav.

STT

Codice: [Seleziona]
    Sommario
        Parametri d'input
        Esempio d'impostazioni

api.ai

L'STT api.ai si basa sull'API api.ai

Parametri d'input

| parametro |necessario| default | valori possibili                           | commento            |
|-----------|----------|---------|--------------------------------------------|---------------------|
| key       | si       | None    |                                            | Informazioni utente |
| language  | no       | en-US   | [lang](https://docs.api.ai/docs/languages) |                     |

Esempio d'impostazioni

Codice: [Seleziona]
  default_speech_to_text: "apiai"

  speech_to_text:
    - apiai:
        key: "0cbff154af44944a6"
        language: "it"

Bing

L'STT Bing è basato sull'API Microsoft Recognition Voice di Bing

Parametri d'input

| parametro |necessario| default | valori possibili                                                      | commento            |
|-----------|----------|---------|-----------------------------------------------------------------------|---------------------|
| key       | SI       | None    |                                                                       | Informazioni utente |
| language  | No       | en-US   | [lang](https://www.microsoft.com/cognitive-services/en-us/speech-api) | 7 languages         |

Esempio d'impostazioni

Codice: [Seleziona]
  default_speech_to_text: "bing"

  speech_to_text:
   - bing :
        key: "9e48ddaf75904838bedc11aea6b36fb0"
        language: "it"
      

CMUSphinx

Codice: [Seleziona]
Sommario

    Installazione
    Parametri d'input
    Esempio d'impostazioni
    Usando parole chiave

Questo modulo è una soluzione STT auto-ospitata (offline) basata sull'engine CMUSPhinx. Di base, è disponibile solo la lingua inglese. È possibile scaricare altre lingue dal repository principale e installarle seguendo la documentazione ufficiale .

Installazione

Installa i pacchetti

Codice: [Seleziona]
  sudo apt-get install swig libpulse-dev

Quindi installa la lib per python

  sudo pip installa pocketphinx

Parametri d'input

| Parametro       |Necessario|  Tipo   | Default |Valori possibili| Commento                                                                                                                                      |
| --------------- | -------- | ------- | ------- |----------------| --------------------------------------------------------------------------------------------------------------------------------------------- |
| language        | no       | stringa | en-US   |                | [Installare altre lingue](https://github.com/Uberi/speech_recognition/blob/master/reference/pocketsphinx.rst#installing-other-languages)      |
| keyword_entries | no       | elenco  |         |                | Elenco di tuple nella forma (keyword, sensitivity), dove keyword è una frase e sensitivity è la sensibilità al riconoscimento di questa frase |
| grammar_file    | no       | stringa |         |                | Percorso file grammaticali FSG o JSGF. Nota: se vengono passati `keyword_entries`, `grammar_file` verrà ignorato                              |

Esempio d'impostazioni

Codice: [Seleziona]
  default_speech_to_text: "cmusphinx"

  speech_to_text:
   - cmusphinx :
        language: "it-IT"

Usare le parole chiave

Sphinx di solito opera in "transcription mode" e restituirà tutte le parole che riconosce.
L'aggiunta di keyword_entries alle impostazioni restringe il suo spazio di ricerca ed è più accurata della semplice ricerca di quelle stesse parole chiave nelle trascrizioni non basate su parole chiave, perché Sphinx sa esattamente quali suoni cercare.
Il parametro keyword_entries prevede un elenco di tuple composto da una frase e un livello di sensibilità che definiscono la sensibilità di questa frase al riconoscitore, su una scala da 0 (molto insensibile, più falsi negativi) a 1 (molto sensibile, più falsi positivi).

Codice: [Seleziona]
  default_speech_to_text: "cmusphinx"

  speech_to_text:
   - cmusphinx :
        language: "it-IT"
        keyword_entries:
          - ["Ciao", 0.8]
          - ["Ferma la musica", 0.6]

Google

L'STT di Google è basato sull'API Google Speech Recognition. Questo STT è gratuito per meno di 60 minuti di utilizzo al mese. Dopo ciò hai bisogno di un abbonamento.

Parametri d'input

| parametro |necessario| default | valori possibili                                                              | commento   |
|-----------|----------|---------|-------------------------------------------------------------------------------|------------|
| key       | No       | None    |                                                                               |            |
| language  | No       | en-US   | [lang](https://en.wikipedia.org/wiki/Google_Voice_Search#Supported_languages) |stringa LCID|

Esempio d'impostazioni

Utilizzo gratuito

Codice: [Seleziona]
  default_speech_to_text: "google"

  speech_to_text:
   - google:
       language: "it-IT"

Per gli utenti paganti

  default_speech_to_text: "google"

  speech_to_text:
   - google:
       language: "it-IT
       key: "my_google_stt_key"

Houndify

Questo STT è basato sul engine Houndify .

Questo STT supporta solo l'inglese.

Parametri d'input

| parametro |necessario| default |valori possibili| commento          |
|:---------:|----------|---------|----------------|-------------------|
| key       | Yes      | None    |                |Informazioni utente|
| client_id | Yes      | None    |                |Informazioni utente|

Esempio d'impostazioni

Codice: [Seleziona]
  default_speech_to_text: "houndify"

  speech_to_text:
   - houndify :
       key: "my_user_key"
       client_id : "my_user_client_id"
      

wit.ai

La wit STT è basata sull'API Wit.ai

Parametri d'input

| parametro |necessario| default |valori possibili| commento          |
|:---------:|----------|---------|----------------|-------------------|
| key       | Yes      | None    |                |Informazioni utente|

Esempio d'impostazioni

Codice: [Seleziona]
  default_speech_to_text: "wit"

  speech_to_text:
   - wit:
        key: "my_user_key"

TTS

Codice: [Seleziona]
Sommario

    Parametri d'input
    Installazione
    Esempio d'impostazioni
Note

eSpeak

Questo TTS è basato sull'engine eSpeak.

Parametri d'input

| Parametro  |Necessario| Default         | Valori possibili         | Commento                                                           |
| ---------- | -------- | --------------- | ------------------------ | ------------------------------------------------------------------ |
| voice      | si       |                 | tutte le voci installate | guarda l'elenco completo con il comando "espeak --voices=LANGUAGE" |
| variant    | no       |                 |tutte le lingue installate| guarda l'elenco completo con il comando "espeak --voices=variant"  |
| speed      | no       | 160             | 80 to 450                | Velocità in parole per minuto                                      |
| amplitude  | no       | 100             |  0 to 200                | Ampiezza                                                           |
| pitch      | no       | 50              |  0 to  99                | Regolazione del pitc                                               |
| path       | no       | /usr/bin/espeak |  0 to  99                | Percorso di espeak                                                 |
| cache      | no       | TRUE            |                          | True se si desidera utilizzare la cache con questo TTS             |

Installazione

Espeak deve essere installato con:

  sudo apt-get install espeak

Per vedere l'elenco completo di lingue e voci:

  espeak --voices

Per vedere l'elenco completo delle voci:

  espeak --voices=LANGUAGE

Esempio:

   espeak --voices=fr
   Pty Language Age/Gender VoiceName          File          Other Languages
    5  fr-fr          M  french               fr            (fr 5)
    7  fr             M  french-mbrola-1      mb/mb-fr1
    7  fr             F  french-mbrola-4      mb/mb-fr4
    5  fr-be          M  french-Belgium       europe/fr-be  (fr 8)

Configurazione per "7 fr M french-mbrola-1 mb/mb-fr1"

  voice: "mb-fr1"

Per vedere l'elenco completo delle varianti:

  espeak --voices=variant

Esempio:

   espeak --voices=variant
   Pty Language Age/Gender VoiceName          File          Other Languages
    5  variant        F  female2              !v/f2
    5  variant        F  female3              !v/f3
    5  variant        F  female4              !v/f4
    5  variant        F  female5              !v/f5
    5  variant        F  female_whisper       !v/whisperf
    5  variant        -  klatt                !v/klatt
    5  variant        -  klatt2               !v/klatt2
    [...]

Configurazione per "5 variant F female3 !v/f3".

   voice: "fr"
   variant: "f3"

Esempio d'impostazioni

  default_text_to_speech: "espeak"

  text_to_speech:
    - espeak:
        voice: "fr"
        variant: "f3"

googletts

Questo TTS è basato sul Google translate engine

Parametri d'input

| Parametro  |Necessario| Default | Valori possibili                                                              | Commento                                                                                                        |
| ---------- | -------- | ------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| language   | YES      |         | [103 lingue](http://translate.google.com/about/intl/en_ALL/languages.html)    | Le lingue sono identificate con i loro codici ISO_639-1 (https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) |
| cache      | No       | TRUE    | True / False                                                                  | True se si desidera utilizzare la cache con questo TTS                                                          |

Esempio d'impostazioni

   default_text_to_speech : "googletts"

   text_to_speech:
      - googletts:
         language: "fr"
      

marytts
   
MaryTTS è una piattaforma open-source di sintesi vocale multilingue scritta in Java.

Parametri d'input

| Parametro  |Necessario| Default   | Valori possibili                  | Commento                                                            |
| ---------- | -------- | --------- | --------------------------------- | ------------------------------------------------------------------- |
| voice      | si       | None      | es. bits1, cmu-bdl, enst-camille  | Esegui "./marytts list" per controllare le voci installate          |
| locale     | si       | None      | es. de, en_US, fr                 | Controlla "http://localhost:59125/locales" per le lingue installate |
| host       | no       | localhost |                                   | Indirizzo host del tuo server MaryTTS                               |
| port       | no       | 59125     |                                   | Porta del tuo server MaryTTS                                        |

Esempio d'impostazioni

Per la voce inglese su localhost aggiungi le seguenti righe nel tuo settings.yml:

   text_to_speech:
     - marytts:
        voice: "cmu-bdl"
        locale: "en_US"
        cache: True

Per voce inglese su host remoto con porta predefinita:

   text_to_speech:
     - marytts:
        voice: "cmu-bdl"
        locale: "en_US"
        host: 192.168.0.25
        cache: True

Note :

    Nota: E' necessario installare il server Marytts .
   
pico2wave
   
Questo TTS è basato sull'engine SVOX picoTTS

Parametri d'input

| Parametro  |Necessario| Default            |Valori possibili| Commento                                                                                                                                                        |
| ---------- | -------- | ------------------ | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| language   | si       |                    | 6 lingue       | Elenco delle lingue supportate nella sezione Note                                                                                                               |
| cache      | no       | TRUE               | True,  False   | True se si desidera utilizzare la cache con questo TTS                                                                                                          |
| samplerate | no       |                    | int            | Pico2wave crea file da 16 khz ma non tutti i dispositivi USB supportano questo. Impostare un valore da convertire in un samplerate specifico. Ad esempio: 44100 |
| path       | no       | /usr/bin/pico2wave |                | Percorso di Pico2wave. Se non impostato, Kalliope proverà a caricarlo dall'environment                                                                          |

Esempio d'impostazioni

  default_text_to_speech : "pico2wave"

   text_to_speech:
      - pico2wave:
         language: "fr-FR"
         cache: True

Note

Lingue supportate:

    Inglese en-US
    Inglese en-GB
    Francese FR-FR
    Spagnolo ES-ES
    Tedesco de-DE
    Italiano it-IT
   
   
voicerss
   
Questo TTS è basato sull'engine VoiceRSS. Documentazione ufficiale qui

Parametri d'input

| Parametro    |Necessario| Default              | Valori possibili                                                                | Commento                                                 |
| ------------ | -------- | -------------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------- |
| language     | SI       |                      | [26 llingue](http://www.voicerss.org/api/documentation.aspx), esempio : "fr-fr" | Le lingue sono identificate dalla stringa LCID           |
| key          | SI       |                      |                                                                                 | registrati nel sito web ufficiale per ottenere la key API|
| rate         | NO       | 0                    | qualunque intero "int"                                                          | Frequenza audio                                          |
| codec        | NO       | 'MP3'                | 'MP3', 'WAV', 'AAC', 'OGG', 'CAF'                                               | Codec audio                                              |
| audio_format | NO       | '44khz_16bit_stereo' | [51 scelte](http://www.voicerss.org/api/documentation.aspx), '8khz_8bit_mono'   | Formati audio                                            |
| ssml         | NO       | False                | True / False                                                                    | True se si desidera usare ssml (solo a pagamento)        |
| base64       | NO       | False                | True / False                                                                    | True se si desidera usare  base64                        |
| ssl          | NO       | False                | True / False                                                                 
Titolo: Re:Creare l'antenato dell'HAL9000 con Kalliope
Inserito da: Plasmodium - 03 Marzo 2019, 19:52
 :)
riservato
Titolo: Re:Creare l'antenato dell'HAL9000 con Kalliope
Inserito da: Plasmodium - 03 Marzo 2019, 19:52
 :)
riservato
Titolo: Re:Creare l'antenato dell'HAL9000 con Kalliope
Inserito da: zoomx - 05 Marzo 2019, 12:13
Da provare!
Ti sei dimenticato di aggiungere all'inizio il fatto che ci vuole una pennetta audio USB!
Titolo: Re:Creare l'antenato dell'HAL9000 con Kalliope
Inserito da: -Mirco- - 24 Marzo 2019, 00:27
Figatissima  :D
Appena recupero nuovamente un rasp provo!