Creare l'antenato dell'HAL9000 con Kalliope

  • 6 Risposte
  • 530 Visite

0 Utenti e 1 Visitatore stanno visualizzando questo topic.

Offline Plasmodium

  • Nuovo Iscritto
  • *
  • 30
  • Sesso: Maschio
Creare l'antenato dell'HAL9000 con Kalliope
« il: 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:
  • Scarica da https://github.com/kalliope-project/kalliope/releases l'img.zip
  • Scompatta questa immagine e clonala sulla tua scheda SD come fate solito per un Raspberry Pi.
  • Verificare che l'ingresso e l'uscita audio funzionino correttamente. Per questo, registra la tua voce:
Codice: [Seleziona]
rec test.wav
  • Premi CTRL-C per interrompere la registrazione, quindi ascolta la registrazione con il seguente comando.
Codice: [Seleziona]
mplayer test.wav
    Con 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
    • un'uscita analogica (o il jack è collegato) sulla scheda 0 e sul dispositivo 0 (card0, device0)
    • un'uscita audio USB su scheda 1 e dispositivo 0 (scheda 1, dispositivo 0)

    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:
    • l'uscita audio (che ci dice Kalliopé) si trova sull'uscita analogica (il jack)
    • l'ingresso audio (quello che viene detto in Kalliopé) sulla micro USB
       
    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

    Offline Plasmodium

    • Nuovo Iscritto
    • *
    • 30
    • Sesso: Maschio
    Re:Creare l'antenato dell'HAL9000 con Kalliope
    « Risposta #1 il: 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/ 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  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:

    • Tramite l'immagine del disco precompilato
    • Tramite script
    • manualmente

    Installa tramite l'immagine del disco precompilata

    Scarica l'ultima immagine dalla pagina di rilascio di Kalliope 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:

    •     l'audio analogico (dove è collegato il jack) è su card 0 e device 1
    •     l'audio USB è su card 1 e device 1

    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:

    •     uscita audio (voce di Kalliope) sull'audio analogico (tramite altoparlanti collegati al jack)
    •     input audio (ciò che viene detto a Kalliope) sul microfono USB

    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 :



    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:

    •     it_IT.utf8
    •     en_GB.utf8
    •     fr_FR.utf8
    •     es_ES.utf8

    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:

    •     Dalla tua cartella corrente, Eg /home/pi/my_kalliope/
    •     Da /etc/kalliope/
    •     Dal settings.yml e brain.yml di default che si trovano nel root del progetto Kalliope.

    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:

    •     an order: Qualcosa che è stato pronunciato ad alta voce dall'utente.
    •     an event: Una data o una azione ripetuta (EG: ripetere ogni mattina alle 8:30)
    •     a mqtt message Un messaggio ricevuto su un argomento MQTT
    •     a geolocation Dalla posizione del tuo smartphone
    •     a community signal Ad esempio: Usando una GPIO consente di attivare azioni da un pulsante
    •     No signal. La sinapsi può essere chiamata solo da un'altra sinapsi o dall'API

    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:

    •     Dalla cartella corrente, ad es. /home/pi/my_kalliope/settings.yml
    •     Da /etc/kalliope/settings.yml
    •     Di default cerca `settings.yml` nella cartella principale del progetto.

    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/) |
    « Ultima modifica: 03 Marzo 2019, 19:50 da Plasmodium »

    Offline Plasmodium

    • Nuovo Iscritto
    • *
    • 30
    • Sesso: Maschio
    Re:Creare l'antenato dell'HAL9000 con Kalliope
    « Risposta #2 il: 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:

    •     Elencare le sinapsi
    •     Ottenere i dettagli delle sinapsi
    •     Eseguire una sinapsi
    •     Aggiornare le impostazioni
    •     Aggiornare il brain

    Per la lista completa delle API vedi la documentazione 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/ 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                                                                 

    Offline Plasmodium

    • Nuovo Iscritto
    • *
    • 30
    • Sesso: Maschio
    Re:Creare l'antenato dell'HAL9000 con Kalliope
    « Risposta #3 il: 03 Marzo 2019, 19:52 »
     :)
    riservato

    Offline Plasmodium

    • Nuovo Iscritto
    • *
    • 30
    • Sesso: Maschio
    Re:Creare l'antenato dell'HAL9000 con Kalliope
    « Risposta #4 il: 03 Marzo 2019, 19:52 »
     :)
    riservato

    Offline zoomx

    • Esperto
    • ****
    • 543
    Re:Creare l'antenato dell'HAL9000 con Kalliope
    « Risposta #5 il: 05 Marzo 2019, 12:13 »
    Da provare!
    Ti sei dimenticato di aggiungere all'inizio il fatto che ci vuole una pennetta audio USB!

    Offline -Mirco-

    • Administrator
    • Esperto
    • *****
    • 1835
    • Sesso: Maschio
    • "Non esiste curva in cui non si può superare"
      • Ilpuntotecnicoeadsl
    Re:Creare l'antenato dell'HAL9000 con Kalliope
    « Risposta #6 il: 24 Marzo 2019, 00:27 »
    Figatissima  :D
    Appena recupero nuovamente un rasp provo!
    "Non esiste curva in cui non si può superare"
    Ayrton Senna