（５）スピーカーに収納する

- radiko-esp32-main_04/
      - components/
                   - radiko-esp32/
                              - CMakeLists.txt
                              - Kconfig.projbuild
                              - radiko.c
                              - radiko.h
                              - radiko_jp_rootcert.pem
                   - my_board/
                              - my_board_v1_0/
                                        - board.c
                                        - board.h
                                        - board_def.h
                                        - board_pins_config.c
                              - AQM0802A/
                                        - AQM0802A.c
                                        - AQM0802A.h
                              - CMakeLists.txt
      - main/
                   - CMakeLists.txt
                   - Kconfig.projbuild
                   - play_radiko.c
      - CMakeLists.txt
      - partitions.csv
      - sdkconfig.defaults

#ifndef _AUDIO_BOARD_DEFINITION_H_
#define _AUDIO_BOARD_DEFINITION_H_

#define BUTTON_CHG_CHAN    GPIO_NUM_39   /* You need to define the GPIO pins of your board */
#define BUTTON_CHG_BAND    GPIO_NUM_36   /* You need to define the GPIO pins of your board */

#define AUDIO_CODEC_DEFAULT_CONFIG(){                   \
        .adc_input  = AUDIO_HAL_ADC_INPUT_LINE1,        \
        .dac_output = AUDIO_HAL_DAC_OUTPUT_ALL,         \
        .codec_mode = AUDIO_HAL_CODEC_MODE_BOTH,        \
        .i2s_iface = {                                  \
            .mode = AUDIO_HAL_MODE_SLAVE,               \
            .fmt = AUDIO_HAL_I2S_NORMAL,                \
            .samples = AUDIO_HAL_48K_SAMPLES,           \
            .bits = AUDIO_HAL_BIT_LENGTH_16BITS,        \
        },                                              \
};

#define INPUT_KEY_NUM     2             /* You need to define the number of input buttons on your board */

#define INPUT_KEY_DEFAULT_INFO() {                      \
    {                                                   \
        .type = PERIPH_ID_BUTTON,                       \
        .user_id = INPUT_KEY_USER_ID_CHG_CHAN,          \
        .act_id = BUTTON_CHG_CHAN,                      \
    },                                                  \
    {                                                   \
        .type = PERIPH_ID_BUTTON,                       \
        .user_id = INPUT_KEY_USER_ID_CHG_CHAN,          \
        .act_id = BUTTON_CHG_BAND,                      \
    },                                                  \
}

