heuzef
/
WiringPi
kopia lustrzana https://github.com/WiringPi/WiringPi.git
1
0
Forkuj 0
Kod Zgłoszenia 0 Wydania 9 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
161 Commity
10 Gałęzie
53 MiB
 
 
 
 
 
Drzewo: 6b1941cbeb
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '6b1941cbeb'
${ noResults }
WiringPi/gpio/readall.c

533 wiersze
15 KiB
Czysty Wina Historia 

  1. /*

  2.  * readall.c:

  3.  *	The readall functions - getting a bit big, so split them out.

  4.  *	Copyright (c) 2012-2018 Gordon Henderson

  5.  ***********************************************************************

  6.  * This file is part of wiringPi:

  7.  *	https://projects.drogon.net/raspberry-pi/wiringpi/

  8.  *

  9.  *    wiringPi is free software: you can redistribute it and/or modify

  10.  *    it under the terms of the GNU Lesser General Public License as published by

  11.  *    the Free Software Foundation, either version 3 of the License, or

  12.  *    (at your option) any later version.

  13.  *

  14.  *    wiringPi is distributed in the hope that it will be useful,

  15.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of

  16.  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  17.  *    GNU Lesser General Public License for more details.

  18.  *

  19.  *    You should have received a copy of the GNU Lesser General Public License

  20.  *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.

  21.  ***********************************************************************

  22.  */

  23. 

  24. 

  25. #include <stdio.h>

  26. #include <stdlib.h>

  27. #include <stdint.h>

  28. #include <ctype.h>

  29. #include <string.h>

  30. #include <unistd.h>

  31. #include <errno.h>

  32. #include <fcntl.h>

  33. #include <sys/types.h>

  34. #include <sys/stat.h>

  35. 

  36. #include <wiringPi.h>

  37. 

  38. extern int wpMode ;

  39. 

  40. #ifndef TRUE

  41. #  define       TRUE    (1==1)

  42. #  define       FALSE   (1==2)

  43. #endif

  44. 

  45. /*

  46.  * doReadallExternal:

  47.  *	A relatively crude way to read the pins on an external device.

  48.  *	We don't know the input/output mode of pins, but we can tell

  49.  *	if it's an analog pin or a digital one...

  50.  *********************************************************************************

  51.  */

  52. 

  53. static void doReadallExternal (void)

  54. {

  55.   int pin ;

  56. 

  57.   printf ("+------+---------+--------+\n") ;

  58.   printf ("|  Pin | Digital | Analog |\n") ;

  59.   printf ("+------+---------+--------+\n") ;

  60. 

  61.   for (pin = wiringPiNodes->pinBase ; pin <= wiringPiNodes->pinMax ; ++pin)

  62.     printf ("| %4d |  %4d   |  %4d  |\n", pin, digitalRead (pin), analogRead (pin)) ;

  63. 

  64.   printf ("+------+---------+--------+\n") ;

  65. }

  66. 

  67. 

  68. /*

  69.  * doReadall:

  70.  *	Read all the GPIO pins

  71.  *	We also want to use this to read the state of pins on an externally

  72.  *	connected device, so we need to do some fiddling with the internal

  73.  *	wiringPi node structures - since the gpio command can only use

  74.  *	one external device at a time, we'll use that to our advantage...

  75.  *********************************************************************************

  76.  */

  77. 

  78. static char *alts [] =

  79. {

  80.   "IN", "OUT", "ALT0", "ALT1", "ALT2", "ALT3", "ALT4", "ALT5"

  81. } ;

  82. 

  83. static const char *pupd [] =

  84. {

  85. 	"DSBLD", "P/U", "P/D"

  86. };

  87. 

  88. static int physToWpi [64] = 

  89. {

  90.   -1,           // 0

  91.   -1, -1,       // 1, 2

  92.    8, 15,

  93.    9, 29,

  94.    7, -1,

  95.   -1, 16,

  96.    0,  1,

  97.   -1, -1,

  98.    3, -1,

  99.   -1,  5,

  100.   12,  4,

  101.   13,  6,

  102.   14, 10,

  103.    2, 11,       // 25, 26

  104.   -1, -1,	// Actually I2C, but not used

  105.   21, 30,

  106.   22, 26,

  107.   23, 31,

  108.   24, 27,

  109.   25, 28,

  110.   -1, -1,

  111.   -1, -1,

  112.   -1, -1,

  113.   -1, -1,

  114.   -1, -1,

  115.   -1, -1,

  116.   17, 18,

  117.   19, 20,

  118.   -1, -1, -1, -1, -1, -1, -1, -1, -1

  119. } ;

  120. 

  121. /*----------------------------------------------------------------------------*/

  122. static int physToWpi_Edge [64] =

  123. {

  124. 	-1,	// 0

  125. 	-1, -1,	// 1, 2

  126.     -1, -1, //	-1, 13,

  127.     -1, -1, //	-1, 12,

  128. 	-1, -1,

  129. 	-1,  9,

  130. 	-1,  8,

  131. 	-1, -1,

  132. 	-1, -1,

  133. 	-1,  0,

  134. 	-1, 11,

  135. 	-1,  7,

  136. 	-1,  2,

  137. 	17,  3,	

  138. 	-1, -1,	

  139.     -1,  6,  //	10,  6,

  140.     -1,  5,  //	14,  5,

  141. 	-1,  4,

  142. 	-1,  1,

  143. 	-1, -1,

  144. 	-1, -1,

  145. 	-1, -1,

  146. 	-1, -1,

  147. 	-1, -1,

  148. 	-1, -1,

  149. 	-1, -1,

  150. 	-1, -1,

  151. 	-1, -1,

  152. 	-1, -1, -1, -1, -1, -1, -1, -1, -1

  153. } ;

  154. 

  155. /*------------------------------------------------------------------------------------------*/

  156. static const char *physNamesKhadasVim1[64] = {

  157. 	NULL,

  158. 	"      5V","GND     ",

  159. 	"      5V","PIN.DV25",

  160. 	" HUB_DM1","PIN.DV24",

  161. 	" HUB_DP1","GND     ",

  162. 	"     GND","PIN.DV27",

  163. 	"      5V","PIN.DV26",

  164. 	" HUB_DM2","3.3V    ",

  165. 	" HUB_DP2","GND     ",

  166. 	"     GND","PIN.H7  ",

  167. 	" ADC.CH0","PIN.H6  ",

  168. 	"     GND","PIN.H9  ",

  169. 	" ADC.CH2","PIN.H8  ",

  170. 	"   SPDIF","PIN.AO6 ",

  171. 	"     GND","GND     ",

  172. 	" PIN.AO5","PIN.AO3 ",

  173. 	" PIN.AO4","RTC_CLK ",

  174. 	"     GND","PIN.H5  ",

  175. 	" PIN.AO1","PWR_EN  ",

  176. 	" PIN.AO2","PWM_F   ",

  177. 	"    3.3V","GND     ",

  178. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  179. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  180. 	NULL,NULL,NULL,

  181. };

  182. 

  183. static const char *physNamesKhadasVim2[64] = {

  184. 	NULL,

  185. 	"      5V","GND     ",

  186. 	"      5v","PIN.DV25",

  187. 	"  USB_DM","PIN.DV24",

  188. 	"  USB_DP","GND     ",

  189. 	"     GND","PIN.DV27",

  190. 	"PIN.DV21","PIN.DV26",

  191. 	"PIN.DV22","3.3V    ",

  192. 	"PIN.DV23","GND     ",

  193. 	"     GND","PIN.H7  ",

  194. 	"    ADC0","PIN.H6  ",

  195. 	"    1.8V","PIN.H9  ",

  196. 	"    ADC1","PIN.H8  ",

  197. 	"   SPDIF","PIN.AO6 ",

  198. 	"     GND","GND     ",

  199. 	" PIN.AO5","PIN.DV29",

  200. 	" PIN.AO4","RTC_CLK ",

  201. 	"     GND","PIN.H5  ",

  202. 	" PIN.AO1","EXP_INT ",

  203. 	" PIN.AO0","PIN.DV13",

  204. 	"    3.3v","GND     ",

  205. 	//Not used

  206. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  207. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  208. 	NULL,NULL,NULL,

  209. };

  210. 

  211. static const char *physNamesKhadasVim3[64] = {

  212. 	NULL,

  213. 	"      5V","GND     ",

  214. 	"      5V","PIN.A15 ",

  215. 	"  USB_DM","PIN.A14 ",

  216. 	"  USB_DP","GND     ",

  217. 	"     GND","PIN.AO2 ",

  218. 	"  MCU3V3","PIN.AO3 ",

  219. 	" MCUNRST","3V3     ",

  220. 	" MCUSWIM","GND     ",

  221. 	"     GND","PIN.A1  ",

  222. 	"    ADC0","PIN.A0  ",

  223. 	"     1V8","PIN.A3  ",

  224. 	"    ADC1","PIN.A2  ",

  225. 	"   SPDIF","PIN.A4  ",

  226. 	"    GND3","GND     ",

  227. 	"  PIN.H6","PWM-F   ",

  228. 	"  PIN.H7","RTC     ",

  229. 	"     GND","PIN.H4  ",

  230. 	" PIN.AO1","MCU-FA1 ",

  231. 	" PIN.AO0","PIN.Z15 ",

  232. 	"     3V3","GND     ",

  233. 	//Not used

  234. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  235. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  236. 	NULL,NULL,NULL,

  237. };

  238. 

  239. /*----------------------------------------------------------------------------*/

  240. static const char *physNamesKhadasEdge [64] =

  241. {

  242. 	NULL,

  243. 

  244. 	"               5V", "GND(0V)                   ",

  245. 	"               5V", "SPI3_RXD/I2C0_SCK/GPIO1_C0",

  246. 	"         HOST1_DM", "SPI3_TXD/I2C0_SDA/GPIO1_B7",

  247. 	"         HOST1_DP", "GND(0V)                   ",

  248. 	"          GND(0V)", "I2C2_SCL/GPIO2_A1         ",

  249. 	"           MCU_TX", "I2C2_SDA/GPIO2_A0         ",

  250. 	"         MCU_NRST", "3.3V                      ",

  251. 	"         MCU_SWIM", "GND(0V)                   ",

  252. 	"          GND(0V)", "I2S0_SCLK/GPIO3_D0        ",

  253. 	"          ADC_IN2", "I2S_CLK/GPIO4_A0          ",

  254. 	"             1.8V", "I2S0_SDO0/GPIO3_D7        ",

  255. 	"          ADC_IN3", "2S0_LRCK_TX/GPIO3_D2      ",

  256. 	"   SPDIF/GPIO3_C0", "I2S0_SDI0/GPIO3_D3        ",

  257. 	"           GND(0V", "GND(0V)                   ",

  258. 	" SPI3_CS/GPIO1_C2", "I2S0_SDI3SDO1/GPIO3_D6    ",

  259. 	"SPI3_CLK/GPIO1_C1", "2S0_SDI2SDO2/GPIO3_D5     ",

  260. 	"          GND(0V)", "I2S0_SDI1SDO3/GPIO3_D4    ",

  261. 	"          UART_RX", "I2S0_LRCK_RX/GPIO3_D1     ",

  262. 	"          UART_TX", "MCU_PA1                   ",

  263. 	"             3.3V", "GND(0V)                   ",	

  264. 

  265. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  266. 	NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,

  267. 	NULL,NULL,NULL,

  268. } ;

  269. 

  270. static void readallPhysKhadas (int model, int UNU rev, int physPin, const char *physNames[])

  271. {

  272. 	int pin;

  273. 

  274. 	//GPIO, wPi pin number

  275. 	if ((physPinToGpio (physPin) == -1) && (physToWpi [physPin] == -1))

  276. 		printf (" |      |    ") ;

  277. 	else if (physPinToGpio (physPin) != -1)

  278. 		printf (" |  %3d | %3d", physPinToGpio (physPin), physToWpi [physPin]);

  279. 	else

  280. 		printf (" |      | %3d", physToWpi [physPin]);

  281. 

  282. 	// GPIO pin name

  283. 	printf (" | %s", physNames [physPin]);

  284. 

  285. 	// GPIO pin mode, value, drive strength, pupd

  286. 	if ((physToWpi [physPin] == -1) || (physPinToGpio (physPin) == -1)){

  287. 		printf (" |      |   |    |      ") ;

  288. 	}

  289. 

  290. 	else {

  291. 		if (wpMode == MODE_GPIO)

  292. 			pin = physPinToGpio (physPin);

  293. 		else if(wpMode == MODE_PHYS)

  294. 			pin = physPin;

  295. 		else{

  296. 			pin = physToWpi [physPin];

  297. 		}

  298. 		printf (" | %4s", alts [getAlt (pin)]);

  299. 		printf (" | %d", digitalRead (pin));	

  300. 		switch(model) {

  301. 			case MODEL_KHADAS_VIM1:

  302. 			case MODEL_KHADAS_VIM2:

  303. 			case MODEL_KHADAS_VIM3:

  304. 				printf (" |    | %5s", pupd[getPUPD(pin)]);

  305. 				break;

  306. 			default:

  307. 				break;

  308. 		}

  309. 	}

  310. 

  311. 	// Physical pin number

  312. 	printf (" | %2d", (physPin+1)/2);

  313. 	printf (" || %-2d", (physPin+41)/2);

  314. 	++physPin;

  315. 

  316. 	// GPIO pin mode, value, drive strength, pupd

  317. 	if ((physToWpi [physPin] == -1) || (physPinToGpio (physPin) == -1))

  318. 		printf (" |       |    |   |     ");

  319. 	else {

  320. 		if(wpMode == MODE_GPIO)

  321. 			pin = physPinToGpio (physPin);

  322. 		else if(wpMode == MODE_PHYS)

  323. 			pin = physPin;

  324. 		else

  325. 			pin = physToWpi [physPin];

  326. 

  327. 		switch(model){

  328. 			case MODEL_KHADAS_VIM1:

  329. 			case MODEL_KHADAS_VIM2:

  330. 			case MODEL_KHADAS_VIM3:

  331. 				printf (" | %-5s |   ", pupd[getPUPD(pin)]);

  332. 				break;

  333. 			default:

  334. 				break;

  335. 		}

  336. 		printf (" | %d", digitalRead (pin));

  337. 		printf (" | %-4s", alts [getAlt (pin)]);

  338. 	}

  339. 

  340. 	// GPIO pin name

  341. 	printf (" | %-6s", physNames [physPin]);

  342. 

  343. 	//GPIO, wPi pin number

  344. 	if ((physPinToGpio (physPin) == -1) && (physToWpi [physPin] == -1))

  345. 		printf (" |     |     ") ;

  346. 	else if(physPinToGpio (physPin) != -1)

  347. 		printf (" | %-3d |  %-3d", physToWpi [physPin], physPinToGpio (physPin));

  348. 	else

  349. 		printf (" | %-3d |     ", physToWpi [physPin]);

  350. 	

  351. 	printf (" |\n") ;

  352. }

  353. 

  354. static void readallPhysKhadas_edge (int model, int UNU rev, int physPin, const char *physNames[])

  355. {

  356. 	int pin;

  357. 

  358. 	//GPIO, wPi pin number

  359. 	if ((physPinToGpio (physPin) == -1) && (physToWpi_Edge [physPin] == -1))

  360. 		printf (" |      |    ") ;

  361. 	else if (physPinToGpio (physPin) != -1)

  362. 		printf (" |  %3d | %3d", physPinToGpio (physPin), physToWpi_Edge [physPin]);

  363. 	else

  364. 		printf (" |      | %3d", physToWpi_Edge [physPin]);

  365. 

  366. 	// GPIO pin name

  367. 	printf (" | %s", physNames [physPin]);

  368. 

  369. 	// GPIO pin mode, value, drive strength, pupd

  370. 	if ((physToWpi_Edge [physPin] == -1) || (physPinToGpio (physPin) == -1)){

  371. 		printf (" |      |   |    |      ") ;

  372. 	}

  373. 

  374. 	else {

  375. 		if (wpMode == MODE_GPIO)

  376. 			pin = physPinToGpio (physPin);

  377. 		else if(wpMode == MODE_PHYS)

  378. 			pin = physPin;

  379. 		else{

  380. 			pin = physToWpi_Edge [physPin];

  381. 		}

  382. 		printf (" | %4s", alts [getAlt (pin)]);

  383. 		printf (" | %d", digitalRead (pin));	

  384. 		switch(model) {

  385. 			case MODEL_KHADAS_VIM1:

  386. 			case MODEL_KHADAS_VIM2:

  387. 			case MODEL_KHADAS_VIM3:

  388. 				printf (" |    | %5s", pupd[getPUPD(pin)]);

  389. 				break;

  390. 			case MODEL_KHADAS_EDGE:

  391. 				printf (" |    |      ");

  392. 				break;

  393. 			default:

  394. 				break;

  395. 		}

  396. 	}

  397. 

  398. 	// Physical pin number

  399. 	printf (" | %2d", (physPin+1)/2);

  400. 	printf (" || %-2d", (physPin+41)/2);

  401. 	++physPin;

  402. 

  403. 	// GPIO pin mode, value, drive strength, pupd

  404. 	if ((physToWpi_Edge [physPin] == -1) || (physPinToGpio (physPin) == -1))

  405. 		printf (" |       |    |   |     ");

  406. 	else {

  407. 		if(wpMode == MODE_GPIO)

  408. 			pin = physPinToGpio (physPin);

  409. 		else if(wpMode == MODE_PHYS)

  410. 			pin = physPin;

  411. 		else

  412. 			pin = physToWpi_Edge [physPin];

  413. 

  414. 		switch(model){

  415. 			case MODEL_KHADAS_VIM1:

  416. 			case MODEL_KHADAS_VIM2:

  417. 			case MODEL_KHADAS_VIM3:

  418. 				printf (" | %-5s |   ", pupd[getPUPD(pin)]);

  419. 				break;

  420. 			case MODEL_KHADAS_EDGE:

  421. 				printf (" |       |   ");

  422. 				break;				

  423. 			default:

  424. 				break;

  425. 		}

  426. 		printf (" | %d", digitalRead (pin));

  427. 		printf (" | %-4s", alts [getAlt (pin)]);

  428. 	}

  429. 

  430. 	// GPIO pin name

  431. 	printf (" | %-6s", physNames [physPin]);

  432. 

  433. 	//GPIO, wPi pin number

  434. 	if ((physPinToGpio (physPin) == -1) && (physToWpi_Edge [physPin] == -1))

  435. 		printf (" |     |     ") ;

  436. 	else if(physPinToGpio (physPin) != -1)

  437. 		printf (" | %-3d |  %-3d", physToWpi_Edge [physPin], physPinToGpio (physPin));

  438. 	else

  439. 		printf (" | %-3d |     ", physToWpi_Edge [physPin]);

  440. 	

  441. 	printf (" |\n") ;

  442. }

  443. 

  444. /*--------------------------------------------------------------------------------------*/

  445. void ReadallKhadas(int model, int rev, const char *physNames[])

  446. {

  447. 	int pin;

  448. 	if(MODEL_KHADAS_EDGE == model){

  449. 		printf (" | GPIO | wPi |        Name       | Mode | V | DS | PU/PD | Physical | PU/PD | DS | V | Mode |            Name            | wPi | GPIO |\n") ;

  450. 		printf (" +------+-----+-------------------+------+---+----+-------+----++----+-------+----+---+------+----------------------------+-----+------+\n") ;

  451. 		for (pin = 1 ; pin <= 40 ; pin += 2)

  452. 			readallPhysKhadas_edge (model, rev, pin, physNames) ;

  453. 		printf (" +------+-----+-------------------+------+---+----+-------+----++----+-------+----+---+------+----------------------------+-----+------+\n") ;

  454. 	}

  455. 	else{

  456. 		printf (" | GPIO | wPi |   Name   | Mode | V | DS | PU/PD | Physical | PU/PD | DS | V | Mode |   Name   | wPi | GPIO |\n");

  457. 		printf (" +------+-----+----------+------+---+----+-------+----++----+-------+----+---+------+----------+-----+------+\n");

  458. 		for (pin = 1 ; pin <= 40 ; pin += 2)

  459. 			readallPhysKhadas (model, rev, pin, physNames);

  460. 		printf (" +------+-----+----------+------+---+----+-------+----++----+-------+----+---+------+----------+-----+------+\n");

  461. 	}

  462. }

  463. 

  464. /*--------------------------------------------------------------------------------------*/

  465. /*									doReadall											*/

  466. /*	Read all the GPIO pins																*/

  467. /*	We also want to use this to read the state of pins on an externally					*/

  468. /*	connected device, so we need to do some fiddling with the internal					*/

  469. /*	wiringPi node structures - since the gpio command can only use						*/

  470. /*	one external device at a time, we'll use that to our advantage...					*/

  471. /*--------------------------------------------------------------------------------------*/

  472. void doReadall(void)

  473. {

  474. 	int model, rev, mem, maker, overVolted;

  475. 	

  476. 	const char **physNames;

  477. 

  478. 	// External readall

  479. 	if (wiringPiNodes != NULL) {

  480. 		doReadallExternal ();

  481. 		return;

  482. 	}

  483. 

  484. 	piBoardId(&model, &rev, &mem, &maker, &overVolted);

  485. 

  486. 	switch(model){

  487. 		case MODEL_KHADAS_VIM1:

  488. 			printf (" +------+-----+----------+------+---+----+---- Model  KDADAS-VIM1---+----+---+------+----------+-----+------+\n") ;

  489. 			physNames = physNamesKhadasVim1;

  490. 			break;

  491. 		case MODEL_KHADAS_VIM2:

  492. 			printf (" +------+-----+----------+------+---+----+---- Model  KDADAS-VIM2---+----+---+------+----------+-----+------+\n") ;

  493. 			physNames = physNamesKhadasVim2;

  494. 			break;

  495. 		case MODEL_KHADAS_VIM3:

  496. 			printf (" +------+-----+----------+------+---+----+---- Model  KDADAS-VIM3---+----+---+------+----------+-----+------+\n") ;

  497. 			physNames = physNamesKhadasVim3;

  498. 			break;

  499. 		case MODEL_KHADAS_EDGE:

  500. 			printf (" +------+-----+-------------------+------+---+----+--- Model  KHADAS-EDGE ---+----+---+------+----------------------------+-----+------+\n");

  501. 			physNames = physNamesKhadasEdge;

  502. 			break;

  503. 		default:

  504. 			printf ("Oops - unable to determine board type... model: %d\n", model);

  505. 			return;

  506. 	}

  507. 	ReadallKhadas(model, rev, physNames);

  508. }

  509. 

  510. /*--------------------------------------------------------------------------------------*/

  511. /*								doAllReadall											*/

  512. /*	Force reading of all pins regardless of Pi model									*/

  513. /*--------------------------------------------------------------------------------------*/

  514. void doAllReadall(void)

  515. {

  516. 	doReadall();

  517. }

  518. 

  519. /*--------------------------------------------------------------------------------------*/

  520. void doQmode(int argc, char *argv[])

  521. {

  522. 	int pin;

  523. 	if(argc != 3){

  524. 		fprintf (stderr, "Usage: %s qmode pin\n", argv [0]) ;

  525. 		exit(EXIT_FAILURE);

  526. 	}

  527. 

  528. 	pin = atoi(argv[2]);

  529. 	printf("%s\n", alts[getAlt(pin)]);

  530. }

  531. /*--------------------------------------------------------------------------------------*/

  532. /*--------------------------------------------------------------------------------------*/