visus
/
teensy-core-4.1
Beobachten 1
Favorisieren 0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Teensy 4.1 core updated for C++20
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
608 Commits
2 Branches
Struktur: 5c064702ba
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „5c064702ba“
${ noResults }
teensy-core-4.1/teensy3/analog.c

563 Zeilen
18KB
Originalformat Blame Verlauf 

  1. /* Teensyduino Core Library

  2.  * http://www.pjrc.com/teensy/

  3.  * Copyright (c) 2013 PJRC.COM, LLC.

  4.  *

  5.  * Permission is hereby granted, free of charge, to any person obtaining

  6.  * a copy of this software and associated documentation files (the

  7.  * "Software"), to deal in the Software without restriction, including

  8.  * without limitation the rights to use, copy, modify, merge, publish,

  9.  * distribute, sublicense, and/or sell copies of the Software, and to

  10.  * permit persons to whom the Software is furnished to do so, subject to

  11.  * the following conditions:

  12.  *

  13.  * 1. The above copyright notice and this permission notice shall be 

  14.  * included in all copies or substantial portions of the Software.

  15.  *

  16.  * 2. If the Software is incorporated into a build system that allows 

  17.  * selection among a list of target devices, then similar target

  18.  * devices manufactured by PJRC.COM must be included in the list of

  19.  * target devices and selectable in the same manner.

  20.  *

  21.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  22.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  23.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  24.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  25.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  26.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  28.  * SOFTWARE.

  29.  */

  30. 

  31. #include "core_pins.h"

  32. //#include "HardwareSerial.h"

  33. 

  34. static uint8_t calibrating;

  35. static uint8_t analog_right_shift = 0;

  36. static uint8_t analog_config_bits = 10;

  37. static uint8_t analog_num_average = 4;

  38. static uint8_t analog_reference_internal = 0;

  39. 

  40. // the alternate clock is connected to OSCERCLK (16 MHz).

  41. // datasheet says ADC clock should be 2 to 12 MHz for 16 bit mode

  42. // datasheet says ADC clock should be 1 to 18 MHz for 8-12 bit mode

  43. 

  44. #if F_BUS == 120000000

  45.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(3) + ADC_CFG1_ADICLK(1) // 7.5 MHz

  46.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 15 MHz

  47.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 15 MHz

  48.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 15 MHz

  49. #elif F_BUS == 108000000

  50.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(3) + ADC_CFG1_ADICLK(1) // 7 MHz

  51.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 14 MHz

  52.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 14 MHz

  53.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 14 MHz

  54. #elif F_BUS == 96000000

  55.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 12 MHz

  56.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 12 MHz

  57.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 12 MHz

  58.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 24 MHz

  59. #elif F_BUS == 90000000

  60.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 11.25 MHz

  61.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 11.25 MHz

  62.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 11.25 MHz

  63.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 22.5 MHz

  64. #elif F_BUS == 80000000

  65.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 10 MHz

  66.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 10 MHz

  67.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 10 MHz

  68.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 20 MHz			

  69. #elif F_BUS == 72000000

  70.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 9 MHz

  71.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 18 MHz

  72.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 18 MHz

  73.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 18 MHz

  74. #elif F_BUS == 64000000

  75.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 8 MHz

  76.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 16 MHz

  77.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 16 MHz

  78.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 16 MHz

  79. #elif F_BUS == 60000000

  80.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 7.5 MHz

  81.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 15 MHz

  82.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 15 MHz

  83.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 15 MHz

  84. #elif F_BUS == 56000000 || F_BUS == 54000000

  85.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(2) + ADC_CFG1_ADICLK(1) // 7 MHz

  86.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 14 MHz

  87.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 14 MHz

  88.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 14 MHz

  89. #elif F_BUS == 48000000

  90.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 12 MHz

  91.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 12 MHz

  92.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 12 MHz

  93.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 24 MHz

  94. #elif F_BUS == 40000000

  95.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 10 MHz

  96.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 10 MHz

  97.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 10 MHz

  98.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 20 MHz

  99. #elif F_BUS == 36000000

  100.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(1) // 9 MHz

  101.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 18 MHz

  102.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 18 MHz

  103.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(1) // 18 MHz

  104. #elif F_BUS == 24000000

  105.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(0) // 12 MHz

  106.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(0) // 12 MHz

  107.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(1) + ADC_CFG1_ADICLK(0) // 12 MHz

  108.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 24 MHz

  109. #elif F_BUS == 16000000

  110.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz

  111.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz

  112.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz

  113.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 16 MHz

  114. #elif F_BUS == 8000000

  115.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz

  116.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz

  117.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz

  118.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 8 MHz

  119. #elif F_BUS == 4000000

  120.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz

  121.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz

  122.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz

  123.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 4 MHz

  124. #elif F_BUS == 2000000

  125.   #define ADC_CFG1_16BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz

  126.   #define ADC_CFG1_12BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz

  127.   #define ADC_CFG1_10BIT  ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz

  128.   #define ADC_CFG1_8BIT   ADC_CFG1_ADIV(0) + ADC_CFG1_ADICLK(0) // 2 MHz

  129. #else

  130. #error "F_BUS must be 120, 108, 96, 90, 80, 72, 64, 60, 56, 54, 48, 40, 36, 24, 4 or 2 MHz"

  131. #endif

  132. 

  133. void analog_init(void)

  134. {

  135. 	uint32_t num;

  136. 

  137. 	#if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  138. 	VREF_TRM = 0x60;

  139. 	VREF_SC = 0xE1;		// enable 1.2 volt ref

  140. 	#endif

  141. 

  142. 	if (analog_config_bits == 8) {

  143. 		ADC0_CFG1 = ADC_CFG1_8BIT + ADC_CFG1_MODE(0);

  144. 		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);

  145. 		#ifdef HAS_KINETIS_ADC1

  146. 		ADC1_CFG1 = ADC_CFG1_8BIT + ADC_CFG1_MODE(0);

  147. 		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);

  148. 		#endif

  149. 	} else if (analog_config_bits == 10) {

  150. 		ADC0_CFG1 = ADC_CFG1_10BIT + ADC_CFG1_MODE(2) + ADC_CFG1_ADLSMP;

  151. 		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);

  152. 		#ifdef HAS_KINETIS_ADC1

  153. 		ADC1_CFG1 = ADC_CFG1_10BIT + ADC_CFG1_MODE(2) + ADC_CFG1_ADLSMP;

  154. 		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(3);

  155. 		#endif

  156. 	} else if (analog_config_bits == 12) {

  157. 		ADC0_CFG1 = ADC_CFG1_12BIT + ADC_CFG1_MODE(1) + ADC_CFG1_ADLSMP;

  158. 		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);

  159. 		#ifdef HAS_KINETIS_ADC1

  160. 		ADC1_CFG1 = ADC_CFG1_12BIT + ADC_CFG1_MODE(1) + ADC_CFG1_ADLSMP;

  161. 		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);

  162. 		#endif

  163. 	} else {

  164. 		ADC0_CFG1 = ADC_CFG1_16BIT + ADC_CFG1_MODE(3) + ADC_CFG1_ADLSMP;

  165. 		ADC0_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);

  166. 		#ifdef HAS_KINETIS_ADC1

  167. 		ADC1_CFG1 = ADC_CFG1_16BIT + ADC_CFG1_MODE(3) + ADC_CFG1_ADLSMP;

  168. 		ADC1_CFG2 = ADC_CFG2_MUXSEL + ADC_CFG2_ADLSTS(2);

  169. 		#endif

  170. 	}

  171. 

  172. 	#if defined(__MK20DX128__)

  173. 	if (analog_reference_internal) {

  174. 		ADC0_SC2 = ADC_SC2_REFSEL(1); // 1.2V ref

  175. 	} else {

  176. 		ADC0_SC2 = ADC_SC2_REFSEL(0); // vcc/ext ref

  177. 	}

  178. 	#elif defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  179. 	if (analog_reference_internal) {

  180. 		ADC0_SC2 = ADC_SC2_REFSEL(1); // 1.2V ref

  181. 		ADC1_SC2 = ADC_SC2_REFSEL(1); // 1.2V ref

  182. 	} else {

  183. 		ADC0_SC2 = ADC_SC2_REFSEL(0); // vcc/ext ref

  184. 		ADC1_SC2 = ADC_SC2_REFSEL(0); // vcc/ext ref

  185. 	}

  186. 	#elif defined(__MKL26Z64__)

  187. 	if (analog_reference_internal) {

  188. 		ADC0_SC2 = ADC_SC2_REFSEL(0); // external AREF

  189. 	} else {

  190. 		ADC0_SC2 = ADC_SC2_REFSEL(1); // vcc

  191. 	}

  192. 	#endif

  193. 

  194. 	num = analog_num_average;

  195. 	if (num <= 1) {

  196. 		ADC0_SC3 = ADC_SC3_CAL;  // begin cal

  197. 		#ifdef HAS_KINETIS_ADC1

  198. 		ADC1_SC3 = ADC_SC3_CAL;  // begin cal

  199. 		#endif

  200. 	} else if (num <= 4) {

  201. 		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(0);

  202. 		#ifdef HAS_KINETIS_ADC1

  203. 		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(0);

  204. 		#endif

  205. 	} else if (num <= 8) {

  206. 		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(1);

  207. 		#ifdef HAS_KINETIS_ADC1

  208. 		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(1);

  209. 		#endif

  210. 	} else if (num <= 16) {

  211. 		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(2);

  212. 		#ifdef HAS_KINETIS_ADC1

  213. 		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(2);

  214. 		#endif

  215. 	} else {

  216. 		ADC0_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(3);

  217. 		#ifdef HAS_KINETIS_ADC1

  218. 		ADC1_SC3 = ADC_SC3_CAL + ADC_SC3_AVGE + ADC_SC3_AVGS(3);

  219. 		#endif

  220. 	}

  221. 	calibrating = 1;

  222. }

  223. 

  224. static void wait_for_cal(void)

  225. {

  226. 	uint16_t sum;

  227. 

  228. 	//serial_print("wait_for_cal\n");

  229. #if defined(HAS_KINETIS_ADC0) && defined(HAS_KINETIS_ADC1)

  230. 	while ((ADC0_SC3 & ADC_SC3_CAL) || (ADC1_SC3 & ADC_SC3_CAL)) {

  231. 		// wait

  232. 	}

  233. #elif defined(HAS_KINETIS_ADC0)

  234. 	while (ADC0_SC3 & ADC_SC3_CAL) {

  235. 		// wait

  236. 	}

  237. #endif

  238. 	__disable_irq();

  239. 	if (calibrating) {

  240. 		//serial_print("\n");

  241. 		sum = ADC0_CLPS + ADC0_CLP4 + ADC0_CLP3 + ADC0_CLP2 + ADC0_CLP1 + ADC0_CLP0;

  242. 		sum = (sum / 2) | 0x8000;

  243. 		ADC0_PG = sum;

  244. 		//serial_print("ADC0_PG = ");

  245. 		//serial_phex16(sum);

  246. 		//serial_print("\n");

  247. 		sum = ADC0_CLMS + ADC0_CLM4 + ADC0_CLM3 + ADC0_CLM2 + ADC0_CLM1 + ADC0_CLM0;

  248. 		sum = (sum / 2) | 0x8000;

  249. 		ADC0_MG = sum;

  250. 		//serial_print("ADC0_MG = ");

  251. 		//serial_phex16(sum);

  252. 		//serial_print("\n");

  253. #ifdef HAS_KINETIS_ADC1

  254. 		sum = ADC1_CLPS + ADC1_CLP4 + ADC1_CLP3 + ADC1_CLP2 + ADC1_CLP1 + ADC1_CLP0;

  255. 		sum = (sum / 2) | 0x8000;

  256. 		ADC1_PG = sum;

  257. 		sum = ADC1_CLMS + ADC1_CLM4 + ADC1_CLM3 + ADC1_CLM2 + ADC1_CLM1 + ADC1_CLM0;

  258. 		sum = (sum / 2) | 0x8000;

  259. 		ADC1_MG = sum;

  260. #endif

  261. 		calibrating = 0;

  262. 	}

  263. 	__enable_irq();

  264. }

  265. 

  266. // ADCx_SC2[REFSEL] bit selects the voltage reference sources for ADC.

  267. //   VREFH/VREFL - connected as the primary reference option

  268. //   1.2 V VREF_OUT - connected as the VALT reference option

  269. 

  270. #if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  271. #define DEFAULT         0

  272. #define INTERNAL        2

  273. #define INTERNAL1V2     2

  274. #define INTERNAL1V1     2

  275. #define EXTERNAL        0

  276. 

  277. #elif defined(__MKL26Z64__)

  278. #define DEFAULT         0

  279. #define INTERNAL        0

  280. #define EXTERNAL        1

  281. #endif

  282. 

  283. void analogReference(uint8_t type)

  284. {

  285. 	if (type) {

  286. 		// internal reference requested

  287. 		if (!analog_reference_internal) {

  288. 			analog_reference_internal = 1;

  289. 			if (calibrating) {

  290. 				ADC0_SC3 = 0; // cancel cal

  291. #ifdef HAS_KINETIS_ADC1

  292. 				ADC1_SC3 = 0; // cancel cal

  293. #endif

  294. 			}

  295. 			analog_init();

  296. 		}

  297. 	} else {

  298. 		// vcc or external reference requested

  299. 		if (analog_reference_internal) {

  300. 			analog_reference_internal = 0;

  301. 			if (calibrating) {

  302. 				ADC0_SC3 = 0; // cancel cal

  303. #ifdef HAS_KINETIS_ADC1

  304. 				ADC1_SC3 = 0; // cancel cal

  305. #endif

  306. 			}

  307. 			analog_init();

  308. 		}

  309. 	}

  310. }

  311. 

  312. 

  313. void analogReadRes(unsigned int bits)

  314. {

  315. 	unsigned int config;

  316. 

  317. 	if (bits >= 13) {

  318. 		if (bits > 16) bits = 16;

  319. 		config = 16;

  320. 	} else if (bits >= 11) {

  321. 		config = 12;

  322. 	} else if (bits >= 9) {

  323. 		config = 10;

  324. 	} else {

  325. 		config = 8;

  326. 	}

  327. 	analog_right_shift = config - bits;

  328. 	if (config != analog_config_bits) {

  329. 		analog_config_bits = config;

  330. 		if (calibrating) {

  331. 			ADC0_SC3 = 0; // cancel cal

  332. 			#ifdef HAS_KINETIS_ADC1

  333. 			ADC1_SC3 = 0;

  334. 			#endif

  335. 		}

  336. 		analog_init();

  337. 	}

  338. }

  339. 

  340. void analogReadAveraging(unsigned int num)

  341. {

  342. 

  343. 	if (calibrating) wait_for_cal();

  344. 	if (num <= 1) {

  345. 		num = 0;

  346. 		ADC0_SC3 = 0;

  347. 	} else if (num <= 4) {

  348. 		num = 4;

  349. 		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(0);

  350. 	} else if (num <= 8) {

  351. 		num = 8;

  352. 		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(1);

  353. 	} else if (num <= 16) {

  354. 		num = 16;

  355. 		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(2);

  356. 	} else {

  357. 		num = 32;

  358. 		ADC0_SC3 = ADC_SC3_AVGE + ADC_SC3_AVGS(3);

  359. 	}

  360. 	analog_num_average = num;

  361. }

  362. 

  363. // The SC1A register is used for both software and hardware trigger modes of operation.

  364. 

  365. #if defined(__MK20DX128__)

  366. static const uint8_t pin2sc1a[] = {

  367. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 4, 0, 19, 3, 21, // 0-13 -> A0-A13

  368. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 4, // 14-23 are A0-A9

  369. 	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 24-33 are digital only

  370. 	0, 19, 3, 21, // 34-37 are A10-A13

  371. 	26,           // 38 is temp sensor

  372. 	22,           // 39 is vref

  373. 	23            // 40 is unused analog pin

  374. };

  375. #elif defined(__MK20DX256__)

  376. static const uint8_t pin2sc1a[] = {

  377. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 4, 0, 19, 3, 19+128, // 0-13 -> A0-A13

  378. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 4, // 14-23 are A0-A9

  379. 	255, 255, // 24-25 are digital only

  380. 	5+192, 5+128, 4+128, 6+128, 7+128, 4+192, // 26-31 are A15-A20

  381. 	255, 255, // 32-33 are digital only

  382. 	0, 19, 3, 19+128, // 34-37 are A10-A13

  383. 	26,     // 38 is temp sensor,

  384. 	18+128, // 39 is vref

  385. 	23      // 40 is A14

  386. };

  387. #elif defined(__MKL26Z64__)

  388. static const uint8_t pin2sc1a[] = {

  389. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 11, 0, 4+64, 23, // 0-12 -> A0-A12

  390. 	255, // 13 is digital only (no A13 alias)

  391. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 11, 0, 4+64, 23, // 14-26 are A0-A12

  392. 	255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, // 27-37 unused

  393. 	26, // 38=temperature

  394. 	27  // 39=bandgap ref (PMC_REGSC |= PMC_REGSC_BGBE)

  395. };

  396. #elif defined(__MK64FX512__) || defined(__MK66FX1M0__)

  397. static const uint8_t pin2sc1a[] = {

  398. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 4, 3, 19+128, 14+128, 15+128, // 0-13 -> A0-A13

  399. 	5, 14, 8, 9, 13, 12, 6, 7, 15, 4, // 14-23 are A0-A9

  400. 	255, 255, 255, 255, 255, 255, 255, // 24-30 are digital only

  401. 	14+128, 15+128, 17, 18, 4+128, 5+128, 6+128, 7+128, 17+128,  // 31-39 are A12-A20

  402. 	255, 255, 255, 255, 255, 255, 255, 255, 255,  // 40-48 are digital only

  403. 	10+128, 11+128, // 49-50 are A23-A24

  404. 	255, 255, 255, 255, 255, 255, 255, // 51-57 are digital only

  405. 	255, 255, 255, 255, 255, 255, // 58-63 (sd card pins) are digital only

  406. 	3, 19+128, // 64-65 are A10-A11

  407. 	23, 23+128,// 66-67 are A21-A22 (DAC pins)

  408. 	1, 1+128,  // 68-69 are A25-A26 (unused USB host port on Teensy 3.5)

  409. 	26,        // 70 is Temperature Sensor

  410. 	18+128     // 71 is Vref

  411. };

  412. #endif

  413. 

  414. 

  415. 

  416. // TODO: perhaps this should store the NVIC priority, so it works recursively?

  417. static volatile uint8_t analogReadBusyADC0 = 0;

  418. #ifdef HAS_KINETIS_ADC1

  419. static volatile uint8_t analogReadBusyADC1 = 0;

  420. #endif

  421. 

  422. int analogRead(uint8_t pin)

  423. {

  424. 	int result;

  425. 	uint8_t channel;

  426. 

  427. 	//serial_phex(pin);

  428. 	//serial_print(" ");

  429. 

  430. 	if (pin >= sizeof(pin2sc1a)) return 0;

  431. 	channel = pin2sc1a[pin];

  432. 	if (channel == 255) return 0;

  433. 

  434. 	if (calibrating) wait_for_cal();

  435. 

  436. #ifdef HAS_KINETIS_ADC1

  437. 	if (channel & 0x80) goto beginADC1;

  438. #endif

  439. 

  440. 	__disable_irq();

  441. startADC0:

  442. 	//serial_print("startADC0\n");

  443. #if defined(__MKL26Z64__)

  444. 	if (channel & 0x40) {

  445. 		ADC0_CFG2 &= ~ADC_CFG2_MUXSEL;

  446. 		channel &= 0x3F;

  447. 	} else {

  448. 		ADC0_CFG2 |= ADC_CFG2_MUXSEL;

  449. 	}

  450. #endif

  451. 	ADC0_SC1A = channel;

  452. 	analogReadBusyADC0 = 1;

  453. 	__enable_irq();

  454. 	while (1) {

  455. 		__disable_irq();

  456. 		if ((ADC0_SC1A & ADC_SC1_COCO)) {

  457. 			result = ADC0_RA;

  458. 			analogReadBusyADC0 = 0;

  459. 			__enable_irq();

  460. 			result >>= analog_right_shift;

  461. 			return result;

  462. 		}

  463. 		// detect if analogRead was used from an interrupt

  464. 		// if so, our analogRead got canceled, so it must

  465. 		// be restarted.

  466. 		if (!analogReadBusyADC0) goto startADC0;

  467. 		__enable_irq();

  468. 		yield();

  469. 	}

  470. 

  471. #ifdef HAS_KINETIS_ADC1

  472. beginADC1:

  473. 	__disable_irq();

  474. startADC1:

  475. 	//serial_print("startADC1\n");

  476. 	// ADC1_CFG2[MUXSEL] bit selects between ADCx_SEn channels a and b.

  477. 	if (channel & 0x40) {

  478. 		ADC1_CFG2 &= ~ADC_CFG2_MUXSEL;

  479. 	} else {

  480. 		ADC1_CFG2 |= ADC_CFG2_MUXSEL;

  481. 	}

  482. 	ADC1_SC1A = channel & 0x3F;

  483. 	analogReadBusyADC1 = 1;

  484. 	__enable_irq();

  485. 	while (1) {

  486. 		__disable_irq();

  487. 		if ((ADC1_SC1A & ADC_SC1_COCO)) {

  488. 			result = ADC1_RA;

  489. 			analogReadBusyADC1 = 0;

  490. 			__enable_irq();

  491. 			result >>= analog_right_shift;

  492. 			return result;

  493. 		}

  494. 		// detect if analogRead was used from an interrupt

  495. 		// if so, our analogRead got canceled, so it must

  496. 		// be restarted.

  497. 		if (!analogReadBusyADC1) goto startADC1;

  498. 		__enable_irq();

  499. 		yield();

  500. 	}

  501. #endif

  502. }

  503. 

  504. 

  505. 

  506. void analogWriteDAC0(int val)

  507. {

  508. #if defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  509. 	SIM_SCGC2 |= SIM_SCGC2_DAC0;

  510. 	if (analog_reference_internal) {

  511. 		DAC0_C0 = DAC_C0_DACEN;  // 1.2V ref is DACREF_1

  512. 	} else {

  513. 		DAC0_C0 = DAC_C0_DACEN | DAC_C0_DACRFS; // 3.3V VDDA is DACREF_2

  514. 	}

  515. 	if (val < 0) val = 0;  // TODO: saturate instruction?

  516. 	else if (val > 4095) val = 4095;

  517. 	*(int16_t *)&(DAC0_DAT0L) = val;

  518. #elif defined(__MKL26Z64__)

  519. 	SIM_SCGC6 |= SIM_SCGC6_DAC0;

  520. 	if (analog_reference_internal == 0) {

  521. 		// use 3.3V VDDA power as the reference (this is the default)

  522. 		DAC0_C0 = DAC_C0_DACEN | DAC_C0_DACRFS | DAC_C0_DACSWTRG; // 3.3V VDDA

  523. 	} else {

  524. 		// use whatever voltage is on the AREF pin

  525. 		DAC0_C0 = DAC_C0_DACEN | DAC_C0_DACSWTRG; // 3.3V VDDA

  526. 	}

  527. 	if (val < 0) val = 0;

  528. 	else if (val > 4095) val = 4095;

  529. 	*(int16_t *)&(DAC0_DAT0L) = val;

  530. #endif

  531. }

  532. 

  533. 

  534. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  535. void analogWriteDAC1(int val)

  536. {

  537. 	SIM_SCGC2 |= SIM_SCGC2_DAC1;

  538. 	if (analog_reference_internal) {

  539. 		DAC1_C0 = DAC_C0_DACEN;  // 1.2V ref is DACREF_1

  540. 	} else {

  541. 		DAC1_C0 = DAC_C0_DACEN | DAC_C0_DACRFS; // 3.3V VDDA is DACREF_2

  542. 	}

  543. 	if (val < 0) val = 0;  // TODO: saturate instruction?

  544. 	else if (val > 4095) val = 4095;

  545. 	*(int16_t *)&(DAC1_DAT0L) = val;

  546. }

  547. #endif

  548. 

  549. 

  550. 

  551. 

  552. 

  553. 

  554. 

  555. 

  556. 

  557. 

  558. 

  559. 

  560. 

  561.