/* Play M3U HTTP Living stream


   This example code is in the Public Domain (or CC0 licensed, at your option.)
   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "esp_log.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "audio_element.h"
#include "audio_pipeline.h"
#include "audio_event_iface.h"
#include "audio_common.h"
#include "http_stream.h"
#include "i2s_stream.h"
#include "aac_decoder.h"
#include "mp3_decoder.h"
#include "esp_tls.h"
#include "esp_http_client.h"
#include "radiko.h"
#include "esp_peripherals.h"
#include "periph_wifi.h"
#include "board.h"
#include "AQM0802A.h"
#include "esp_adc_cal.h"
#include "driver/timer.h"
#include "driver/gpio.h"

#if __has_include("esp_idf_version.h")
#include "esp_idf_version.h"
#else
#define ESP_IDF_VERSION_VAL(major, minor, patch) 1
#endif

#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 1, 0))
#include "esp_netif.h"
#else
#include "tcpip_adapter.h"
#endif

#define TIMER_DIVIDER         (16)  //  Hardware timer clock divider
#define TIMER_SCALE           (TIMER_BASE_CLK / TIMER_DIVIDER)  // convert counter value to seconds

#define MAX_HTTP_RECV_BUFFER 512
#define MAX_HTTP_content 8192

#define chk_channel     33
#define channel_chg     39
#define chg_band		36

#define _no_data        0
#define _radiko	        1
#define _shtmp3			2
#define _shtaac			3

static const char *TAG = "HTTP_LIVINGSTREAM_EXAMPLE";

#define DEFAULT_VREF    3900        					//Use adc2_vref_to_gpio() to obtain a better estimate
static const adc_atten_t atten = ADC_ATTEN_DB_11;
static const adc_unit_t unit = ADC_UNIT_1;
static const adc_channel_t channel = ADC_CHANNEL_4;     //GPIO32 if ADC1, GPIO14 if ADC2
static const adc_bits_width_t width = ADC_WIDTH_BIT_12;
static esp_adc_cal_characteristics_t *adc_chars;

audio_pipeline_handle_t pipeline;
audio_element_handle_t http_stream_reader, i2s_stream_writer, aac_decoder, mp3_decoder;

struct st_info {         //Station info
    int _deco;
    int _st_no;
    char _st_ID[20];
    char _st_URL[200];
};

struct st_info station_info[] = {
	{_radiko, 0, "0", "0"},
	{_radiko, 1, "0", "0"},
	{_radiko, 2, "0", "0"},
	{_radiko, 3, "0", "0"},
	{_radiko, 4, "0", "0"},
	{_radiko, 5, "5", "0"},
	{_radiko, 6, "6", "0"},
	{_radiko, 7, "0", "0"},
	{_radiko, 8, "0", "0"},
	{_radiko, 9, "0", "0"},
	{_radiko, 10, "0", "0"},
	{_radiko, 11, "0", "0"},
	{_radiko, 12, "0", "0"},
	{_radiko, 13, "0", "0"},
	{_radiko, 14, "0", "0"},
	{_radiko, 15, "0", "0"},
	{_no_data, 16, "0", "0"},
	{_no_data, 17, "0", "0"},
	{_shtmp3, 18, "Classic", "http://yp.shoutcast.com/sbin/tunein-station.pls?id=22146"},
	{_shtmp3, 19, "JAZZ1", "http://yp.shoutcast.com/sbin/tunein-station.pls?id=1528122"},
	{_shtmp3, 20, "TOP40", "http://yp.shoutcast.com/sbin/tunein-station.pls?id=1914279"},
	{_shtmp3, 21, "Piano", "http://yp.shoutcast.com/sbin/tunein-station.pls?id=99513978"},
	{_shtmp3, 22, "Dance", "http://yp.shoutcast.com/sbin/tunein-station.pls?id=1817772"},
	{_shtaac, 23, "Antena", "http://yp.shoutcast.com/sbin/tunein-station.pls?id=1796249"}
};

int st_now;

int get_ADC_staion_no()
{
	int data,no,flg;
    int btn_array[13] = {80, 217, 475, 740, 1005, 1285, 1535, 1785, 2055, 2300, 2540, 2800, 3100};

    uint32_t adc_reading = 0;
    for (int no = 0; no < 64; no ++)
               adc_reading += adc1_get_raw((adc1_channel_t)ADC_CHANNEL_4);

 	data = adc_reading / 64;
	flg = 1; no = 0;
	while(flg)
	{
		if(data < btn_array[no + 1]) flg = 0;
		else no ++;

		if(no > 11) { no = 11; flg = 0;	}
	}

	if(gpio_get_level(chg_band)) no += 12;

	return no;
}

void IRAM_ATTR timer_group_isr_callback(void *args)
{
	if(st_now != get_ADC_staion_no())
	{
		timer_pause(TIMER_GROUP_0, TIMER_0);
		gpio_set_level(chk_channel,!gpio_get_level(channel_chg));
	}

	timer_group_clr_intr_status_in_isr(TIMER_GROUP_0, TIMER_0);
	timer_group_enable_alarm_in_isr(TIMER_GROUP_0, TIMER_0);

}

void init_port(void)
{
    gpio_config_t io_conf = {};
    io_conf.mode = GPIO_MODE_INPUT;	    			//set as input mode
    io_conf.pin_bit_mask = 0x9ULL << 36;			//bit mask of the pins GPIO36,39
    io_conf.pull_up_en = 0;						    //disable pull-up mode
    gpio_config(&io_conf);

    io_conf.intr_type = GPIO_INTR_DISABLE;			//disable interrupt
    io_conf.mode = GPIO_MODE_OUTPUT;				//set as input mode
    io_conf.pin_bit_mask = 1ULL << chk_channel;		//bit mask of the pins GPIO36,39
    gpio_config(&io_conf);
	gpio_set_level(chk_channel, 1);					//set high

    adc1_config_width(width);
    adc1_config_channel_atten(channel, atten);
    adc_chars = calloc(1, sizeof(esp_adc_cal_characteristics_t));
  	esp_adc_cal_characterize(unit, atten, width, DEFAULT_VREF, adc_chars);

	timer_config_t config = {
        .divider = TIMER_DIVIDER,
        .counter_dir = TIMER_COUNT_UP,
        .counter_en = TIMER_PAUSE,
        .alarm_en = TIMER_ALARM_EN,
        .auto_reload = true,
	};

    timer_init(TIMER_GROUP_0, TIMER_0, &config);					// For the timer counter to a initial value
    timer_set_counter_value(TIMER_GROUP_0, TIMER_0, 0);				// Set alarm value and enable alarm interrupt
    timer_set_alarm_value(TIMER_GROUP_0, TIMER_0, TIMER_SCALE / 2);	// 0.5 sec
	timer_isr_register(TIMER_GROUP_0, TIMER_0, timer_group_isr_callback, (void *) TIMER_0, ESP_INTR_FLAG_IRAM, NULL);
}

int _http_stream_event_handle(http_stream_event_msg_t *msg)
{
    if (msg->event_id == HTTP_STREAM_RESOLVE_ALL_TRACKS) {
        return ESP_OK;
    }

    if (msg->event_id == HTTP_STREAM_FINISH_TRACK) {
        return http_stream_next_track(msg->el);
    }
    if (msg->event_id == HTTP_STREAM_FINISH_PLAYLIST) {
        return http_stream_fetch_again(msg->el);
    }
    return ESP_OK;
}

void print_station_info(int st_no)
{
	char c_buf[30];

	AQM0802A_clear();
	sprintf(&c_buf[10], "%02d", st_no);
	strcpy(c_buf,"Ch ");
	strcat(c_buf,&c_buf[10]);
	AQM0802A_setCursor(1, 0);
	AQM0802A_print(c_buf);

	switch(station_info[st_no]._deco)
    {
        case _no_data:  strcpy(c_buf, "No_Data");
			    		break;

		case _radiko: 	strcpy(c_buf, (stations + st_no)->id);
			    		break;
		case _shtmp3:
		case _shtaac: 	strcpy(c_buf, station_info[st_no]._st_ID);
						break;

	}

	st_no = strlen(c_buf);
	if(st_no > 8) {  c_buf[8] = 0; st_no = 8; }
	st_no = 8 - st_no;
	st_no /= 2;
	AQM0802A_setCursor(st_no, 1);
	AQM0802A_print(c_buf);

}

void app_main(void)
{
	int flg_no;

    esp_err_t err = nvs_flash_init();
    if (err == ESP_ERR_NVS_NO_FREE_PAGES)
    {
        ESP_ERROR_CHECK(nvs_flash_erase());
        err = nvs_flash_init();
    }
#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 1, 0))
    ESP_ERROR_CHECK(esp_netif_init());
#else
    tcpip_adapter_init();
#endif

	init_port();
	i2c_master_init();
	AQM0802A_init();

    esp_log_level_set("*", ESP_LOG_INFO);
    esp_log_level_set(TAG, ESP_LOG_DEBUG);

    ESP_LOGI(TAG, "[ 3 ] Start and wait for Wi-Fi network");
    esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
    esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);

    ESP_LOGI(TAG, "[3.1] Initialize keys on board");
    audio_board_key_init(set);

    AQM0802A_clear();
	AQM0802A_setCursor(0, 0);
	AQM0802A_print("Connect");
	AQM0802A_setCursor(2, 1);
	AQM0802A_print("WiFi");

    periph_wifi_cfg_t wifi_cfg =
    {
        .ssid = CONFIG_WIFI_SSID,
        .password = CONFIG_WIFI_PASSWORD,
    };

    esp_periph_handle_t wifi_handle = periph_wifi_init(&wifi_cfg);
    esp_periph_start(set, wifi_handle);
    periph_wifi_wait_for_connected(wifi_handle, portMAX_DELAY);

//------------------------------------------------------------------------------------
    AQM0802A_clear();
	AQM0802A_setCursor(1, 0);
	AQM0802A_print("Create");
	AQM0802A_setCursor(0, 1);
	AQM0802A_print("pipeline");
    ESP_LOGI(TAG, "[2.0] Create audio pipeline for playback");
    audio_pipeline_cfg_t pipeline_cfg = DEFAULT_AUDIO_PIPELINE_CONFIG();
    pipeline = audio_pipeline_init(&pipeline_cfg);

    ESP_LOGI(TAG, "[2.1] Create http stream to read data");
    http_stream_cfg_t http_cfg = HTTP_STREAM_CFG_DEFAULT();
    http_cfg.event_handle = _http_stream_event_handle;
    http_cfg.type = AUDIO_STREAM_READER;
    http_cfg.enable_playlist_parser = true;
    http_stream_reader = http_stream_init(&http_cfg);

    ESP_LOGI(TAG, "[2.2] Create i2s stream to write data to codec chip");
    i2s_stream_cfg_t i2s_cfg = I2S_STREAM_CFG_DEFAULT();
    i2s_cfg.type = AUDIO_STREAM_WRITER;
    i2s_stream_writer = i2s_stream_init(&i2s_cfg);

    ESP_LOGI(TAG, "[2.3] Create aac decoder to decode aac file");
    aac_decoder_cfg_t aac_cfg = DEFAULT_AAC_DECODER_CONFIG();
    aac_decoder = aac_decoder_init(&aac_cfg);

    ESP_LOGI(TAG, "[2.3M] Create mp3 decoder to decode mp3 file");
    mp3_decoder_cfg_t mp3_cfg = DEFAULT_MP3_DECODER_CONFIG();
    mp3_decoder = mp3_decoder_init(&mp3_cfg);

    const char *m_link_tag[3] = {"http", "mp3", "i2s"};
   	const char *link_tag[3] = {"http", "aac", "i2s"};

   	ESP_LOGI(TAG, "[2.4] Register all elements to audio pipeline");
   	audio_pipeline_register(pipeline, http_stream_reader, "http");
   	audio_pipeline_register(pipeline, aac_decoder,        "aac");
   	audio_pipeline_register(pipeline, i2s_stream_writer,  "i2s");
   	audio_pipeline_register(pipeline, mp3_decoder,        "mp3");

	st_now = get_ADC_staion_no();

    switch(station_info[st_now]._deco)
    {
    	case _radiko:
    	case _shtaac:	ESP_LOGI(TAG, "[2.5] Link it together http_stream-->aac_decoder-->i2s_stream-->[codec_chip]");
    					audio_pipeline_link(pipeline, &link_tag[0], 3);
    					break;

    	case _shtmp3: 	ESP_LOGI(TAG, "[2.5M] Link it together http_stream-->mp3_decoder-->i2s_stream-->[codec_chip]");
     					audio_pipeline_link(pipeline, &m_link_tag[0], 3);
     					break;
	}

    ESP_LOGI(TAG, "[ 4 ] Set up  event listener");
    audio_event_iface_cfg_t evt_cfg = AUDIO_EVENT_IFACE_DEFAULT_CFG();
    audio_event_iface_handle_t evt = audio_event_iface_init(&evt_cfg);

    ESP_LOGI(TAG, "[4.1] Listening event from all elements of pipeline");
    audio_pipeline_set_listener(pipeline, evt);

    ESP_LOGI(TAG, "[4.2] Listening event from peripherals");
    audio_event_iface_set_listener(esp_periph_set_get_event_iface(set), evt);

//------------------------------------------------------------------------------------
    AQM0802A_clear();
	AQM0802A_setCursor(1, 0);
	AQM0802A_print("Setup");
	AQM0802A_setCursor(1, 1);
	AQM0802A_print("Radiko");
  	auth();
    get_station_list();

    switch(station_info[st_now]._deco)
    {
        case _radiko:   ESP_LOGI(TAG, "[2.6] Set up radiko uri)");
		                generate_playlist_url(stations + st_now);
		                audio_element_set_uri(http_stream_reader, _playlist_url);
		                break;

	    case _shtmp3:
	    case _shtaac:   ESP_LOGI(TAG, "[2.6M] Set up shoutcast uri");
		                audio_element_set_uri(http_stream_reader, station_info[st_now]._st_URL);
		                break;
	}

	ESP_LOGI(TAG, "[ 5 ] Start audio_pipeline");
	if(station_info[st_now]._deco)
	    audio_pipeline_run(pipeline);

	print_station_info(st_now);

    timer_start(TIMER_GROUP_0, TIMER_0);				// Start timer

    while (1)
    {
        audio_event_iface_msg_t msg;
        esp_err_t ret = audio_event_iface_listen(evt, &msg, portMAX_DELAY);
        if (ret != ESP_OK)
        {
            ESP_LOGE(TAG, "[ * ] Event interface error : %d", ret);
            continue;
        }

	    if(msg.cmd == AEL_MSG_CMD_REPORT_MUSIC_INFO)
	    {
	        audio_element_info_t music_info = {0};
		    switch(station_info[st_now]._deco)
    		{
		        case _radiko:
		        case _shtaac:
    	    				    audio_element_getinfo(aac_decoder, &music_info);
    	    				    ESP_LOGI(TAG, "[ * ] Receive music info from aac decoder, sample_rates=%d, bits=%d, ch=%d",
    	    				         music_info.sample_rates, music_info.bits, music_info.channels);
 					    	    break;

				case _shtmp3:   audio_element_getinfo(mp3_decoder, &music_info);
		    				    ESP_LOGI(TAG, "[ * ] Receive music info from mp3 decoder, sample_rates=%d, bits=%d, ch=%d",
		    				             music_info.sample_rates, music_info.bits, music_info.channels);
		    				    break;
			}
		    audio_element_setinfo(i2s_stream_writer, &music_info);
		    i2s_stream_set_clk(i2s_stream_writer, music_info.sample_rates, music_info.bits, music_info.channels);
		}

   		if (msg.source_type == AUDIO_ELEMENT_TYPE_ELEMENT && msg.source == (void *) http_stream_reader
		            && msg.cmd == AEL_MSG_CMD_REPORT_STATUS && (int) msg.data == AEL_STATUS_ERROR_OPEN)
        {
	        ESP_LOGW(TAG, "[ * ] Restart stream");
	        audio_pipeline_stop(pipeline);
	        audio_pipeline_wait_for_stop(pipeline);

	        if(station_info[st_now]._deco == _shtmp3)
		        audio_element_reset_state(mp3_decoder);
			else
    	        audio_element_reset_state(aac_decoder);

			audio_element_reset_state(i2s_stream_writer);
	        audio_pipeline_reset_ringbuffer(pipeline);
	        audio_pipeline_reset_items_state(pipeline);
	        audio_pipeline_run(pipeline);
	        continue;
	    }

        if (msg.source_type == PERIPH_ID_BUTTON)
        {
			timer_pause(TIMER_GROUP_0, TIMER_0);
        	vTaskDelay(1000 / portTICK_PERIOD_MS);
	        flg_no = get_ADC_staion_no();

    	    if( flg_no != st_now)
    	    {
  	        	if(station_info[st_now]._deco)
  	        	{
		        	audio_pipeline_stop(pipeline);
   			        audio_pipeline_wait_for_stop(pipeline);
					audio_pipeline_terminate(pipeline);
   					audio_pipeline_unlink(pipeline);
    				audio_pipeline_remove_listener(pipeline);
				}
    	   		st_now = flg_no;
  	        	ESP_LOGI(TAG, "Station No:%d",flg_no);

			    switch(station_info[st_now]._deco)
		    	{
		    		case _shtmp3:	ESP_LOGI(TAG, "[2.5M] Link it together http_stream-->mp3_decoder-->i2s_stream-->[codec_chip]");
						    		audio_pipeline_link(pipeline, &m_link_tag[0], 3);
    						        audio_element_set_uri(http_stream_reader, station_info[st_now]._st_URL);
						            break;

					case _shtaac:
					case _radiko: 	ESP_LOGI(TAG, "[2.5] Link it together http_stream-->aac_decoder-->i2s_stream-->[codec_chip]");
						    		audio_pipeline_link(pipeline, &link_tag[0], 3);

									if(station_info[st_now]._deco == _radiko)
									{
										generate_playlist_url(stations + st_now);
		    							audio_element_set_uri(http_stream_reader, _playlist_url);
		    						}
									else audio_element_set_uri(http_stream_reader, station_info[st_now]._st_URL);
						            break;
		       	}
    			ESP_LOGI(TAG, "[4.1] Listening event from all elements of pipeline");
    			audio_pipeline_set_listener(pipeline, evt);
  	        	if(station_info[st_now]._deco)
					audio_pipeline_run(pipeline);
			   	print_station_info(st_now);
        	}
    		//Start timer interrupt
			timer_start(TIMER_GROUP_0, TIMER_0);
  		}
    }

    ESP_LOGI(TAG, "[ 6 ] Stop audio_pipeline");
    audio_pipeline_stop(pipeline);
    audio_pipeline_wait_for_stop(pipeline);
    audio_pipeline_terminate(pipeline);

    audio_pipeline_unregister(pipeline, http_stream_reader);
    audio_pipeline_unregister(pipeline, i2s_stream_writer);
    audio_pipeline_unregister(pipeline, aac_decoder);

    /* Terminate the pipeline before removing the listener */
    audio_pipeline_remove_listener(pipeline);

    /* Stop all peripherals before removing the listener */
    esp_periph_set_stop_all(set);
    audio_event_iface_remove_listener(esp_periph_set_get_event_iface(set), evt);

    /* Make sure audio_pipeline_remove_listener & audio_event_iface_remove_listener are called before destroying event_iface */
    audio_event_iface_destroy(evt);

    /* Release all resources */
    audio_pipeline_deinit(pipeline);
    audio_element_deinit(http_stream_reader);
    audio_element_deinit(i2s_stream_writer);
    audio_element_deinit(aac_decoder);
    esp_periph_set_destroy(set);
}