OK Mégsem
Fórum témák

» Több friss téma
Fórum » ARM - Miértek hogyanok
ARM - Miértek hogyanok
 
Témaindító: gtk, idő: Jún 26, 2007
Témakörök:
Lapozás: OK   104 / 176
(#) kiborg válasza csatti2 hozzászólására (») Okt 27, 2017 /
 
Szia!

Köszi. Igen, azt bűvölöm továbbra is
Viszont ezt a modult használom, amiben van felhúzó ellenállás is.
Namost én is raktam az SDA és SCL vonalakra 4,7kOhm-os ellenállást.
Meg jön még rá más modul is, aminek valószínűleg szintén van saját felhúzó ellenállása.
Okozni fog-e ilyen sok felhúzóellenállás problémát? Vagy a modulokról vegyem inkább le őket?
(#) csatti2 válasza kiborg hozzászólására (») Okt 27, 2017 /
 
Hát azért ésszel kell használni őket. Ha az effektív ellenállás 1k5 alá csökken akkor szedjél le belőlük. Mint oly sok minden, ez is kompromisszumokkal működik. A nagyobb ellenállás kisebb fogyasztást jelent viszont cserébe lassabb busz sebesség használható csak. A kisebb ellenállás lehetővé teszi a nagyobb sebesség használatát, de károsíthatja az eszközöket ha az áram már túl nagy.
(#) kiborg válasza csatti2 hozzászólására (») Okt 28, 2017 /
 
Szia, köszi, meglesz.
Továbbra is maradnék a STM32-nél, de más jellegű probléma.
Van 3 gombom a B12,B13,B14 porton és egy RTC másodpercenkénti megszakítása a B15-ön.
Azt szeretném, hogy ha valamelyik gombot megnyomom(akkor ugye meghívódik a hozzá tartozó megszakítás,ezt jelzem a főprogramnak, ahol ha érzékelte a gombnyomást,akkor vár 20ms-t(systickel késleltetve), majd újra ellenőrzi a gomb lenyomott állapotát, ha le van nyomva, akkor hajtja végre az gombhoz tartozó utasítást.
Namost gombnyomáskor le kellene tiltani a B15-ön beérkező megszakításokat.
De csak ott! Hogyan?
  1. EXTI_InitTypeDef EXTI_InitStructure;
  2.                             EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  3.                             EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  4.                             EXTI_InitStructure.EXTI_Line = EXTI_Line15;
  5.                             EXTI_InitStructure.EXTI_LineCmd = DISABLE;
  6.                             EXTI_Init(&EXTI_InitStructure);


Ez így jó vagy van egyszerűbb módja is? Mert ugye ezzel konfigolom is a B15-t, csak ott ENABLE van.
(#) csatti2 válasza kiborg hozzászólására (») Okt 28, 2017 /
 
Direkt regiszter piszkálással egyszerűbb (a low layernek is van elegánsabb utasítása).
Csinálhatod mondjuk így is:
  1. EXTI_InitTypeDef EXTI_InitStructure;
  2. EXTI_StructInit(&EXTI_InitStructure);
  3. EXTI_InitStructure.EXTI_Line = EXTI_Line15;
  4. EXTI_Init(&EXTI_InitStructure);
(#) kiborg válasza csatti2 hozzászólására (») Okt 28, 2017 /
 
Ahha, viszont ez csak "negál", tehát ha engedélyezve volt, akkor tiltva lesz, ha tiltva volt, akkor engedélyezve lesz. Jól gondolom?
Mert ha igen, akkor ha két függvényt létrehozok, hogy EXTI15_Disable és EXTI15_Enable és belerakom amit az előző hozzászólásban írtam, az úgy kevesebb sor és jobban olvasható.
(#) csatti2 válasza kiborg hozzászólására (») Okt 28, 2017 /
 
Amit írtam, az nem negál hanem tilt.
(#) kiborg válasza csatti2 hozzászólására (») Okt 28, 2017 /
 
Háááááááááááát, ez a C-s rövidítések &,!, stb-k nem az én világom még. Szoknom kell és tanulnom.
Amit írtál annak akkor a ! változata lesz az engedélyezés?
Viszont nem szép, de
  1. void EXTI15_Disable()
  2.     {
  3.         EXTI_InitTypeDef EXTI_InitStructure;
  4.             EXTI_ClearITPendingBit(EXTI_Line15);
  5.                 EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  6.                 EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  7.                 EXTI_InitStructure.EXTI_Line = EXTI_Line15;
  8.                 EXTI_InitStructure.EXTI_LineCmd = DISABLE;
  9.                 EXTI_Init(&EXTI_InitStructure);
  10.     }
  11.  
  12.  
  13. void EXTI15_Enable()
  14.     {
  15.         EXTI_InitTypeDef EXTI_InitStructure;
  16.             EXTI_ClearITPendingBit(EXTI_Line15);
  17.                 EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  18.                 EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
  19.                 EXTI_InitStructure.EXTI_Line = EXTI_Line15;
  20.                 EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  21.                 EXTI_Init(&EXTI_InitStructure);
  22.     }

így is működik ?
(#) csatti2 válasza kiborg hozzászólására (») Okt 28, 2017 /
 
Kevered a szezont a fazonnal. Az & használata a változó előtt pointerré alakítja át azt, azaz a változót cím és nem pedig érték alapján adjuk át. Ez sokkal "olcsóbb" mint a másik lehetőség, cserébe a hívott függvény beleírhat a változónkba (gyakran ez is a cél), ezért ezzel számolnunk kell.

A megoldásod működni fog, bár a mode és a trigger beállítása a tiltáskor felesleges, mivel figyelmen kívül hagyja majd azokat a függvény.
(#) kiborg válasza csatti2 hozzászólására (») Okt 28, 2017 /
 
Igen, sajnos keverek még sok mindent, ez a pointeres dolog még homályos.
8-bites AVR-ektől csöppentem ide, ott is assemblyben programoztam, szóval minden újdonságként hat rám. Ezért kérdezek néha nagyon buta és egyszerű dolgokat is. Ezért bocsánatot kérek mindenkitől. Nekem ezek még nem triviálisak.
Esetleg valami könyv, ahol ezeknek utána lehet nézni(magyarul ha lehetséges)?
Ettől függetlenül köszi a segítséget.
(#) csatti2 válasza kiborg hozzászólására (») Okt 28, 2017 /
 
Nézd át ezt:
Programozás C nyelven

Ha vmiről többet szeretnél tudni, akkor keress rá a stack overflow-n, esetleg vegyél rendes papírkönyvet.
(#) kiborg hozzászólása Nov 3, 2017 /
 
Sziasztok!

Újabb gondom támadt.STM32F103C8
Systicket használom fel a késleltetésekhez és van időszak, amikor nem használom, mert nincs olyan dolog,amit késleltetni kell.
Ebben az esetben, pár másodperc eltelte után megakad a programomban a kijelzés. A program fut,mert az RTC 1Hz-en villogó lábát követi a kimenetre kötött Led. Viszont a kijelzéshez hozzá tartozik SPI-s és I2C-s kommunikáció(ami szintén megszakítást használ, mint a Systick).

Ha ilyenkor megállítom a programot, a TimeTick_Decrement vagy SysTick_Handler részben áll meg.

Így használom a Systicket, véleményetek szerint ez így jó, vagy csináljak valamit másképp?
  1. void SysTick_Init(void) {
  2.         /****************************************
  3.          *SystemFrequency/1000      1ms         *
  4.          *SystemFrequency/100000    10us        *
  5.          *SystemFrequency/1000000   1us         *
  6.          ****************************************/
  7.         while (SysTick_Config(SystemCoreClock / 1000000) != 0) {
  8.         } // One SysTick interrupt now equals 1us
  9.  
  10. }
  11.  
  12. void   delay_1ms ( void )   {
  13.          sysTickCounter   =   1000 ;
  14.          while   ( sysTickCounter   !=   0 )   {
  15.          }
  16.  }
  17.  
  18. void   delay_Nms ( u32   n )   {
  19.          while   ( n -- )   {
  20.                  delay_1ms ( ) ;
  21.          }
  22.  }
  23.  
  24. void   TimeTick_Decrement ( void )   {
  25.          if   ( sysTickCounter   !=   0x00 )   {
  26.                  sysTickCounter -- ;
  27.          }
  28.  }
  29.  
  30. void   SysTick_Handler ( void )   {
  31.          TimeTick_Decrement ( ) ;
  32.          //counter--;
  33.  }
A hozzászólás módosítva: Nov 3, 2017
(#) csatti2 válasza kiborg hozzászólására (») Nov 3, 2017 /
 
Ez borzasztó!

1us-enként meghívsz egy megszakítást, ami utána meghív egy másik másik funkciót, ami csökkent egy változót. A procid az ideje nagy részében feleslegesen teker egy rosszul megírt időzítőrutin érdekében... Vedd figyelembe, hogy a megszakítás költséges (regiszterek mentése/visszaállítása, CPU állapot váltások stb.), a függvényhívás szintén költséges (kivéve ha a fordító okosabb nálad és inline-á teszi).

Jobb megoldás lenne, ha úgy konfigurálnád fel az időzítőd, hogy bizonyos (értelmes) időközönként meghívódik (pl. 1-10ms), ezzel növelhetsz egy belső időreferencia értéket (akármit). A főprogramodban pedig ciklikusan figyelhetnéd, kell-e vmit csinálni és ha nem, akkor elküldheted aludni a CPU-t a "__WFI();" utasítással (a megszakítások majd felébresztik, ekkor újra lefuthat a ciklus).
A hozzászólás módosítva: Nov 3, 2017
(#) kiborg válasza csatti2 hozzászólására (») Nov 3, 2017 /
 
Igen, ez lemaradt:
  1. void   delay_10us ( void )   {
  2.          sysTickCounter   =   10;
  3.          while   ( sysTickCounter   !=   0 )   {
  4.          }
  5.  }
  6.  
  7. void  delay_Nus ( u32   n )   {
  8.          while   ( n -- )   {
  9.                  delay_10us ( ) ;
  10.          }
  11.  }


Ezért usecenként systick(sorry ez lemaradt),mert van periféria,ahol a us-es késleltetés kell, a semmi kevés, a ms meg már sok és látszódik a kijelzőn, hogy megakad,bár ha átvariálom, akkor talán nem.
(#) rolandgw válasza kiborg hozzászólására (») Nov 3, 2017 /
 
Delay-t megszakítás nélkül is csinálhatsz Systick-el, flag figyeléssel. Ezt a Low-layer könyvtárból vettem át NXP-re, egy az egyben, mivel a core része, csak átneveztem. A frekvenciát kell korrigálnod:

LPC_Init1msTick(30000000);
NVIC_SetPriority(SysTick_IRQn,0);

systick.h
systick.c		   
(#) csatti2 válasza kiborg hozzászólására (») Nov 4, 2017 /
 
Milyen perifériához kell neked us időzítés? Bitbang-elsz vmit?
(#) kiborg válasza csatti2 hozzászólására (») Nov 4, 2017 /
 
Egy VDF kijelző írás parancsai között kell egy kis szünetet tartani, 10us már elegendő. Ha ms tartományba megyek előfordulhat villogás.

Megpróbálom a megszakítás nélküli delayt megoldani. Hátha megértem, hogy hogyan működik.
(#) vargham hozzászólása Nov 5, 2017 /
 
Sziasztok! STM32 ADC kérdésem van. Mikrokontroller: STM32F103C8.
ADC Setup:
  1. /* ADC1 init function */
  2. static void MX_ADC1_Init(void)
  3. {
  4.  
  5.   ADC_ChannelConfTypeDef sConfig;
  6.  
  7.     /**Common config
  8.     */
  9.   hadc1.Instance = ADC1;
  10.   hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  11.   hadc1.Init.ContinuousConvMode = ENABLE;
  12.   hadc1.Init.DiscontinuousConvMode = DISABLE;
  13.   hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  14.   hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  15.   hadc1.Init.NbrOfConversion = 4;
  16.   if (HAL_ADC_Init(&hadc1) != HAL_OK)
  17.   {
  18.     _Error_Handler(__FILE__, __LINE__);
  19.   }
  20.  
  21.     /**Configure Regular Channel
  22.     */
  23.   sConfig.Channel = ADC_CHANNEL_4;
  24.   sConfig.Rank = 1;
  25.   sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;
  26.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  27.   {
  28.     _Error_Handler(__FILE__, __LINE__);
  29.   }
  30.  
  31.     /**Configure Regular Channel
  32.     */
  33.   sConfig.Channel = ADC_CHANNEL_5;
  34.   sConfig.Rank = 2;
  35.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  36.   {
  37.     _Error_Handler(__FILE__, __LINE__);
  38.   }
  39.  
  40.     /**Configure Regular Channel
  41.     */
  42.   sConfig.Channel = ADC_CHANNEL_6;
  43.   sConfig.Rank = 3;
  44.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  45.   {
  46.     _Error_Handler(__FILE__, __LINE__);
  47.   }
  48.  
  49.     /**Configure Regular Channel
  50.     */
  51.   sConfig.Channel = ADC_CHANNEL_7;
  52.   sConfig.Rank = 4;
  53.   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  54.   {
  55.     _Error_Handler(__FILE__, __LINE__);
  56.   }
  57.  
  58. }


DMA Setup:
  1. static void MX_DMA_Init(void)
  2. {
  3.   /* DMA controller clock enable */
  4.   __HAL_RCC_DMA1_CLK_ENABLE();
  5.  
  6.   /* DMA interrupt init */
  7.   /* DMA1_Channel1_IRQn interrupt configuration */
  8.   HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 5, 0);
  9.   HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
  10.  
  11. }


Finish callback:
  1. extern "C" void HAL_ADC_ConvCpltCallback (ADC_HandleTypeDef *hadc) {
  2.   HAL_ADC_Start_DMA(hadc, (uint32_t*)aADCxConvertedValues, adcConverterBufferSize);
  3. }


Használt változók:
  1. const uint32_t adcConverterBufferSize = 4;
  2. __IO uint16_t aADCxConvertedValues[adcConverterBufferSize];


Indítás a program elején:
  1. HAL_ADCEx_Calibration_Start(&hadc1);
  2. HAL_ADC_Start_DMA(&hadc1, (uint32_t*)aADCxConvertedValues, adcConverterBufferSize);


Négy ADC csatornára feszültségosztóként van kötve négy potméter. Állásuk: min, max, max, min. Nem állítom át őket.
A mérés megtörténik, rendszeres időközönként (1mp) kiírom a nyers értékeket:
  1. ADC: 0=4095, 1=0, 2=1, 3=4094
  2. ADC: 0=4095, 1=0, 2=0, 3=4093
  3. ADC: 0=4095, 1=0, 2=0, 3=4095
  4. ADC: 0=4095, 1=0, 2=0, 3=4093
  5. ADC: 0=4095, 1=0, 2=0, 3=4095
  6. ADC: 0=4095, 1=0, 2=0, 3=4089
  7. ADC: 0=0, 1=4095, 2=4095, 3=0
  8. ADC: 0=0, 1=4095, 2=4095, 3=0
  9. ADC: 0=0, 1=4094, 2=4095, 3=1
  10. ADC: 0=0, 1=4095, 2=4095, 3=0
  11. ADC: 0=0, 1=4095, 2=4095, 3=0
  12. ADC: 0=0, 1=4095, 2=4095, 3=1
  13. ADC: 0=0, 1=4093, 2=4095, 3=0
  14. ADC: 0=0, 1=4093, 2=4095, 3=0
  15. ADC: 0=0, 1=4094, 2=4094, 3=0
  16. ADC: 0=0, 1=4095, 2=4095, 3=0
  17. ADC: 0=0, 1=4093, 2=4094, 3=0
  18. ADC: 0=0, 1=4095, 2=4095, 3=1
  19. ADC: 0=0, 1=4095, 2=4095, 3=0
  20. ADC: 0=0, 1=4095, 2=4094, 3=0
  21. ADC: 0=0, 1=4094, 2=4095, 3=0
  22. ADC: 0=0, 1=4095, 2=4095, 3=0
  23. ADC: 0=0, 1=4095, 2=4095, 3=0
  24. ADC: 0=4095, 1=4095, 2=0, 3=0
  25. ADC: 0=4095, 1=4095, 2=2, 3=0
  26. ADC: 0=0, 1=4095, 2=4095, 3=0
  27. ADC: 0=0, 1=4095, 2=4095, 3=0
  28. ADC: 0=0, 1=4095, 2=4095, 3=0
  29. ADC: 0=4095, 1=0, 2=1, 3=4095
  30. ADC: 0=0, 1=4095, 2=4094, 3=0
  31. ADC: 0=0, 1=4095, 2=4095, 3=0
  32. ADC: 0=0, 1=4095, 2=4095, 3=0
  33. ADC: 0=0, 1=4094, 2=4095, 3=0
  34. ADC: 0=0, 1=4093, 2=4095, 3=0
  35. ADC: 0=0, 1=4093, 2=4095, 3=0
  36. ADC: 0=0, 1=4095, 2=4095, 3=0
  37. ADC: 0=0, 1=4095, 2=4095, 3=0


Látszik, hogy időnként rossz memóriaterületre írja az adott csatornáról olvasott értéket.
Mit rontok el?

Köszönöm.
(#) csatti2 válasza vargham hozzászólására (») Nov 5, 2017 /
 
Én nem használok HAL-t, de alapvetően nem látok semmi problémát a kóddal.

Egy dolog viszont feltűnt és köze lehet a problémához. Minden egyes konverziócsoport végén újraindítod az ADC-t DMA-val a DMA konverzió végén. Ez teljesen felesleges. Konfiguráld a DMA-t körkörös puffer módra (circular buffer) és úgy használd. Innentől kezdve nem kell foglalkoznod az ADC-vel és a DMA-jával, a csoport konverziójának végén újra kezdi majd az elejétől.
Ha szűrni szeretnéd később az adatokat, akkor hozz létre egy nagyobb puffert (8-al osztható eleműt). Használd a DMA félpuffer kész és konverzió kész megszakításokat, hogy a puffer megfelelő felét szűrhesd.
(#) vargham válasza csatti2 hozzászólására (») Nov 6, 2017 /
 
Köszönöm. Úgy tűnik, hogy a circular buffer megoldotta.
(#) roleez hozzászólása Nov 13, 2017 /
 
Sziasztok!

Adott az STM32f103rbt mikrovezérlős board (pár $, ebay), amin soros kommunikációt szeretnék PC-vel. A kommunikáció megy is, ám amikor megkapja a 3 db byte-ból álló parancsot, válaszként
nem csak az "eredmény" jön, hanem a kérés 3 byte-ja is. Azaz pl. kérés (PC->board) #?v a válasz (board->PC) #?vABCD. A válaszban nem kellene szerepelnie a #?v szekvenciának.
Találkoztatok már ilyennel?
Köszönöm,
Roland

USART beállítása:
  1. void InitUSART()
  2. {
  3.  GPIO_InitTypeDef  GPIO_InitStructure;
  4.  USART_InitTypeDef USART_InitStructure;
  5.  NVIC_InitTypeDef NVIC_InitStructure;
  6.  
  7.  RCC_APB2PeriphClockCmd (RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
  8.  
  9.  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10;
  10.  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IN_FLOATING;
  11.  GPIO_Init(GPIOA, &GPIO_InitStructure);
  12.  
  13.  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_9;
  14.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  15.  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;
  16.  GPIO_Init(GPIOA, &GPIO_InitStructure);
  17.  
  18.  USART_InitStructure.USART_BaudRate            = 19200;
  19.  USART_InitStructure.USART_WordLength          = USART_WordLength_8b;
  20.  USART_InitStructure.USART_StopBits            = USART_StopBits_1;
  21.  USART_InitStructure.USART_Parity              = USART_Parity_No ;
  22.  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  23.  USART_InitStructure.USART_Mode                = USART_Mode_Rx | USART_Mode_Tx;
  24.  USART_Init(USART1, &USART_InitStructure);
  25.  
  26.  USART_ITConfig(USART3,USART_IT_TXE, DISABLE);
  27.   // Enable the USART RX Interrupt
  28.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
  29.  
  30.  USART_Cmd(USART1, ENABLE);
  31.  
  32.  
  33.  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  34.  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  35.  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  36.  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  37.  NVIC_Init(&NVIC_InitStructure);
  38. }
(#) aticska válasza roleez hozzászólására (») Nov 13, 2017 /
 
Szia!

Az Usart IrqHandlert is mutasd meg!
Idézet:
„"Amúgy van ARM-es topic "”
A hozzászólás módosítva: Nov 13, 2017
(#) roleez válasza aticska hozzászólására (») Nov 13, 2017 /
 
Köszönöm, bocsánat, hogy nem oda tettem..

  1. void USART1_IRQHandler(void)
  2. {
  3.       if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
  4.       {
  5.          rxchar = fogadUART[hol] = USART_ReceiveData(USART1);
  6.          if (hol < 100) hol++;
  7.          if (rxchar == 0x0A) {
  8.              readRX = 1;
  9.              hol = 0;
  10.          }
  11.          USART_ClearITPendingBit(USART1, USART_IT_RXNE);
  12.          USART_ClearFlag(USART1,USART_FLAG_TC);
  13.          USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
  14.       }
  15. }
(#) csatti2 válasza roleez hozzászólására (») Nov 13, 2017 /
 
Nem lehet, hogy a programban amivel küldöd/fogadod az adatokat be van kapcsolva a küldött adatok ismétlése?
(#) roleez válasza csatti2 hozzászólására (») Nov 13, 2017 /
 
És azt hol lehet ki/be kapcsolni?
(#) csatti2 válasza roleez hozzászólására (») Nov 13, 2017 /
 
Attól függ milyen programot használsz...
(#) roleez válasza csatti2 hozzászólására (») Nov 13, 2017 /
 
Coocox 1.7.6 - erre érted?
PC-n hercules a soros "figyelő"

A string végén lévő karakterek: "\n\r". És nem "\r\n".
Igyanez a PC program, ezzel a szekvenciával jól ment (igaz PIC18F vezérlőn)
(#) kapu48 válasza roleez hozzászólására (») Nov 13, 2017 /
 
Szerintem:
Jobb klikk: Hercules> Recevied/Sent dat
És pipa kivesz: Local Echo
(#) roleez válasza kapu48 hozzászólására (») Nov 13, 2017 /
 
természetesen nem is volt pipa.
Csak az STM32F103 board teszi ezt a jelenséget. A PIC nem. Mindkettő kommunikációs
felületét én írtam, ill. PC-s (qt creator) progit is. A hercules csak tesztnél kell.
Arra gondoltam, hogy az STM32 soros inicializálásában lehet vmi. Ma du. megpróbálom DMA-val is.
A hozzászólás módosítva: Nov 13, 2017
(#) csatti2 válasza roleez hozzászólására (») Nov 13, 2017 /
 
Nem tudok ilyen beállítási lehetőségről az STM-nél. Ha van logikai analizátorod, akkor szerintem nézd meg tényleg jönnek-e ezek az adatok a vezetéken.
(#) csabeszq válasza roleez hozzászólására (») Nov 13, 2017 /
 
Sosem tapasztaltam a problémát az STM32F103-on. A kód hiányos, ezért nem lehet róla mit mondani.
- egy biztos: a mikrovezérlő nem küldi ki a jelet UART-on, nem ismétel
- vagy a te programod küldi ki, mert összeakadnak a globális változóid
- vagy áthallás van a vezetéken, amikor küldesz, az RX pin lebeg és a TX megjelenik rajta

Én arra tippelek, hogy a küldő rutinod rossz, amit nem részleteztél és valahogy belepakolod az inputba az outputot is.

Az RX egyébként (adatfogadás) összezavarja a TX-et a kódodba, ami okozhat kellemetlen mellékhatásokat.
  1. // TXE -> Transmit Data Register empty interrupt
  2. USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
  3. // elég merész húzás ezt az RX interruptban állítani
A hozzászólás módosítva: Nov 13, 2017
Ezekre szükség lehet! - HESTORE.HU

PIC18F1320-I/P
STM32F103-MS
STM32F030C6T6
MJL21193G
NITI 0,34x8 TQ
Következő: »»   104 / 176
Bejelentkezés

Belépés
Hirdetés
Lapoda.hu     XDT.hu     HEStore.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem