API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 12th, 2019
139
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 21.13 KB | None | 0 0
raw download clone embed print report
  1. #include "stm32f3xx.h" // Device header
  2. #include <stdint.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. //PA9 TXD
  8. //PA10 RXD
  9.  
  10. //UART con cable
  11. //SPI con pantalla
  12. //I2C con acelerometro
  13.  
  14. #define MASK(x) (1<<x)
  15. extern uint32_t Rec_registros(uint32_t reg);
  16. extern void rm0(uint32_t datitos);
  17. extern void rm1(uint32_t datitos);
  18. extern void rm2(uint32_t datitos);
  19. extern void rm3(uint32_t datitos);
  20. extern void rm4(uint32_t datitos);
  21. extern void rm5(uint32_t datitos);
  22. extern void rm6(uint32_t datitos);
  23. extern void rm7(uint32_t datitos);
  24. extern void rm8(uint32_t datitos);
  25. extern void rm9(uint32_t datitos);
  26. extern void rm10(uint32_t datitos);
  27. extern void rm11(uint32_t datitos);
  28. extern void rm12(uint32_t datitos);
  29. extern void yolo1(uint32_t a,uint32_t b);
  30. extern void yolo2(uint32_t a,uint32_t b);
  31. extern void yolo3(uint32_t a,uint32_t b);
  32. extern void yolo4(uint32_t a,uint32_t b);
  33. uint16_t adc_data;
  34. void ADC_Init (void);
  35.  
  36. float v_ref = 3.3f;
  37. float voltaje = 0.0f;
  38.  
  39. void USART1_Config(void){
  40. RCC->AHBENR |= RCC_AHBENR_GPIOAEN;
  41. RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
  42. GPIOA->MODER |= (2<<18)|(2<<20);
  43. GPIOA->AFR[1] |= (7<<4)|(7<<8);
  44. USART1->BRR = 69; //115200 bauds
  45. USART1->CR1 |= USART_CR1_TE + USART_CR1_RE + USART_CR1_RXNEIE;
  46. USART1->CR1 |= USART_CR1_UE;
  47. NVIC_EnableIRQ(USART1_IRQn);
  48. }
  49.  
  50.  
  51.  
  52.  
  53. void USART1_Send(char c) {
  54. while(!(USART1->ISR & USART_ISR_TXE));
  55. USART1->TDR=c;
  56. }
  57.  
  58. void USART1_putString(char * string) {
  59. while(*string) {
  60. USART1_Send(*string);
  61. string++;
  62. }
  63. }
  64.  
  65. void ADC_Init(void){
  66. USART1_putString("\r\n");
  67. USART1_putString("hol");
  68. USART1_putString("\r\n");
  69. RCC->AHBENR |= RCC_AHBENR_ADC12EN + RCC_AHBENR_GPIOAEN;
  70.  
  71. GPIOA->MODER |= (3<<8);
  72.  
  73. ADC2->CFGR |= ADC_CFGR_CONT + ADC_CFGR_RES_0;
  74.  
  75. ADC2->SQR1 |= (1<<6);
  76.  
  77. ADC1_2_COMMON->CCR |= (3<<16);
  78.  
  79. ADC2->CR |= ADC_CR_ADEN + ADC_CR_ADSTART;
  80. ADC2->IER |= ADC_IER_EOCIE;
  81.  
  82. NVIC_EnableIRQ(ADC1_2_IRQn);
  83. }
  84.  
  85. void ADC1_2_IRQHandler(void){
  86. USART1_putString("\r\n");
  87. USART1_putString("Interrupcion");
  88. USART1_putString("\r\n");
  89. adc_data = ADC2->DR;
  90. }
  91.  
  92. void analizar(char comando[]){
  93. char com[5];
  94. char reg[5];
  95. char data[20];
  96. const char s[2] = " ";
  97. char *token;
  98. token = strtok(comando, s);
  99.  
  100.  
  101. if (strcmp(token, "RD") == 0){
  102. USART1_putString("\r\n");
  103. USART1_putString("Ingreso RD");
  104. USART1_putString("\r\n");
  105. uint32_t val=0;
  106. char res[100] = "";
  107. val = Rec_registros(0);
  108. sprintf(res,"\nR%i: 0x%x\n\r",0,val);
  109. USART1_putString(res);
  110. val = Rec_registros(1);
  111. sprintf(res,"\nR%i: 0x%x\n\r",1,val);
  112. USART1_putString(res);
  113. val = Rec_registros(2);
  114. sprintf(res,"\nR%i: 0x%x\n\r",2,val);
  115. USART1_putString(res);
  116. val = Rec_registros(3);
  117. sprintf(res,"\nR%i: 0x%x\n\r",3,val);
  118. USART1_putString(res);
  119. val = Rec_registros(4);
  120. sprintf(res,"\nR%i: 0x%x\n\r",4,val);
  121. USART1_putString(res);
  122. val = Rec_registros(5);
  123. sprintf(res,"\nR%i: 0x%x\n\r",5,val);
  124. USART1_putString(res);
  125. val = Rec_registros(6);
  126. sprintf(res,"\nR%i: 0x%x\n\r",6,val);
  127. USART1_putString(res);
  128. val = Rec_registros(7);
  129. sprintf(res,"\nR%i: 0x%x\n\r",7,val);
  130. USART1_putString(res);
  131. val = Rec_registros(8);
  132. sprintf(res,"\nR%i: 0x%x\n\r",8,val);
  133. USART1_putString(res);
  134. val = Rec_registros(9);
  135. sprintf(res,"\nR%i: 0x%x\n\r",9,val);
  136. USART1_putString(res);
  137. val = Rec_registros(10);
  138. sprintf(res,"\nR%i: 0x%x\n\r",10,val);
  139. USART1_putString(res);
  140. val = Rec_registros(11);
  141. sprintf(res,"\nR%i: 0x%x\n\r",11,val);
  142. USART1_putString(res);
  143. val = Rec_registros(12);
  144. sprintf(res,"\nR%i: 0x%x\n\r",12,val);
  145. USART1_putString(res);
  146. val = Rec_registros(13);
  147. sprintf(res,"\nR%i: 0x%x\n\r",13,val);
  148. USART1_putString(res);
  149. val = Rec_registros(14);
  150. sprintf(res,"\nR%i: 0x%x\n\r",14,val);
  151. USART1_putString(res);
  152. val = Rec_registros(15);
  153. sprintf(res,"\nR%i: 0x%x\n\r",15,val);
  154. USART1_putString(res);
  155. USART1_putString("\r\n");
  156. }else if(strcmp(token, "RM") == 0){
  157. token = strtok(NULL, s);
  158. if (strcmp(token, "R0") == 0){
  159. token = strtok(NULL, s);
  160. if (token==NULL){
  161. USART1_putString("\r\n");
  162. USART1_putString("error en el comando");
  163. USART1_putString("\r\n");
  164. }else{
  165. char * pEnd;
  166. uint32_t li1;
  167. li1 = strtol (token,&pEnd,16);
  168. rm0(li1);
  169. USART1_putString("\r\n");
  170. USART1_putString("cambio R0");
  171. USART1_putString("\r\n");
  172. }
  173. }else if (strcmp(token, "R1") == 0){
  174. token = strtok(NULL, s);
  175. if (token==NULL){
  176. USART1_putString("\r\n");
  177. USART1_putString("error en el comando");
  178. USART1_putString("\r\n");
  179. }else{
  180. char * pEnd;
  181. uint32_t li1;
  182. li1 = strtol (token,&pEnd,16);
  183. rm1(li1);
  184. USART1_putString("\r\n");
  185. USART1_putString("cambio R1");
  186. USART1_putString("\r\n");
  187. }
  188. }else if (strcmp(token, "R2") == 0){
  189. token = strtok(NULL, s);
  190. if (token==NULL){
  191. USART1_putString("\r\n");
  192. USART1_putString("error en el comando");
  193. USART1_putString("\r\n");
  194. }else{
  195. char * pEnd;
  196. uint32_t li1;
  197. li1 = strtol (token,&pEnd,16);
  198. rm2(li1);
  199. USART1_putString("\r\n");
  200. USART1_putString("cambio R2");
  201. USART1_putString("\r\n");
  202. }
  203. }else if (strcmp(token, "R3") == 0){
  204. token = strtok(NULL, s);
  205. if (token==NULL){
  206. USART1_putString("\r\n");
  207. USART1_putString("error en el comando");
  208. USART1_putString("\r\n");
  209. }else{
  210. char * pEnd;
  211. uint32_t li1;
  212. li1 = strtol (token,&pEnd,16);
  213. rm3(li1);
  214. USART1_putString("\r\n");
  215. USART1_putString("cambio R3");
  216. USART1_putString("\r\n");
  217. }
  218. }else if (strcmp(token, "R4") == 0){
  219. token = strtok(NULL, s);
  220. if (token==NULL){
  221. USART1_putString("\r\n");
  222. USART1_putString("error en el comando");
  223. USART1_putString("\r\n");
  224. }else{
  225. char * pEnd;
  226. uint32_t li1;
  227. li1 = strtol (token,&pEnd,16);
  228. rm4(li1);
  229. USART1_putString("\r\n");
  230. USART1_putString("cambio R4");
  231. USART1_putString("\r\n");
  232. }
  233. }else if (strcmp(token, "R5") == 0){
  234. token = strtok(NULL, s);
  235. if (token==NULL){
  236. USART1_putString("\r\n");
  237. USART1_putString("error en el comando");
  238. USART1_putString("\r\n");
  239. }else{
  240. char * pEnd;
  241. uint32_t li1;
  242. li1 = strtol (token,&pEnd,16);
  243. rm5(li1);
  244. USART1_putString("\r\n");
  245. USART1_putString("cambio R5");
  246. USART1_putString("\r\n");
  247. }
  248. }else if (strcmp(token, "R6") == 0){
  249. token = strtok(NULL, s);
  250. if (token==NULL){
  251. USART1_putString("\r\n");
  252. USART1_putString("error en el comando");
  253. USART1_putString("\r\n");
  254. }else{
  255. char * pEnd;
  256. uint32_t li1;
  257. li1 = strtol (token,&pEnd,16);
  258. rm6(li1);
  259. USART1_putString("\r\n");
  260. USART1_putString("cambio R6");
  261. USART1_putString("\r\n");
  262. }
  263. }else if (strcmp(token, "R7") == 0){
  264. token = strtok(NULL, s);
  265. if (token==NULL){
  266. USART1_putString("\r\n");
  267. USART1_putString("error en el comando");
  268. USART1_putString("\r\n");
  269. }else{
  270. char * pEnd;
  271. uint32_t li1;
  272. li1 = strtol (token,&pEnd,16);
  273. rm7(li1);
  274. USART1_putString("\r\n");
  275. USART1_putString("cambio R7");
  276. USART1_putString("\r\n");
  277. }
  278. }else if (strcmp(token, "R8") == 0){
  279. token = strtok(NULL, s);
  280. if (token==NULL){
  281. USART1_putString("\r\n");
  282. USART1_putString("error en el comando");
  283. USART1_putString("\r\n");
  284. }else{
  285. char * pEnd;
  286. uint32_t li1;
  287. li1 = strtol (token,&pEnd,16);
  288. rm8(li1);
  289. USART1_putString("\r\n");
  290. USART1_putString("cambio R8");
  291. USART1_putString("\r\n");
  292. }
  293. }else if (strcmp(token, "R9") == 0){
  294. token = strtok(NULL, s);
  295. if (token==NULL){
  296. USART1_putString("\r\n");
  297. USART1_putString("error en el comando");
  298. USART1_putString("\r\n");
  299. }else{
  300. char * pEnd;
  301. uint32_t li1;
  302. li1 = strtol (token,&pEnd,16);
  303. rm9(li1);
  304. USART1_putString("\r\n");
  305. USART1_putString("cambio R9");
  306. USART1_putString("\r\n");
  307. }
  308. }else if (strcmp(token, "R10") == 0){
  309. token = strtok(NULL, s);
  310. if (token==NULL){
  311. USART1_putString("\r\n");
  312. USART1_putString("error en el comando");
  313. USART1_putString("\r\n");
  314. }else{
  315. char * pEndp;
  316. uint32_t li1p;
  317. li1p = strtol (token,&pEndp,16);
  318. rm10(li1p);
  319. USART1_putString("\r\n");
  320. USART1_putString("cambio R10");
  321. USART1_putString("\r\n");
  322. }
  323. }else if (strcmp(token, "R11") == 0){
  324. token = strtok(NULL, s);
  325. if (token==NULL){
  326. USART1_putString("\r\n");
  327. USART1_putString("error en el comando");
  328. USART1_putString("\r\n");
  329. }else{
  330. char * pEnd;
  331. uint32_t li1;
  332. li1 = strtol (token,&pEnd,16);
  333. rm11(li1);
  334. USART1_putString("\r\n");
  335. USART1_putString("cambio R11");
  336. USART1_putString("\r\n");
  337. }
  338. }else if (strcmp(token, "R12") == 0){
  339. token = strtok(NULL, s);
  340. if (token==NULL){
  341. USART1_putString("\r\n");
  342. USART1_putString("error en el comando");
  343. USART1_putString("\r\n");
  344. }else{
  345. char * pEnd;
  346. uint32_t li1;
  347. li1 = strtol (token,&pEnd,16);
  348. rm12(li1);
  349. USART1_putString("\r\n");
  350. USART1_putString("cambio R12");
  351. USART1_putString("\r\n");
  352. }
  353. }else{
  354. USART1_putString("\r\n");
  355. USART1_putString("registro inválido.");
  356. USART1_putString("\r\n");
  357. }
  358. }else if(strcmp(token, "MD") == 0){
  359. USART1_putString("\r\n");
  360. USART1_putString("Ingreso MD");
  361. USART1_putString("\r\n");
  362. token = strtok(NULL, s);
  363. if(token == NULL){
  364. USART1_putString("No hay start y end, se utilizaran los valores default\r\nDe 0x2000064c a 0x20000666\r\n");
  365.  
  366. char *p = (char *) 0x2000064c;
  367. char otro[2];
  368.  
  369. int i ;
  370. for (i = 0; i < (0x20000666 - 0x2000064c); ++i)
  371. {
  372. sprintf(otro,"%02x", p[i]);
  373. USART1_putString(otro);
  374. USART1_putString(" ");
  375. }
  376. USART1_putString("\r\n");
  377.  
  378. USART1_putString("\r\n");
  379. }else{
  380. char * start;
  381. uint32_t li1;
  382. li1 = strtol (token,&start,16);
  383. start = token;
  384. token = strtok(NULL, s);
  385. if(token == NULL){
  386. USART1_putString("Comando invalido");
  387. USART1_putString("\r\n");
  388. }else{
  389. char * resta;
  390. char *end;
  391. uint32_t li2;
  392. li2 = strtol (token,&end,16);
  393. end = token;
  394. uint32_t jka = li2-li1;
  395.  
  396. char *p = (char *) li1;
  397. char otro[2];
  398. int contador = 4;
  399. char imprimir[11];
  400. while (li1< li2){
  401. if (!(contador%4)){
  402. USART1_putString("\r\n");
  403. sprintf(imprimir,"%x",li1);
  404. USART1_putString(imprimir);
  405. USART1_putString(": ");
  406. }
  407. sprintf(otro,"%02x", p[0]);
  408. USART1_putString(otro);
  409. USART1_putString("");
  410. li1++;
  411. p++;
  412. contador++;
  413. }
  414. USART1_putString("\r\n");
  415. }
  416. }
  417.  
  418. }else if(strcmp(token, "MM") == 0){
  419. USART1_putString("\r\n");
  420. USART1_putString("Ingreso MM");
  421. USART1_putString("\r\n");
  422. token = strtok(NULL, s);
  423. if (token == NULL){
  424. USART1_putString("\r\n");
  425. USART1_putString("falta addr");
  426. USART1_putString("\r\n");
  427. }else{
  428. char * addr;
  429. uint32_t addrN;
  430. addrN = strtol (token,&addr,16);
  431. addr = token;
  432. token = strtok(NULL, s);
  433. if (token == NULL){
  434. USART1_putString("\r\n");
  435. USART1_putString("falta data");
  436. USART1_putString("\r\n");
  437. }else{
  438. char * data;
  439. uint32_t dataN;
  440. dataN = strtol (token,&data,16);
  441. data = token;
  442. token = strtok(NULL, s);
  443. if (token==NULL){
  444. USART1_putString("\r\n");
  445. USART1_putString("falta size");
  446. USART1_putString("\r\n");
  447. }else{
  448. char * size;
  449. uint32_t sizeN;
  450. sizeN = strtol (token,&size,16);
  451. size = token;
  452. if (sizeN == 1){
  453. USART1_putString("\r\n");
  454. USART1_putString("Size de 1 byte");
  455. USART1_putString("\r\n");
  456. yolo1(addrN,dataN);
  457. }else if(sizeN == 2){
  458. USART1_putString("\r\n");
  459. USART1_putString("Size de 2 byte");
  460. USART1_putString("\r\n");
  461. yolo2(addrN,dataN);
  462. }else if(sizeN == 3){
  463. USART1_putString("\r\n");
  464. USART1_putString("Size de 3 byte");
  465. USART1_putString("\r\n");
  466. yolo3(addrN,dataN);
  467. }else if(sizeN == 4){
  468. USART1_putString("\r\n");
  469. USART1_putString("Size de 4 byte");
  470. USART1_putString("\r\n");
  471. yolo4(addrN,dataN);
  472. }else{
  473. USART1_putString("\r\n");
  474. USART1_putString("Size invalido, SE USARA DEFAULT DE 1");
  475. yolo1(addrN,dataN);
  476. USART1_putString("\r\n");
  477. }
  478. //podemos trabajar
  479. USART1_putString("\r\n");
  480. USART1_putString(addr);
  481. USART1_putString(" ");
  482. USART1_putString(data);
  483. USART1_putString(" ");
  484. USART1_putString(size);
  485. USART1_putString("\r\n");
  486. }
  487. }
  488. }
  489. }else if(strcmp(token, "BF") == 0){
  490. USART1_putString("\r\n");
  491. USART1_putString("Ingreso BF");
  492. USART1_putString("\r\n");
  493. token = strtok(NULL, s);
  494. if (token == NULL){
  495. USART1_putString("\r\n");
  496. USART1_putString("falta start");
  497. USART1_putString("\r\n");
  498. }else{
  499. char * start;
  500. uint32_t startN;
  501. startN = strtol (token,&start,16);
  502. start = token;
  503. token = strtok(NULL, s);
  504. if (token == NULL){
  505. USART1_putString("\r\n");
  506. USART1_putString("falta end");
  507. USART1_putString("\r\n");
  508. }else{
  509. char * end;
  510. uint32_t endN;
  511. endN = strtol (token,&end,16);
  512. end = token;
  513. token = strtok(NULL, s);
  514. if (token == NULL){
  515. USART1_putString("\r\n");
  516. USART1_putString("falta data");
  517. USART1_putString("\r\n");
  518. }else{
  519. char * data;
  520. uint32_t dataN;
  521. dataN = strtol (token,&data,16);
  522. data = token;
  523. token = strtok(NULL, s);
  524. if (token == NULL){
  525. USART1_putString("\r\n");
  526. USART1_putString("No hay size, se usara el valor default de 1");
  527. USART1_putString("\r\n");
  528. while (startN<endN){
  529. yolo1(startN,dataN);
  530. startN++;
  531. }
  532. }else{
  533. char * size;
  534. uint32_t sizeN;
  535. sizeN = strtol (token,&size,16);
  536. size = token;
  537. if (sizeN==1){
  538. USART1_putString("\r\n");
  539. USART1_putString("Size = 1");
  540. USART1_putString("\r\n");
  541. while (startN<endN){
  542. yolo1(startN,dataN);
  543. startN++;
  544. }
  545. }else if(sizeN==2){
  546. USART1_putString("\r\n");
  547. USART1_putString("Size = 2");
  548. USART1_putString("\r\n");
  549. while (startN<endN){
  550. yolo2(startN,dataN);
  551. startN++;startN++;
  552. }
  553. }else if(sizeN==3){
  554. USART1_putString("\r\n");
  555. USART1_putString("Size = 3");
  556. USART1_putString("\r\n");
  557. while (startN<endN){
  558. yolo3(startN,dataN);
  559. startN++;startN++;startN++;
  560. }
  561. }else if(sizeN==4){
  562. USART1_putString("\r\n");
  563. USART1_putString("Size = 4");
  564. USART1_putString("\r\n");
  565. while (startN<endN){
  566. yolo4(startN,dataN);
  567. startN++;startN++;startN++;startN++;
  568. }
  569. }else{
  570. USART1_putString("\r\n");
  571. USART1_putString("size invalido");
  572. USART1_putString("\r\n");
  573. }
  574. USART1_putString("\r\n");
  575. USART1_putString(start);
  576. USART1_putString(" ");
  577. USART1_putString(end);
  578. USART1_putString(" ");
  579. USART1_putString(data);
  580. USART1_putString(" ");
  581. USART1_putString(size);
  582. USART1_putString("\r\n");
  583. }
  584. }
  585. }
  586. }
  587. }else if(strcmp(token, "RUN") == 0){
  588. USART1_putString("\r\n");
  589. USART1_putString("Ingreso RUN");
  590. USART1_putString("\r\n");
  591. }else if(strcmp(token, "CALL") == 0){
  592. USART1_putString("\r\n");
  593. USART1_putString("Ingreso CALL");
  594. USART1_putString("\r\n");
  595. }else if(strcmp(token, "Ain") == 0){
  596. USART1_putString("\r\n");
  597. USART1_putString("Ingreso Ain");
  598. USART1_putString("\r\n");
  599.  
  600. uint8_t valDef;
  601. token = strtok(NULL, s);
  602. char * punt;
  603. uint32_t strtoint;
  604. strtoint = strtol (token,&punt,8);
  605. ADC_Init();
  606. RCC->AHBENR |= RCC_AHBENR_GPIODEN;
  607. GPIOD->MODER |= MASK(16) + MASK(18) +MASK(20) +MASK(22) +MASK(24) +MASK(26) +MASK(28) +MASK(30);
  608. /*
  609. if (token == NULL){
  610. ADC2->CFGR |= ADC_CFGR_RES_0;
  611. } else{
  612.  
  613. if(strtoint == 6){
  614. ADC1->CFGR |= (3<<4);
  615. }else if(strtoint == 8){
  616. ADC1->CFGR |= (2<<4);
  617. }else if(strtoint == 10){
  618. ADC1->CFGR |= (1<<4);
  619. }if(strtoint == 12){
  620. ADC1->CFGR &= ~(11<<4);
  621. }else{
  622. USART1_putString("\r\n");
  623. USART1_putString("El valor de resolucion es incorrecto");
  624. USART1_putString("\r\n");
  625. }
  626.  
  627. }*/
  628.  
  629.  
  630.  
  631.  
  632. GPIOD->ODR |=(1<<8);
  633. GPIOD->ODR |=(1<<9);
  634. GPIOD->ODR |=(1<<10);
  635. GPIOD->ODR |=(1<<11);
  636. GPIOD->ODR |=(1<<12);
  637. GPIOD->ODR |=(1<<13);
  638. GPIOD->ODR |=(1<<14);
  639. GPIOD->ODR |=(1<<15);
  640. while(1){
  641. voltaje = (adc_data*v_ref)/1023.0f;
  642. /*char array[10];
  643. sprintf(array, "%f", voltaje);
  644. USART1_putString("\r\n");
  645. USART1_putString(array);
  646. USART1_putString("\r\n");*/
  647. if (voltaje > (v_ref*0.8888f)){
  648. GPIOD->ODR |=(1<<8);
  649. GPIOD->ODR |=(1<<9);
  650. GPIOD->ODR |=(1<<10);
  651. GPIOD->ODR |=(1<<11);
  652. GPIOD->ODR |=(1<<12);
  653. GPIOD->ODR |=(1<<13);
  654. GPIOD->ODR |=(1<<14);
  655. GPIOD->ODR |=(1<<15);}
  656. else if (voltaje > (v_ref*0.7777f)){
  657. GPIOD->ODR |=(1<<8);
  658. GPIOD->ODR |=(1<<9);
  659. GPIOD->ODR |=(1<<10);
  660. GPIOD->ODR |=(1<<11);
  661. GPIOD->ODR |=(1<<12);
  662. GPIOD->ODR |=(1<<13);
  663. GPIOD->ODR |=(1<<14);
  664. GPIOD->ODR &= ~(1<<15);}
  665. else if (voltaje > (v_ref*0.6666f)){
  666. GPIOD->ODR |=(1<<8);
  667. GPIOD->ODR |=(1<<9);
  668. GPIOD->ODR |=(1<<10);
  669. GPIOD->ODR |=(1<<11);
  670. GPIOD->ODR |=(1<<12);
  671. GPIOD->ODR |=(1<<13);
  672. GPIOD->ODR &= ~(1<<14);
  673. GPIOD->ODR &= ~(1<<15);}
  674. else if (voltaje > (v_ref*0.5555f)){
  675. GPIOD->ODR |=(1<<8);
  676. GPIOD->ODR |=(1<<9);
  677. GPIOD->ODR |=(1<<10);
  678. GPIOD->ODR |=(1<<11);
  679. GPIOD->ODR |=(1<<12);
  680. GPIOD->ODR &= ~(1<<13);
  681. GPIOD->ODR &= ~(1<<14);
  682. GPIOD->ODR &= ~(1<<15);}
  683. else if (voltaje > (v_ref*0.4444f)){
  684. GPIOD->ODR |=(1<<8);
  685. GPIOD->ODR |=(1<<9);
  686. GPIOD->ODR |=(1<<10);
  687. GPIOD->ODR |=(1<<11);
  688. GPIOD->ODR &= ~(1<<12);
  689. GPIOD->ODR &= ~(1<<13);
  690. GPIOD->ODR &= ~(1<<14);
  691. GPIOD->ODR &= ~(1<<15);}
  692. else if (voltaje > (v_ref*0.3333f)){
  693. GPIOD->ODR |= (1<<8);
  694. GPIOD->ODR |= (1<<9);
  695. GPIOD->ODR |= (1<<10);
  696. GPIOD->ODR &= ~(1<<11);
  697. GPIOD->ODR &= ~(1<<12);
  698. GPIOD->ODR &= ~(1<<13);
  699. GPIOD->ODR &= ~(1<<14);
  700. GPIOD->ODR &= ~(1<<15);}
  701. else if (voltaje > (v_ref*0.2222f)){
  702. GPIOD->ODR |= (1<<8);
  703. GPIOD->ODR |= (1<<9);
  704. GPIOD->ODR &= ~(1<<10);
  705. GPIOD->ODR &= ~(1<<11);
  706. GPIOD->ODR &= ~(1<<12);
  707. GPIOD->ODR &= ~(1<<13);
  708. GPIOD->ODR &= ~(1<<14);
  709. GPIOD->ODR &= ~(1<<15);}
  710. else if (voltaje > (v_ref*0.1111f)){
  711. GPIOD->ODR |= (1<<8);
  712. GPIOD->ODR &= ~(1<<9);
  713. GPIOD->ODR &= ~(1<<10);
  714. GPIOD->ODR &= ~(1<<11);
  715. GPIOD->ODR &= ~(1<<12);
  716. GPIOD->ODR &= ~(1<<13);
  717. GPIOD->ODR &= ~(1<<14);
  718. GPIOD->ODR &= ~(1<<15);
  719. }else{
  720. GPIOD->ODR &= ~(1<<8);
  721. GPIOD->ODR &= ~(1<<9);
  722. GPIOD->ODR &= ~(1<<10);
  723. GPIOD->ODR &= ~(1<<11);
  724. GPIOD->ODR &= ~(1<<12);
  725. GPIOD->ODR &= ~(1<<13);
  726. GPIOD->ODR &= ~(1<<14);
  727. GPIOD->ODR &= ~(1<<15);
  728. }
  729. }
  730. /* while(1){
  731. voltaje = (adc_data*v_ref)/1023.0f;
  732. char * dir;
  733. * dir = voltaje;
  734. USART1_putString("\r\n");
  735. USART1_putString(dir);
  736. USART1_putString("\r\n");
  737.  
  738. }*/
  739.  
  740.  
  741.  
  742. }else{
  743. USART1_putString("\r\n");
  744. USART1_putString("Comando inválido");
  745. USART1_putString("\r\n");
  746. }
  747. }
  748.  
  749.  
  750. int cont=0;
  751.  
  752. //PA9-Verde
  753. void USART1_IRQHandler(void) {
  754. char uart_data;
  755. char string[100];
  756. char forma[100];
  757. if(USART1->ISR & USART_ISR_RXNE) {
  758. uart_data = USART1->RDR;
  759. if(uart_data!='\r'){
  760. string[cont]=uart_data;
  761. USART1_Send(uart_data);
  762. cont++;
  763. } else {
  764. //Analiza aqui
  765. //sprintf(forma,"\n\rSTRING: %s\n\r",string);
  766. //USART1_putString(forma);
  767. sprintf(forma,"%s",string);
  768. analizar(forma);
  769. cont=0;
  770. memset(string,0,sizeof(string));
  771. char formato[24];
  772. sprintf(formato,">>Microprocesadores 2019\n\r");
  773. USART1_putString(formato);
  774. }
  775. }
  776. }
  777.  
  778.  
  779.  
  780. int main() {
  781. char formato[24];
  782. USART1_Config();
  783. sprintf(formato,">>Microprocesadores 2019\n\r");
  784. USART1_putString(formato);
  785. while(1) {
  786.  
  787. }
  788. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!