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

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   852 / 853
(#) denon888 válasza Panhard hozzászólására (») Dec 2, 2024 /
 
Lehet. Ebben benne van a DS3231. Az előzőben is benne volt. A GitHubon találtam ezt, és ez tetszik neki. Lehet egy másik fordításnál meg erre fog hibát adni. Nemhiába, az elektronika bitek bájtok útjai kifürkészhetetlenek.

RTClib-maste...jpg		    
(#) metabo7000 hozzászólása Dec 3, 2024 /
 

arduino C++ to MicroPython konvertálás

Hello!
rp2040 MicroPythonra szeretnék egy kódrészletet átírni arduino c++ rol eben van meg a kész rész!
  1. #include <Arduino.h>
  2.  
  3. #define CLOCK_PIN 26
  4. #define DATA_PIN 25
  5.  
  6. #define BUFFER_SIZE 23
  7. #define DATA_PERIOD_MS 80
  8.  
  9. uint8_t buff[BUFFER_SIZE];
  10.  
  11. uint8_t bitPos;
  12. unsigned long lastPeriodMs;
  13.  
  14. void IRAM_ATTR _CLK_ISR() {
  15.   unsigned long ms = millis();
  16.  
  17.   if (ms < lastPeriodMs) lastPeriodMs = ms;
  18.   if (ms - lastPeriodMs < DATA_PERIOD_MS) return;
  19.  
  20.   if (bitPos == BUFFER_SIZE) bitPos = 0;
  21.  
  22.   if (bitPos < BUFFER_SIZE) {
  23.     buff[bitPos++] = (GPIO.in >> DATA_PIN) & 0x1;
  24.   }
  25.  
  26.   if (bitPos == BUFFER_SIZE) lastPeriodMs = ms;
  27. }
  28.  
  29. float getMeasurement() {
  30.   int8_t sign;
  31.   int16_t value;
  32.  
  33.   sign = buff[20] == 0x1 ? -1 : 1;
  34.  
  35.   for (uint8_t i; i < BUFFER_SIZE; i++) {
  36.     if (buff[i] == 0x1) {
  37.       value |= 1 << i;
  38.     }
  39.   }
  40.  
  41.   return (value * sign) / 100.00;
  42. }
  43.  
  44. bool isValueAvailable() {
  45.   return bitPos == BUFFER_SIZE;
  46. }
  47.  
  48. void setup() {
  49.   Serial.begin(115200);
  50.  
  51.   while (!Serial)
  52.     ;
  53.  
  54.   pinMode(CLOCK_PIN, INPUT);
  55.   pinMode(DATA_PIN, INPUT);
  56.  
  57.   attachInterrupt(digitalPinToInterrupt(CLOCK_PIN), _CLK_ISR, RISING);
  58. }
  59.  
  60. unsigned long lastMillis;
  61.  
  62. void loop() {
  63.   if (isValueAvailable() && (millis() - lastMillis) > 100) {
  64.     Serial.println(getMeasurement());
  65.     lastMillis = millis();
  66.   }
  67. }
(#) icserny válasza metabo7000 hozzászólására (») Dec 4, 2024 /
 
Az ilyen feladatokat az AI (magyarul MI) többnyire meg tudja oldani. Néha figyelmezetetni kell, ha kifelejt vagy rosszul tud valamit. Én nem használok MicroPythont, de remélem, kiindulásnak jó lesz:
  1. from machine import Pin, Timer
  2. import time
  3.  
  4. CLOCK_PIN = 26
  5. DATA_PIN = 25
  6.  
  7. BUFFER_SIZE = 23
  8. DATA_PERIOD_MS = 80
  9.  
  10. buff = [0] * BUFFER_SIZE
  11.  
  12. bitPos = 0
  13. lastPeriodMs = 0
  14.  
  15. def _CLK_ISR(pin):
  16.     global bitPos, lastPeriodMs
  17.     ms = time.ticks_ms()
  18.    
  19.     if ms < lastPeriodMs:
  20.         lastPeriodMs = ms
  21.     if ms - lastPeriodMs < DATA_PERIOD_MS:
  22.         return
  23.    
  24.     if bitPos == BUFFER_SIZE:
  25.         bitPos = 0
  26.    
  27.     if bitPos < BUFFER_SIZE:
  28.         buff[bitPos] = Pin(DATA_PIN, Pin.IN).value()
  29.         bitPos += 1
  30.    
  31.     if bitPos == BUFFER_SIZE:
  32.         lastPeriodMs = ms
  33.  
  34. def getMeasurement():
  35.     sign = -1 if buff[20] == 1 else 1
  36.     value = 0
  37.    
  38.     for i in range(BUFFER_SIZE):
  39.         if buff[i] == 1:
  40.             value |= 1 << i
  41.    
  42.     return (value * sign) / 100.0
  43.  
  44. def isValueAvailable():
  45.     return bitPos == BUFFER_SIZE
  46.  
  47. def main():
  48.     global lastMillis
  49.     lastMillis = 0
  50.    
  51.     clock_pin = Pin(CLOCK_PIN, Pin.IN)
  52.     clock_pin.irq(trigger=Pin.IRQ_RISING, handler=_CLK_ISR)
  53.    
  54.     while True:
  55.         if isValueAvailable() and (time.ticks_ms() - lastMillis) > 100:
  56.             print(getMeasurement())
  57.             lastMillis = time.ticks_ms()
  58.  
  59. if __name__ == "__main__":
  60.     main()
(#) metabo7000 válasza icserny hozzászólására (») Dec 5, 2024 /
 
jaj az AI ...

A teljes kod MicroPython van irva azt ujra kezdeni nagy feladat csak egy szenzort kell cserélnem benne!
Köszi hogy megnézted!
(#) icserny válasza metabo7000 hozzászólására (») Dec 5, 2024 /
 
Nem gondolom, hogy emiatt újra kellene írni a meglevő programodat, csak a lenti main() függvényt felejtsd el és a benne levő dolgokat dolgozd bele a programodba - ahol kell.
(#) Gabtronic hozzászólása Dec 9, 2024 /
 

Arduino

Sziasztok,
az alábbi óra kapcsán lenne az a kérdésem, hogy eredetileg 60 Hz-es órajelről működik. 50 Hz esetén mit kell változtatni a kódban? (255, 286 sor?)
Köszönöm az ötleteket.

Bővebben: Link

  1. /*
  2. 2  ONE-TUBE NIXIE CLOCK for Arduino UNO - - - - - - - - - - - - L. Thomas -- August 2023
  3. 3  - Displays the time by repeatedly sequencing the digits each 2.5 seconds.
  4. 4  - Uses interrupt (pin 2) to detect each cycle of 60Hz AC power.  This is used to
  5. 5    count seconds, and time the sequencing of each digit.
  6. 6  - Has leading zero blanking.
  7. 7  - Jumper (pin 6) can be cut to run the clock in 24-hour format.
  8. 8  - A short blink between digits separates them. This is needed for the eye to catch
  9. 9    double digits such as 11 or 22.
  10. 10  - Nixie digits 0-9 are displayed according to the hex value of pins 8-11.
  11. 11  - A hexadecimal value greater than 9 will cause none of the nixie digits to illuminate.
  12. 12  - Output pin 12 is used to turn the decimal point ON and OFF.
  13. 13  - The decimal point is turned on during display of hours digit(s).
  14. 14  - The clock is frozen at zero seconds when the RUN/SET switch is in SET position. This
  15. 15    allows the clock to start immediately at zero seconds when switched from SET to RUN.
  16. 16  - At start-up or reset, all ten digits are displayed & decimal point blinks as a test.
  17. 17  - At start-up or reset, the clock begins at 12:59 (requires setting to correct time).
  18. 18  
  19. 19*/
  20. 20int ACint = 2;     // pin 2 is the interrupt from the 60Hz AC line (INT0)
  21. 21int HRSBTN = 3;    // pin 3 senses press of the Hours button (adds 1)
  22. 22int MINBTN = 4;    // pin 4 senses press of the Minutes button (adds 1)
  23. 23int RUNSET = 5;    // pin 5 senses if in the Set mode (low)
  24. 24int JUMPER = 6;    // pin 6 senses if time should be displayed in 24-hour format (HIGH)
  25. 25int hexA = 8;      // pin 8 is the LSD - used to display one of the nixie digits
  26. 26int hexB = 9;      // pin 9 - used to display one of the nixie digits
  27. 27int hexC = 10;     // pin 10 - used to display one of the nixie digits
  28. 28int hexD = 11;     // pin 11 is the MSD - used to display one of the nixie digits
  29. 29int Dpoint = 12;   // pin 12 turns the nixie decimal point on and off
  30. 30int TestPt = 13;   // pin 13 has an on-board LED and is used as a visual test indicator
  31. 31//
  32. 32int timeH = 12;    // Stores the HOURS value
  33. 33int timeM = 59;    // Stores the MINUTES value
  34. 34int SUBsec = 0;    // Accumulates AC cycles for each second
  35. 35int Seconds = 0;   // Accumulate seconds up to 60
  36. 36int Dcounter = 0;  // Runs from 0 to 149 to organize nixie display sequence timing
  37. 37int Flag = 0;      // Set to 1 when interrupt occurs
  38. 38int Temp1 = 0;     // Temporary register 1
  39. 39int Temp2 = 0;     // Temporary register 2
  40. 40int INstatus = LOW;  // Used to capture status of a digital input - HIGH or LOW
  41. 41int LASTs3 = HIGH;   // Used to debounce Hours setting button
  42. 42int LASTs2 = HIGH;   // Used to debounce Minutes setting button
  43. 43int Dstatus = 5;     // Defines the current status (case number) for nixie display
  44. 44//
  45. 45// The setup routine runs once during start-up or when RESET is pressed.
  46. 46void setup()
  47. 47{ pinMode(HRSBTN, INPUT);  // 3
  48. 48  pinMode(MINBTN, INPUT);  // 4
  49. 49  pinMode(RUNSET, INPUT);  // 5
  50. 50  pinMode(JUMPER, INPUT);  // 6
  51. 51  pinMode(hexA, OUTPUT);   // 8
  52. 52  pinMode(hexB, OUTPUT);   // 9
  53. 53  pinMode(hexC, OUTPUT);   // 10
  54. 54  pinMode(hexD, OUTPUT);   // 11
  55. 55  pinMode(Dpoint, OUTPUT); // 12
  56. 56  pinMode(TestPt, OUTPUT); // 13 (LED)
  57. 57// **** Display all ten digits and flash the decimal point ****
  58. 58  digitalWrite(hexA, LOW);
  59. 59  digitalWrite(hexB, LOW);
  60. 60  digitalWrite(hexC, LOW);
  61. 61  digitalWrite(hexD, LOW);     // This will display "0"
  62. 62  digitalWrite(Dpoint, HIGH);  // Decimal point ON
  63. 63  delay(400);                  // Show each digit for 800ms
  64. 64  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  65. 65  delay(400);
  66. 66  digitalWrite(hexA, HIGH);    //Display "1"
  67. 67  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  68. 68  delay(400);
  69. 69  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  70. 70  delay(400);
  71. 71  digitalWrite(hexA, LOW);
  72. 72  digitalWrite(hexB, HIGH);    //Display "2"
  73. 73  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  74. 74  delay(400);
  75. 75  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  76. 76  delay(400);
  77. 77  digitalWrite(hexA, HIGH);
  78. 78  digitalWrite(hexB, HIGH);    //Display "3"
  79. 79  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  80. 80  delay(400);
  81. 81  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  82. 82  delay(400);
  83. 83  digitalWrite(hexA, LOW);
  84. 84  digitalWrite(hexB, LOW);
  85. 85  digitalWrite(hexC, HIGH);    //Display "4"
  86. 86  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  87. 87  delay(400);
  88. 88  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  89. 89  delay(400);
  90. 90  digitalWrite(hexA, HIGH);    //Display "5"
  91. 91  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  92. 92  delay(400);
  93. 93  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  94. 94  delay(400);
  95. 95  digitalWrite(hexA, LOW);
  96. 96  digitalWrite(hexB, HIGH);    //Display "6"
  97. 97  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  98. 98  delay(400);
  99. 99  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  100. 100  delay(400);
  101. 101  digitalWrite(hexA, HIGH);
  102. 102  digitalWrite(hexB, HIGH);    //Display "7"
  103. 103  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  104. 104  delay(400);
  105. 105  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  106. 106  delay(400);
  107. 107  digitalWrite(hexA, LOW);
  108. 108  digitalWrite(hexB, LOW);
  109. 109  digitalWrite(hexC, LOW);
  110. 110  digitalWrite(hexD, HIGH);    //Display "8"
  111. 111  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  112. 112  delay(400);
  113. 113  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  114. 114  delay(400);
  115. 115  digitalWrite(hexA, HIGH);    //Display "9"
  116. 116  digitalWrite(Dpoint, HIGH);  //Decimal point ON
  117. 117  delay(400);
  118. 118  digitalWrite(Dpoint, LOW);   //Decimal point OFF
  119. 119  delay(400);
  120. 120  digitalWrite(hexB, HIGH);    //All nixie digits now OFF
  121. 121  delay(800);
  122. 122  attachInterrupt(0, ClkUpdate, RISING); //Enable the interrupt.
  123. 123}
  124. 124//
  125. 125// **** MAIN LOOP ***************************************************************
  126. 126void loop ()
  127. 127{
  128. 128  INstatus = digitalRead(RUNSET);    //Is the clock being set?
  129. 129  if (Seconds >= 60 && Flag == 1 && INstatus == HIGH)
  130. 130//                                    Just update the display if not true.                                
  131. 131  {
  132. 132  Seconds = 0;                       //ELSE Seconds = 60 so adjust for a new minute
  133. 133  timeM = timeM + 1;                 //Add a minute to the time
  134. 134  if (timeM >= 60)                   //Do we also have a new hour?
  135. 135  {
  136. 136  timeM = 0;                         //Yes-Reset the minutes
  137. 137  timeH = timeH + 1;                 // and add an hour
  138. 138  INstatus = digitalRead(JUMPER);    //Read the jumper
  139. 139  if (INstatus == LOW && timeH > 12) //Back to 1:00 (if 12-hour format)
  140. 140  timeH = 1;                         //Yes-reset to 1:00
  141. 141  if (timeH > 23)                    //Reset to 0:00 (if 24-hour format)
  142. 142  timeH = 0;                         //Yes-reset to 0:00
  143. 143  }}
  144. 144// Now update the display according to Case 1 through Case 5 ********************
  145. 145  if (Flag == 1)                     //Recent interrupt?
  146. 146//                                    If not, nothing else, done with loop.
  147. 147  {
  148. 148  Flag = 0;                          //Yes-so reset Flag and update display
  149. 149  Dstatus = 5;                       //Start with nixie off
  150. 150  if (Dcounter < 96)                 //If true display Minutes-ones
  151. 151  Dstatus = 4;                       //Case 4
  152. 152  if (Dcounter < 77)                 //If true nixie off
  153. 153  Dstatus = 5;                       //Case 5
  154. 154  if (Dcounter < 74)                 //If true display Minutes-tens
  155. 155  Dstatus = 3;                       //Case 3
  156. 156  if (Dcounter < 55)                 //If true nixie off
  157. 157  Dstatus = 5;                       //Case 5
  158. 158  if (Dcounter < 41)                 //If true display Hours-ones + DP
  159. 159  Dstatus = 2;                       //Case 2
  160. 160  if (Dcounter < 22)                 //If true nixie off
  161. 161  Dstatus = 5;                       //Case 5
  162. 162  if (Dcounter < 19)                 //If true display Hours-tens + DP
  163. 163  Dstatus = 1;                       //Case 1
  164. 164//
  165. 165  switch (Dstatus)
  166. 166  {
  167. 167  case 1:                            //Displays Hours-tens digit
  168. 168  Temp1 = timeH % 10;                //Temp1 now has the remainder (0,1,or 2)
  169. 169  Temp2 = (timeH - Temp1)/10;        //Temp2 now has the Hours-tens value
  170. 170  if (Temp2 == 0)                    //Check for leading zero blanking
  171. 171  Temp2 = 10;                        //Yes-Set Temp2 to blank leading zero
  172. 172  break;
  173. 173  case 2:                            //Displays Hours-ones digit
  174. 174  Temp2 = timeH % 10;                //Temp2 now has the Hours-one value
  175. 175  break;
  176. 176  case 3:                            //Displays Minutes-tens digit
  177. 177  Temp1 = timeM % 10;                //Temp1 now has the remainder (0-9)
  178. 178  Temp2 = (timeM - Temp1)/10;        //Temp2 now has the Minutes-tens value
  179. 179  break;
  180. 180  case 4:                            //Displays Minutes-ones digit
  181. 181  Temp2 = timeM % 10;                //Temp2 now has the Minutes-one value
  182. 182  break;
  183. 183  case 5:                            //Turns the nixie off (including DP)
  184. 184  Temp2 = 10;
  185. 185  break;
  186. 186  }
  187. 187//
  188. 188  if (Dstatus == 1 || Dstatus == 2)  //Should the DP be turned on?
  189. 189  {
  190. 190  digitalWrite(Dpoint, HIGH);        //ON - Yes-Dstatus was a 1 or 2
  191. 191  }
  192. 192  else
  193. 193  {
  194. 194  digitalWrite(Dpoint, LOW);         //OFF - No-Dstatus was not a 1 or 2
  195. 195  }
  196. 196//
  197. 197// **** Set outputs 8,9,10,11 & 12 according to Temp2 ***************************
  198. 198//
  199. 199  if (Temp2 > 7 && Temp2 < 10)       //Is it 8 or 9?
  200. 200  {
  201. 201  digitalWrite(hexD, HIGH);          //Yes-Turn on the "8" bit
  202. 202  Temp2 = (Temp2 - 8);               //prepare for next test
  203. 203  }
  204. 204  else
  205. 205  {
  206. 206  digitalWrite(hexD, LOW);           //No -Turn off the "8" bit
  207. 207  }
  208. 208  if (Temp2 > 3 && Temp2 < 8)        //Is it 4,5,6, or 7?
  209. 209  {
  210. 210  digitalWrite(hexC, HIGH);          //Yes-Turn on the "4" bit
  211. 211  Temp2 = (Temp2 - 4);               //prepare for next test
  212. 212  }
  213. 213  else
  214. 214  {
  215. 215  digitalWrite(hexC, LOW);           //No -Turn off the "4" bit
  216. 216  }
  217. 217  if (Temp2 > 1 && Temp2 < 4)        //Is it 2 or 3?
  218. 218  {
  219. 219  digitalWrite(hexB, HIGH);          //Yes-Turn on the "2" bit
  220. 220  Temp2 = (Temp2 - 2);               //prepare for next test
  221. 221  }
  222. 222  else
  223. 223  {
  224. 224  digitalWrite(hexB, LOW);           //No -Turn off the "2" bit
  225. 225  }
  226. 226  if (Temp2 == 1)                    //Is it now 1?
  227. 227  {
  228. 228  digitalWrite(hexA, HIGH);          //Yes-Turn on the "1" bit
  229. 229  }
  230. 230  else
  231. 231  {
  232. 232  digitalWrite(hexA, LOW);           //No -Turn off the "1" bit
  233. 233  }
  234. 234  if (Temp2 == 10)                   //Turn the nixie off and DP off
  235. 235  {
  236. 236  digitalWrite(hexA, LOW);           //The nixie will be off if output value
  237. 237  digitalWrite(hexB, HIGH);          // is 10 or greater
  238. 238  digitalWrite(hexC, LOW);
  239. 239  digitalWrite(hexD, HIGH);          //Output value is now 10 (decimal)
  240. 240  digitalWrite(Dpoint, LOW);         //The decimal point is now off
  241. 241  //   De-bounce the Minutes and Hours setting buttons
  242. 242  INstatus = digitalRead(MINBTN);    //Read the Minutes button status
  243. 243  if (INstatus != LASTs2)            //Determine if status has changed
  244. 244  LASTs2 = HIGH;                     //NOT equal- it did change
  245. 245  INstatus = digitalRead(HRSBTN);    //Now read the Hours button status
  246. 246  if (INstatus != LASTs3)            //Determine if status has changed
  247. 247  LASTs3 = HIGH;                     //NOT equal- it did change
  248. 248  }}}                                //End of Loop here *************************
  249. 249//
  250. 250//
  251. 251//
  252. 252// Interrupt Service - Accumulates Seconds and Detects Clock Setting ************
  253. 253  void ClkUpdate (void)
  254. 254  {
  255. 255  SUBsec = SUBsec + 1;               //Add 1 towards accumulating 1 second
  256. 256  INstatus = digitalRead(RUNSET);    //Read the RUN/SET switch status
  257. 257  if (INstatus == LOW)               //LOW if switch is in SET positon
  258. 258  {
  259. 259  SUBsec = 0;                        //RUN/SET switch is in the SET position
  260. 260  Seconds = 0;                       //This freezes the clock at zero seconds
  261. 261  //         Now check the clock setting buttons:
  262. 262  INstatus = digitalRead(MINBTN);    //Read the MINUTES button status
  263. 263  if (INstatus == LOW && INstatus != LASTs2)  //Must be a NEW low status
  264. 264  {
  265. 265  timeM = timeM + 1;                 // Button was pressed - add a minute
  266. 266  LASTs2 = INstatus;                 // Save the button status to LASTs2
  267. 267  if (timeM > 59)                    // Roll over back to zero?
  268. 268  timeM = 0;                         // Yes
  269. 269  }
  270. 270  INstatus = digitalRead(HRSBTN);    //Read the HOURS button status
  271. 271  if (INstatus == LOW && INstatus != LASTs3)  //Must be a NEW low status
  272. 272  {
  273. 273  timeH = timeH + 1;                 // Button was pressed - add an hour
  274. 274  LASTs3 = INstatus;                 // Save the button status to LASTs3
  275. 275  INstatus = digitalRead(JUMPER);    //Read the jumper
  276. 276  if (INstatus == LOW && timeH > 12) //Back to 1:00 (if 12-hour format)
  277. 277  timeH = 1;                         //Yes-reset to 1:00
  278. 278  if (timeH > 23)                    //Reset to 0:00 (if 24-hour format)
  279. 279  timeH = 0;                         //Yes-reset to 0:00
  280. 280  }}
  281. 281  if (SUBsec == 5)                   //Skips to here if not setting the clock
  282. 282  digitalWrite(TestPt, LOW);         //Turn off the test LED (short blink)
  283. 283  if (SUBsec > 59)                   //Have we accumulated 1 second yet?
  284. 284  {
  285. 285  SUBsec = 0;                        //Yes-so reset for the next one
  286. 286  Seconds = Seconds + 1;             // and increment the seconds
  287. 287  digitalWrite(TestPt, HIGH);        // and turn on the test point & LED
  288. 288  }
  289. 289  Dcounter = Dcounter + 1;           //Also increment the display counter
  290. 290  if (Dcounter > 149)                //At the end of the display cycle?
  291. 291  Dcounter = 0;                      //Yes- so reset for next cycle        
  292. 292  Flag = 1;                          //Now show that we have been here
  293. 293  }
  294. 294// End of Interrupt Service: ****************************************************

5b4ba882-409...jpg		    
(#) benjami válasza Gabtronic hozzászólására (») Dec 9, 2024 / 1
 
Első ránézésre nekem úgy tűnik a 283. sornál kell az 59-et 49-re cserélni.
(#) elactrofan hozzászólása Dec 18, 2024 /
 

arduino alapok

Üdv!
Arduino ide milyen program nyelvet használ?
(#) Panhard válasza elactrofan hozzászólására (») Dec 18, 2024 /
 
Bővebben: Link
(#) elactrofan válasza Panhard hozzászólására (») Dec 18, 2024 /
 
köszönöm
(#) apeape hozzászólása Jan 12, 2025 /
 

rádios kapcsolat kettő UNO között ,programhiba

Ez most egy felhívás a " NAP HŐSE " címére !
Régen sikerült nRF24 rádión 2 integer változót küldeni, csak már elfelejtettem programját.
A rádió beállítása biztosan rendben , mert a " Hello Világ " text üzenet megy .
  1. ***********************************************************************************
  2.                                                       ADÓ
  3.                                    
  4. #include <SPI.h>
  5. #include <nRF24L01.h>
  6. #include <RF24.h>
  7.  
  8. RF24 radio(3, 4); // CE, CSN
  9. const byte address[6] = "00001";
  10.  
  11. int Array [1];    // két elemű tömb
  12. int ciklus ;      // növekvő egész számhoz
  13.  
  14. void setup() {
  15.   Serial.begin(9600);
  16.   int ciklus = 0 ;       // hogy lássak valamit
  17.   radio.begin();
  18.   radio.openWritingPipe(address);
  19.   radio.setPALevel(RF24_PA_MIN);
  20.   radio.stopListening();
  21. }
  22.                  
  23. void loop() {
  24.   ciklus = ciklus + 1 ;     // növekvő szám , hogy lássak valamit
  25.  
  26.    if ( ciklus >= 1000 ) {
  27.     ciklus = 0 ;
  28.    }
  29.   Array [0] = ciklus      ;                 // első adat
  30.   Array [1] = ciklus + 50 ;                 // második adat
  31.   radio.write(&Array[1], sizeof(Array[1]));
  32.   Serial.print( Array [0] ) ;               // az adót ellenőrzöm
  33.   Serial.print( "   " ) ;  
  34.   delay(800);
  35. }  
  36.  
  37.  
  38.                           EZEKET AZ ADATOKAT KELLETT VOLNA KÜLDENIE
  39. 0  1   52   103   154   205   256   307   358   409   460   511   562   613   664   715   766   817   868   919   970   0   51   102   153   204   255   306   357   408   459   510   561   612   663   714   765   816   867   918   969   0   51   102   153   204   255   306   357   408   459   510   561   612   663   714   765   816   867   918   969   0   51   102   153   204   255   306   357   408   459   510   561  
  40.  
  41.  
  42. ***********************************************************************************
  43.                                                                 VEVŐ
  44.  
  45. #include <SPI.h>
  46. #include <nRF24L01.h>
  47. #include <RF24.h>
  48.  
  49. RF24 radio(3, 4); // CE, CSN
  50. const byte address[6] = "00001";
  51. int Array [1];                              //  a vevőt 2 db integer változóra készítem fel
  52.  
  53. void setup() {
  54.   Serial.begin(9600);
  55.   radio.begin();
  56.   radio.openReadingPipe(0, address);
  57.   radio.setPALevel(RF24_PA_MIN);
  58.   radio.startListening();
  59. }
  60.  
  61. void loop() {
  62.   if (radio.available()) {
  63.     radio.read(&Array  , sizeof(Array ));     // itt szabotálja el a tömb vételét
  64.     Serial.print   ( Array[0])             ;        // tömb első tagja
  65.     Serial.print   ( "      = =        ")  ;
  66.     Serial.println ( Array[1])             ;        // tömb második tagja
  67.    
  68.      }
  69.   else {
  70.     Serial.println ( " Nem vette az adást ")  ;
  71.   }
  72. }
  73. ITT AZ EREDMÉNY
  74. Nem vette az adást = =  Nem vette az adást = =  Nem vette az adást = =  Nem vette az adást = =  
  75. Nem vette az adást = =  Nem vette az adást = =  Nem vette az adást = =  Nem vette az adást = =  
  76. ********************

Azt megköszönöm , ha a hibás sorokat kijavítjátok . Nem kell az egész programot leírni.
Lehet , hogy - string-é kell alakítanom ?
Úgy magyarázzátok , hogy a nagymamátok is értse.
A hozzászólás módosítva: Jan 13, 2025
Moderátor által szerkesztve
(#) majkimester válasza apeape hozzászólására (») Jan 12, 2025 /
 
Az első hiba mindketőben, hogy ez 1 elemű tömb, a második elem írásakor felülírod az utána következő változót:

  1. int Array [1]; // két elemű tömb


legyen inkább:


  1. int Array [2]; // két elemű tömb
(#) apeape válasza majkimester hozzászólására (») Jan 13, 2025 /
 
Moderátornak köszönöm , hogy áttekinthetővé tette a program részeket.
Igazad van, a deklarációt valóban elfuseráltam.
Amatőr vagyok , de ezt még nekem is tudnom kellett volna
Ezeken a pontokon nyúltam bele:

  1. ADÓ
  2.    9. sor javítása
  3.  /* int Array [1];    // két elemű tömb      */
  4.  int adatok [] = {0 , 1 } ;    // két elemű tömb
  5.  
  6.    29, 30 , 31 , 32. sor javítása
  7.  /*  Array [0] = ciklus      ;                 // első adat
  8.      Array [1] = ciklus + 50 ;                 // második adat
  9.      radio.write(&Array[1], sizeof(Array[1]));
  10.      Serial.print( Array [0] ) ;               // az adót ellenőrzöm   */
  11.  
  12.   adatok [0] = ciklus      ; // első adat
  13.   adatok [1] = ciklus + 50 ; // második adat
  14.   radio.write(&adatok, sizeof(adatok));
  15.   Serial.println( adatok [0] ) ;
  16.   Serial.println( adatok [1] ) ;
  17.  
  18.  
  19.  
  20.                                                                         VEVŐ
  21.   51. sor javítása
  22.   /* int Array [1];   //  a vevőt 2 db integer változóra készítem fel */
  23.   int adatok [] = {0 , 1 } ;    // két elemű tömb
  24.  
  25.    63, 64  , 66. sor javítása
  26.  
  27.    /* radio.read(&Array  , sizeof(Array ));     // itt szabotálja el a tömb vételét
  28.     Serial.print   ( Array[0])             ;        // tömb első tagja
  29.     Serial.print   ( "      = =        ")  ;
  30.     Serial.println ( Array[1])             ;        // tömb második tagja    */
  31.  
  32.     radio.read(&adatok  , sizeof(adatok ));     // itt szabotálja el a tömb vételét
  33.     Serial.print   ( adatok[0])             ;        // tömb első tagja
  34.     Serial.print   ( "      = =        ")  ;
  35.     Serial.println ( adatok[ 1])             ;        // tömb második tagja


A hibás sorokat átírtam de nem javult a helyzet .
Ha az adón megnyomom a resetgombot , akkor hébe-hóba 5/1 arányban veszi a vevő és jó értékkel.
Régebben egy vízmelegítő tartályban mértem a nyomást és töltöttséget és működött .
A hozzászólás módosítva: Jan 13, 2025
Moderátor által szerkesztve
(#) Moderátor hozzászólása apeape hozzászólására (») Jan 13, 2025
 
Szívesen. Nem nagy kunszt, a "Kód" gomb megnyomásával a szükséges "tag"-ek beszúrhatóak. (Szögletes zárójelek között a "code" és "/code" tag-ek.)
(#) szeg76 válasza apeape hozzászólására (») Jan 18, 2025 /
 
Nekem az &adatok gyanúsnak tűnik. A write és read első paraméternek egy memótiacímet vár el, az adatok már önmagában egy cím, az &adatok a cím címét jelenti.
(#) apeape válasza szeg76 hozzászólására (») Jan 19, 2025 /
 
Én ezt programot innen koppintottam , van benne magyarázat is.

https://howtomechatronics.com/tutorials/arduino/arduino-wireless-co...orial/

Három program van benne
- Hello Világ
- potis ledes
- rekord.-os
Az első kettő ment gond nélkül ez a rekor.-os csak minden 5. - 6. reset gomb nyomásra , ha resetelem az adót akkor jól átviszi az adatokat.
Ezt a rekordos programot ahogy kimásoltam , lefordította a fordító , de jól nem ment soha.
Az adatok helyén egy rekordnak kell lenni - ahogy én gondolom és nem memóriának. // Amatőr vagyok .

Ez a példaprogram deklarációja:

  1. // Max size of this struct is 32 bytes - NRF24L01 buffer limit
  2. struct Data_Package {
  3.   byte a = 0;
  4.   byte b = 125;
  5.   byte c = 255;
  6.   int d = 1024;
  7.   float e = 3.141592;
  8.   String f = "Test";
  9. };
  10.  
  11. Data_Package data; // Create a variable with the above structure


Én ezt akartam 2db integer változóra alakítani, mégpedig így .
  1. /* int Array [2];    // két elemű tömb      */
  2.  int adatok [] = {0 , 1 } ;    // két elemű tömb


Vagy itt hibás a deklaráció , vagy a következő sor az adás.
radio.write(&adatok, sizeof(adatok));
Én szerintem az adatok az változó, amit én integernek határoztam meg az elején.
Ha ezt a két sort ki tudnád gyomlálni annak örülnék.
A hozzászólás módosítva: Jan 20, 2025
Moderátor által szerkesztve
(#) Kera_Will válasza apeape hozzászólására (») Jan 19, 2025 /
 
Flote e valtozot kivetted ?
Akkor mar nem lesz sehol se egesz valtozo eredmeny benne ha hadznalod ... avagy tizedesek elvesznek az eredmenybol.
De ugy remlik a arduino ide fordito mar forditaskor valtozo tipus hibaval megallna.
(#) apeape válasza Kera_Will hozzászólására (») Jan 19, 2025 /
 
Valóban kivettem a rekordból pár sort, de a fordító ennek ellenére lefordítja.
Az eredeti / rekord / típusú volt. Nekem még nem volt dolgom " rekord "típussal .
Nekem bőven elég ha 2 integer típust átküldök.
Ha valaki ezt a pár sort helyesen leírja :

  1. int a ;                    // deklaráció . Ezt elemezzétek ki
  2. int b ;
  3. adatok [ ] = { a , b }
  4.  
  5.    a = a + 1 ;        // ez működik , hogy lássam van e változás. Ez tuti jó
  6.  if ( a >= 10 ) {
  7.     a = 0   ;
  8. }
  9.    b = a *2   ;
  10.  
  11.         radio.write(&adatok, sizeof(adatok));    // adatok küldése . Szintén izgalmas sor
  12.                                                                  // mi az" &"szerepe ?

Ami biztosan jó :
- rádió kapcsolat // ha az adó oldalon nyomkodom a reset gombot , akkor helyes számokat olvasok le a vevő oldalon de csak minden 5. 6. nyomásra megy át adat.
Valamint a " Hello Világ" szintén átmegy természetesen , ha text .-re van deklarálva.
- van egy potenciométeres program is , vevő oldalon pedig egy led ez is működik.
Tehát a rádió hibát én kizárnám.
Továbbá van 4 db arduino UNO.-m 4db nRF24 rádióm , mindent lepróbáltam.
- a tömb típust a TurboPascal .-ból ismerem és a változó típusokat is.
- rekordról is olvastam , de még nem használtam.
Ami nagyon zavaros :
- rádió adás sora.
Régen már csináltam ilyent :
- töltöttem az autó akkumulátorát és a szobában leolvastam a feszültségét
- vagy néztem egy fotoellenállással a napsütést és mértem a víz hőmérsékletét . Pluszban még SD kártyára vettem az adatait amit exel táblán grafikonra alakítottam.
Tökéletesen működött .
Valójában csak hobbiból csinálom, csak régen jobban mentek ezek a dolgok.
A hozzászólás módosítva: Jan 20, 2025
Moderátor által szerkesztve
(#) sector99 hozzászólása Jan 21, 2025 /
 

0,96 OLED I2C to 0,96 OLED SPI

Sziasztok !
0,96 I2C kijelzőre írt programot át lehet-e írni SPI kommunikációs változatú kijelzőre ? (vagy vegyek egy I2C-s változatot) Konkrétan ERRŐL lenne szó.
(#) Régi motoros válasza sector99 hozzászólására (») Jan 21, 2025 /
 
Meg van rá az esély. De ezt most nem én fogom megoldani neked, csak várd meg amíg valaki megnézi a forrást is. A lényeg, hogy a kijelződhöz kell igazítani a programot, és min általában ezer meg egy féle kijelző közül lehet választani. Bár, hogy valaki meg csinálja e neked, arra nem esküszöm, mert ahogy elnéztem, több képernyő felület van, szóval nem csak 1-2 órás feladat lenne.
Arról nem is beszélve, hogy az új képernyőn tesztelni is kellene mi hogyan jelenik meg.
Mindenesetre kemény dió lesz...
(#) benjami válasza sector99 hozzászólására (») Jan 22, 2025 /
 
A programban használt U8glib képes szoftverSPI, hardverSPI és I2C periférián is kommunikálni a kijelzővel, csak annyit kell módosítani, hogy más paraméterezésű konstruktort kell használni.
  1. class U8GLIB_SSD1306_128X64 : public U8GLIB
  2. {
  3.   public:
  4.     U8GLIB_SSD1306_128X64(uint8_t sck, uint8_t mosi, uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE)
  5.       : U8GLIB(&u8g_dev_ssd1306_128x64_sw_spi, sck, mosi, cs, a0, reset)
  6.       { }
  7.     U8GLIB_SSD1306_128X64(uint8_t cs, uint8_t a0, uint8_t reset = U8G_PIN_NONE)
  8.       : U8GLIB(&u8g_dev_ssd1306_128x64_hw_spi, cs, a0, reset)
  9.       { }
  10.     U8GLIB_SSD1306_128X64(uint8_t options = U8G_I2C_OPT_NONE)
  11.       : U8GLIB(&u8g_dev_ssd1306_128x64_i2c, options)
  12.       { }
  13. };

Jelenleg a harmadik szerint van paraméterezve, ha szabadok az SPI lábak a másodikat (hardver SPI) célszerű választani.
(#) sector99 válasza Régi motoros hozzászólására (») Jan 22, 2025 /
 
Köszi ! Én nem tudok programozni. Mivel nem csak pár sor átírásáról van szó, inkáb veszek egy I2C felületű OLED-et.
(#) sector99 válasza benjami hozzászólására (») Jan 22, 2025 /
 
No épp most válaszoltam Régi motorosnak..
A Te javaslatod nem tűnik olyan nagyon időigényesnek.
Visszatérünk rá rövidesen. Köszi !
(#) kobold válasza apeape hozzászólására (») Jan 22, 2025 /
 
  1. adatok [ ] = { a , b }

Erről nekem az jut csak eszembe, hogy típus nélküli tömbdeklarációt látok, meg egy hiányzó pontosvesszőt. Én így írnám:
  1. int adatok[] = {a, b};


  1. radio.write(&adatok, sizeof(adatok));

A & (addressof operator) használata normális a C alapú nyelvekben, mert ezzel egy címet adunk át (a tömb kezdőcímét), illetve a címtől kezdődő memóriarész (azaz a teljes tömb) hosszát. A Visual Basic volt olyan, hogy alapból mindent értékkel adott át egy hívásnál, vagyis pakolgatta a stack-be a paramétereket, ha nem használtuk a ByRef előtagot; a C nyelv alapból nem pazarol stack-et ilyesmire, hanem átad egy pointert, a hosszt, és a tömb típusa alapján a fordító már tudni fogja, hogy mennyi byte-ot hogyan olvasva hogyan értelmezzen, illetve mindezt hol találja meg.
Pl. ha karakterlánc volna a paraméter, akkor nagyon látványos, hogy nem egy éppen ezerhatszáznégy karakteres kisverset másolunk át egy hívott függvényhez karakterről karakterre zabálva a stack-et, hanem csak odaadjuk, hogy itt kezdődik, meg ezerhatszáznégy karakter hosszú, aztán a függvény már azt kezd vele, amit akar.
(#) apeape válasza kobold hozzászólására (») Jan 22, 2025 /
 
Igazad van. Ide a fórumba rosszul másoltam , de a programban jól.
Máskülönben, nem is fordítaná le programot.
Most kicsit elbizonytalanodtam , mert a Hello Vilag sem akar lefutni.
Adj 2-3 napot , hogy összeszedjem magam és precízen tudjak kérdezni .
Légy szíves 2 naponta nézz rá , és én jelentkezni fogok.
Megpróbálok képet is feltenni.
A hozzászólás módosítva: Jan 22, 2025
(#) kissi válasza apeape hozzászólására (») Csü, 1:22 /
 
Szia!

Nem vagyok benne az Arduino programozásában és a radio.write fv-t nem néztem meg, de az jutott eszembe, hogy az eredeti struktúrában az utolsó helyen string volt, amit tárolásnál '0'-val zárnak le...Ha a radio.write függvény eetleg ezt a nullát figyeli, akkor a te tömbödnél ez gondot okozhat...Próbáld már ki 3 eleműnek deklarálni a tömböt, utolsó helyen 0-val!

Elnézést kérek, ha nem jön be!

  1. int adatok[] = {a, b,0};
A hozzászólás módosítva: Csü, 1:23
(#) apeape válasza kissi hozzászólására (») Csü, 20:14 /
 
Én nagyon amatőr vagyok.

https://howtomechatronics.com/tutorials/arduino/arduino-wireless-co...gnette

Innen kezdtem lekoppintani ,ahol 3 példaprogram van.
- első a Hello Világ.-os // először ment , most nem megy
- poti adó , led vevő // ez megy
- strukturált , ez nagyon átvágott

struct Data_Package {
byte a = 0;
byte b = 125;
byte c = 255;
int d = 1024;
float e = 3.141592;
String f = "Test";
};

Ezt akartam szétszálazni .
Nekem csak 2 integer.-re van szükségem, esetleg float.
A vevő a " loop " -ban ezeket szépen kiírta a soros monitorra , de az volt az átverés , hogy nem a rádión vette az adatokat hanem úgy írták meg a programot , hogy a deklarációt másolgatta.
Most kicsit rátanulok és utána azt szeretném ha a meghatározó sorokat leellenőriznétek.
2-3 nap és jelentkezem.
A képen van a tananyag , csak na tömbben segít , de rNF24-ről nincs benne semmi.
A hozzászólás módosítva: Csü, 20:17

1000002471.jpg		    
(#) mateatek hozzászólása Szo, 17:44 /
 

LGT8F328P programozása Ardino-val

Üdvözlet!

LGT8F328P mikrokontrollert szeretnék programozni Arduino panellel, ami ATmega mikrokontrollert tartalmaz. Tehát, rá szeretném tölteni a "LarduinoISP" programot. Ha olyan alaplapot választok ki, amin LGT8F328P van, akkor egy menüpontban be tudom állítani a "[To burn an ISP] SERIAL_RX_BUFFER_SIZE to 250" opciót és arra gond nélkül föltöltöm a programot és ezúttal az programozóvá alakul.
Ezt a programot miként lehetne föltölteni egy ATmega mikrokontrolleres alaplapra? Mert ha erre szeretném föltölteni, akkor a következő hibaüzenetet kapom:
#error : Please change the macro SERIAL_RX_BUFFER_SIZE to 250 (In the menu: Tools/Arduino as ISP/SERIAL_RX_BUFFER_SIZE)
A hozzászólás módosítva: Szo, 17:44

larduino_ISP.png		    
(#) kisninja hozzászólása Vas, 21:42 /
 

Vezérlés

Sziasztok

Gondolkodtam hogyan oldjam meg egy egyfázisú töltő megtáplálását az éppen rendelkezésre álló három fázis valamelyikéről. Amit szeretnék priorizálnék illetve időben is vezérelni.
Van egy fázis ami naponta csak kb 7 órát van 1 van egy fázis ami csak télen kedvezményes 2 (H) és van egy fázis ami alapesetben mindig van 3. A célom az lenne, hogy ha megvan mindhárom fázis akkor az általam kiválasztottat kapcsolná a töltőre, ha az nincs akkor kapcsolná a következőt ha az sincs akkor az utolsót. Ha belejönnék vagy megérteném a programozását akkor időzíteném illetve fogyasztás alapján változna a prioritás is. Fázis figyelésre sima reléket gondoltam ami vagy 0 vagy 1.
Jól gondolom, hogy egy r3 uno és egy 4 es 12v relémodul kezdésnek elegendő ?
Valaki tudna linkelni egy kis olvasni valót merre induljak el.
Köszönöm előre is a válaszokat.
(#) vargham válasza kisninja hozzászólására (») Hé, 7:29 / 2
 
Amit tervezel, az szerződésszegés. Ha rájön a szolgáltató, akkor elég magas díjat fogsz fizetni. Igen, jogos, mert aláírtad a szerződésben. H tarifáról csak hőszivattyú mehet, vezéreltről pedig csak fixen bekötött hőtermelő készülékek, mint bojler meg hőtárolós kályha.
Ezekre szükség lehet! - HESTORE.HU

RF24-RGB
DS3231-MINI-RTCM
NRF24L01-AM-MINI
RP2040-ZERO-PICO
M 6 X 25 DBKNY
Következő: »»   852 / 853
Bejelentkezés

Belépés
Hirdetés
XDT.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