Mercurial > co2meter / file comparison

comparison: main/task_adc.c

main/task_adc.c

changeset 12
7dc9003f86a8
parent 0
88d965579617
child 37
358bbd5b608e
equal deleted inserted replaced
11:e33f2d325d15 12:7dc9003f86a8
7 7
8 #include "config.h" 8 #include "config.h"
9 9
10 10
11 #define DEFAULT_VREF 1093 ///< Use adc2_vref_to_gpio() to obtain a better estimate 11 #define DEFAULT_VREF 1093 ///< Use adc2_vref_to_gpio() to obtain a better estimate
12 #define NO_OF_SAMPLES 64 ///< Multisampling 12 #define NO_OF_SAMPLES 128 ///< Multisampling
13 13
14 14
15 #define PRESSURE_1 (CONFIG_PRESSURE_1) 15 #define PRESSURE_1 (CONFIG_PRESSURE_1)
16 #define PRESSURE_2 (CONFIG_PRESSURE_2) 16 #define PRESSURE_2 (CONFIG_PRESSURE_2)
17 #define PRESSURE_3 (CONFIG_PRESSURE_3) 17 #define PRESSURE_3 (CONFIG_PRESSURE_3)
44 return true; 44 return true;
45 return false; 45 return false;
46 } 46 }
47 47
48 48
49 /*
50 static void print_char_val_type(esp_adc_cal_value_t val_type)
51 {
52 if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) {
53 ESP_LOGI(TAG, "Characterized using Two Point Value");
54 } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
55 ESP_LOGI(TAG, "Characterized using eFuse Vref");
56 } else {
57 ESP_LOGI(TAG, "Characterized using Default Vref");
58 }
59 }
60 */
61
62 49
63 /* 50 /*
64 * Task to read pressure sensors and battery voltage on request. 51 * Task to read pressure sensors and battery voltage on request.
65 */ 52 */
66 void task_adc(void *pvParameter) 53 void task_adc(void *pvParameter)
67 { 54 {
68 int i, adc_reading; 55 int i, adc_reading;
69 adc_atten_t atten = ADC_ATTEN_DB_0; 56 adc_atten_t atten = ADC_ATTEN_DB_0;
70 57
71 ESP_LOGI(TAG, "Starting task ADC sensors"); 58 ESP_LOGI(TAG, "Starting task ADC sensors");
72 // esp_log_level_set("task_adc", ESP_LOG_DEBUG);
73
74 //Check TP is burned into eFuse
75 // ESP_LOGI(TAG, "eFuse Two Point: %supported", (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_TP) == ESP_OK) ? "S":"NOT s");
76 //Check Vref is burned into eFuse
77 // ESP_LOGI(TAG, "eFuse Vref: %supported", (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_VREF) == ESP_OK) ? "S":"NOT s");
78
79 adc_state = malloc(sizeof(ADC_State)); 59 adc_state = malloc(sizeof(ADC_State));
80 for (i = 0; i < 3; i++) { 60 for (i = 0; i < 3; i++) {
81 adc_state->Pressure[i].valid = false; 61 adc_state->Pressure[i].valid = false;
82 // adc_state->Pressure[i].atten = ADC_ATTEN_DB_2_5; // Optimal 100..1250 mV, max 1500 mV. max 4,5 bar. 62 adc_state->Pressure[i].atten = ADC_ATTEN_DB_0;
83 adc_state->Pressure[i].atten = ADC_ATTEN_DB_6; // Optimal 150..1750 mV, max 2200 mV, max 6,3 bar.
84 adc_state->Pressure[i].voltage = 0; 63 adc_state->Pressure[i].voltage = 0;
85 adc_state->Pressure[i].error = ADC_ERR_NONE; 64 adc_state->Pressure[i].error = ADC_ERR_NONE;
86 } 65 }
87 adc_state->Pressure[0].channel = PRESSURE_1; 66 adc_state->Pressure[0].channel = PRESSURE_1;
88 adc_state->Pressure[1].channel = PRESSURE_2; 67 adc_state->Pressure[1].channel = PRESSURE_2;
90 adc_state->Batt_voltage = 0; 69 adc_state->Batt_voltage = 0;
91 adc_state->Batt_error = ADC_ERR_NONE; 70 adc_state->Batt_error = ADC_ERR_NONE;
92 71
93 //Characterize ADC 72 //Characterize ADC
94 esp_adc_cal_characteristics_t *adc_chars = calloc(1, sizeof(esp_adc_cal_characteristics_t)); 73 esp_adc_cal_characteristics_t *adc_chars = calloc(1, sizeof(esp_adc_cal_characteristics_t));
95 // esp_adc_cal_value_t val_type = esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_6, ADC_WIDTH_BIT_11, DEFAULT_VREF, adc_chars);
96 // print_char_val_type(val_type);
97 74
98 /* event handler and event group for this task */ 75 /* event handler and event group for this task */
99 xEventGroupADC = xEventGroupCreate(); 76 xEventGroupADC = xEventGroupCreate();
100 EventBits_t uxBits; 77 EventBits_t uxBits;
101 78
106 83
107 uxBits = xEventGroupWaitBits(xEventGroupADC, TASK_ADC_REQUEST_PRESSURE, pdFALSE, pdFALSE, portMAX_DELAY ); 84 uxBits = xEventGroupWaitBits(xEventGroupADC, TASK_ADC_REQUEST_PRESSURE, pdFALSE, pdFALSE, portMAX_DELAY );
108 85
109 if (uxBits & TASK_ADC_REQUEST_PRESSURE) { 86 if (uxBits & TASK_ADC_REQUEST_PRESSURE) {
110 87
111 adc1_config_width(ADC_WIDTH_BIT_11); 88 ESP_LOGI(TAG, "Requested ADC readings");
89 adc1_config_width(ADC_WIDTH_BIT_12);
112 90
113 for (i = 0; i < 3; i++) { 91 for (i = 0; i < 3; i++) {
114 adc_reading = 0; 92 adc_reading = 0;
115 atten = ADC_ATTEN_DB_0; 93 atten = ADC_ATTEN_DB_0;
116 94
117 /* 95 /*
118 * Autoranging the ADC conversion 96 * Autoranging the ADC conversion
119 */ 97 */
120 while (1) { 98 while (1) {
121 esp_adc_cal_characterize(ADC_UNIT_1, atten, ADC_WIDTH_BIT_11, DEFAULT_VREF, adc_chars); 99 esp_adc_cal_characterize(ADC_UNIT_1, atten, ADC_WIDTH_BIT_12, DEFAULT_VREF, adc_chars);
122 adc1_config_channel_atten((adc1_channel_t)adc_state->Pressure[i].channel, atten); 100 adc1_config_channel_atten((adc1_channel_t)adc_state->Pressure[i].channel, atten);
123 int raw = adc1_get_raw((adc1_channel_t)adc_state->Pressure[i].channel); 101 int raw = adc1_get_raw((adc1_channel_t)adc_state->Pressure[i].channel);
124 // printf("raw: %d atten: %d\n", raw, atten); 102 if (atten == ADC_ATTEN_DB_0 && raw > 3700)
125 // if (raw < 3400)
126 // break;
127
128 if (atten == ADC_ATTEN_DB_0 && raw > 1850)
129 atten = ADC_ATTEN_DB_2_5; 103 atten = ADC_ATTEN_DB_2_5;
130 else if (atten == ADC_ATTEN_DB_2_5 && raw > 1850) 104 else if (atten == ADC_ATTEN_DB_2_5 && raw > 3700)
131 atten = ADC_ATTEN_DB_6; 105 atten = ADC_ATTEN_DB_6;
132 else if (atten == ADC_ATTEN_DB_6 && raw > 1850) 106 else if (atten == ADC_ATTEN_DB_6 && raw > 3700)
133 atten = ADC_ATTEN_DB_11; 107 atten = ADC_ATTEN_DB_11;
134 else 108 else
135 break; 109 break;
136 } 110 }
137 111
138 /* 112 /*
139 * Now that he have the best attenuation, multisample the real value. 113 * Now that he have the best attenuation, multisample the real value.
140 */ 114 */
141 for (int j = 0; j < NO_OF_SAMPLES; j++) { 115 for (int j = 0; j < NO_OF_SAMPLES; j++) {
142 int tmp = adc1_get_raw((adc1_channel_t)adc_state->Pressure[i].channel); 116 int tmp = adc1_get_raw((adc1_channel_t)adc_state->Pressure[i].channel);
117 if (tmp < 0) {
118 adc_reading = -1;
119 break;
120 }
143 adc_reading += tmp; 121 adc_reading += tmp;
144 // printf("%4d ", tmp);
145 //adc_reading += adc1_get_raw((adc1_channel_t)adc_state->Pressure[i].channel);
146 } 122 }
147 // printf("\n"); 123 if (xSemaphoreTake(xSemaphoreADC, 10) == pdTRUE) {
148 if (adc_reading < 0) { 124 if (adc_reading < 0) {
149 adc_state->Pressure[i].error = ADC_ERR_READ; 125 adc_state->Pressure[i].error = ADC_ERR_READ;
150 adc_state->Pressure[i].voltage = 0; 126 adc_state->Pressure[i].voltage = 0;
151 } else { 127 } else {
152 adc_reading /= NO_OF_SAMPLES; 128 adc_reading /= NO_OF_SAMPLES;
153 if (xSemaphoreTake(xSemaphoreADC, 25) == pdTRUE) {
154 adc_state->Pressure[i].voltage = esp_adc_cal_raw_to_voltage(adc_reading, adc_chars); // voltage in mV 129 adc_state->Pressure[i].voltage = esp_adc_cal_raw_to_voltage(adc_reading, adc_chars); // voltage in mV
155 adc_state->Pressure[i].error = ADC_ERR_NONE; 130 adc_state->Pressure[i].error = ADC_ERR_NONE;
156 xSemaphoreGive(xSemaphoreADC);
157 } 131 }
132 xSemaphoreGive(xSemaphoreADC);
133 } else {
134 ESP_LOGE(TAG, "Missed lock 1");
158 } 135 }
159 ESP_LOGI(TAG, "Pressure %d raw: %4d, atten: %d, %.3f volt, error: %d", 136 ESP_LOGI(TAG, "Pressure %d raw: %4d, atten: %d, %.3f volt, error: %d",
160 i, adc_reading, atten, adc_state->Pressure[i].voltage / 1000.0, adc_state->Pressure[i].error); 137 i, adc_reading, atten, adc_state->Pressure[i].voltage / 1000.0, adc_state->Pressure[i].error);
161 } 138 }
162 139
140 /*
141 * Read VDD by reading 1/2 VDD from a precision ladder.
142 */
163 adc_reading = 0; 143 adc_reading = 0;
164 atten = ADC_ATTEN_DB_6; // Don't use DB_11, it has a bad linearity. 144 atten = ADC_ATTEN_DB_6; // Don't use DB_11, it has a bad linearity.
165 esp_adc_cal_characterize(ADC_UNIT_1, atten, ADC_WIDTH_BIT_11, DEFAULT_VREF, adc_chars); 145 esp_adc_cal_characterize(ADC_UNIT_1, atten, ADC_WIDTH_BIT_12, DEFAULT_VREF, adc_chars);
166 adc1_config_channel_atten((adc1_channel_t)BATT_CHANNEL, atten); 146 adc1_config_channel_atten((adc1_channel_t)BATT_CHANNEL, atten);
167 for (int j = 0; j < NO_OF_SAMPLES; j++) { 147 for (int j = 0; j < NO_OF_SAMPLES; j++) {
168 adc_reading += adc1_get_raw((adc1_channel_t)BATT_CHANNEL); 148 int tmp = adc1_get_raw((adc1_channel_t)BATT_CHANNEL);
149 if (tmp < 0) {
150 adc_reading = -1;
151 break;
152 }
153 adc_reading += tmp;
169 } 154 }
170 155 if (xSemaphoreTake(xSemaphoreADC, 10) == pdTRUE) {
171 if (adc_reading < 0) { 156 if (adc_reading < 0) {
172 adc_state->Batt_voltage = 0; 157 adc_state->Batt_voltage = 3.3;
173 adc_state->Batt_error = ADC_ERR_READ; 158 adc_state->Batt_error = ADC_ERR_READ;
174 } else { 159 } else {
175 adc_reading /= NO_OF_SAMPLES; 160 adc_reading /= NO_OF_SAMPLES;
176 if (xSemaphoreTake(xSemaphoreADC, 25) == pdTRUE) {
177 adc_state->Batt_voltage = esp_adc_cal_raw_to_voltage(adc_reading, adc_chars) * 2; // Chip supply voltage in mV 161 adc_state->Batt_voltage = esp_adc_cal_raw_to_voltage(adc_reading, adc_chars) * 2; // Chip supply voltage in mV
178 adc_state->Batt_error = ADC_ERR_NONE; 162 adc_state->Batt_error = ADC_ERR_NONE;
179 xSemaphoreGive(xSemaphoreADC); 163 }
180 } 164 xSemaphoreGive(xSemaphoreADC);
165 } else {
166 ESP_LOGE(TAG, "Missed lock 2");
181 } 167 }
182 168
183 xEventGroupClearBits(xEventGroupADC, TASK_ADC_REQUEST_PRESSURE); 169 xEventGroupClearBits(xEventGroupADC, TASK_ADC_REQUEST_PRESSURE);
184 xEventGroupSetBits(xEventGroupADC, TASK_ADC_REQUEST_DONE); 170 xEventGroupSetBits(xEventGroupADC, TASK_ADC_REQUEST_DONE);
185 #if 1 171 #if 1
186 ESP_LOGI(TAG, "Battery raw: %4d, atten: %d %.3f volt, error: %d", adc_reading, atten, adc_state->Batt_voltage / 1000.0, adc_state->Batt_error); 172 ESP_LOGI(TAG, "Battery raw: %4d, atten: %d %.3f volt, error: %d", adc_reading, atten, adc_state->Batt_voltage / 1000.0, adc_state->Batt_error);
187 #endif 173 #endif
188 } 174 }
189 vTaskDelay( (TickType_t)10);
190 } 175 }
191 } 176 }
192 177

Mercurial Repository: co2meter

mercurial