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   370 / 845
(#) kapu48 válasza atus1981 hozzászólására (») Aug 2, 2017 /
 
Ha már ennyit dolgoztam az érdekedben!
Jó lenne, ha kipróbálnád, és vissza jeleznél! Hogy működik a project?

Egy könyvtárba mindent:
I2C_EEPROMtest
  1. /*    I2C_EEPROMtest.ino
  2.   *  Use the I2C bus with EEPROM 24LC64
  3.   *  Sketch:    eeprom.ino
  4.   *
  5.   *  Author: hkhijhe
  6.   *  Date: 01/10/2010
  7.   *
  8.   *
  9.   */
  10.  
  11. /////////////////////////////////////////////////////////////////////////////////////////
  12. // General include
  13. #include "Wire.h"
  14.  
  15.  
  16.  
  17. void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
  18.     int rdata = data;
  19.     Wire.beginTransmission(deviceaddress);
  20.     Wire.write((int)(eeaddress >> 8)); // MSB
  21.     Wire.write((int)(eeaddress & 0xFF)); // LSB
  22.     Wire.write(rdata);
  23.     Wire.endTransmission();
  24. }
  25.  
  26. // WARNING: address is a page address, 6-bit end will wrap around
  27. // also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
  28. void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
  29.     Wire.beginTransmission(deviceaddress);
  30.     Wire.write((int)(eeaddresspage >> 8)); // MSB
  31.     Wire.write((int)(eeaddresspage & 0xFF)); // LSB
  32.     byte c;
  33.     for ( c = 0; c < length; c++)
  34.         Wire.write(data[c]);
  35.     Wire.endTransmission();
  36. }
  37.  
  38. byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
  39.     byte rdata = 0xFF;
  40.     Wire.beginTransmission(deviceaddress);
  41.     Wire.write((int)(eeaddress >> 8)); // MSB
  42.     Wire.write((int)(eeaddress & 0xFF)); // LSB
  43.     Wire.endTransmission();
  44.     Wire.requestFrom(deviceaddress,1);
  45.     if (Wire.available()) rdata = Wire.read();
  46.     return rdata;
  47. }
  48.  
  49. // maybe let's not read more than 30 or 32 bytes at a time!
  50. void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
  51.     Wire.beginTransmission(deviceaddress);
  52.     Wire.write((int)(eeaddress >> 8)); // MSB
  53.     Wire.write((int)(eeaddress & 0xFF)); // LSB
  54.     Wire.endTransmission();
  55.     Wire.requestFrom(deviceaddress,length);
  56.     int c = 0;
  57.     for ( c = 0; c < length; c++ )
  58.         if (Wire.available()) buffer[c] = Wire.read();
  59. }
  60.  
  61.  
  62.  
  63.  
  64. void setup()
  65. {
  66.     char somedata[] = "this is data from the eeprom"; // data to write
  67.     Wire.begin(); // initialise the connection
  68.     Serial.begin(9600);
  69.     i2c_eeprom_write_page(0x50, 0, (byte *)somedata, sizeof(somedata)); // write to EEPROM
  70.  
  71.     delay(100); //add a small delay
  72.  
  73.     Serial.println("Memory written");
  74. }
  75.  
  76. void loop()
  77. {
  78.     int addr=0; //first address
  79.     byte b = i2c_eeprom_read_byte(0x50, 0); // access the first address from the memory
  80.  
  81.     while (b!=0)
  82.     {
  83.         Serial.print((char)b); //print content to serial port
  84.         addr++; //increase address
  85.         b = i2c_eeprom_read_byte(0x50, addr); //access an address from the memory
  86.     }
  87.     Serial.println(" ");
  88.     delay(2000);
  89. }


  1. /*  Wire.h
  2.   TwoWire.h - TWI/I2C library for Arduino & Wiring
  3.   Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
  4.  
  5.   This library is free software; you can redistribute it and/or
  6.   modify it under the terms of the GNU Lesser General Public
  7.   License as published by the Free Software Foundation; either
  8.   version 2.1 of the License, or (at your option) any later version.
  9.  
  10.   This library is distributed in the hope that it will be useful,
  11.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.   Lesser General Public License for more details.
  14.  
  15.   You should have received a copy of the GNU Lesser General Public
  16.   License along with this library; if not, write to the Free Software
  17.   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18.  
  19.   Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
  20.   Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
  21.   Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
  22. */
  23.  
  24. #ifndef TwoWire_h
  25. #define TwoWire_h
  26.  
  27. #include <inttypes.h>
  28. #include "Stream.h"
  29.  
  30.  
  31.  
  32. #define BUFFER_LENGTH 32
  33. // ESP-12
  34. //#define SDA 4
  35. //#define SCL 5
  36.  
  37. // ESP-01
  38. #define SDA 0
  39. #define SCL 2
  40.  
  41. class TwoWire : public Stream
  42. {
  43.   private:
  44.     static uint8_t rxBuffer[];
  45.     static uint8_t rxBufferIndex;
  46.     static uint8_t rxBufferLength;
  47.  
  48.     static uint8_t txAddress;
  49.     static uint8_t txBuffer[];
  50.     static uint8_t txBufferIndex;
  51.     static uint8_t txBufferLength;
  52.  
  53.     static uint8_t transmitting;
  54.     static void (*user_onRequest)(void);
  55.     static void (*user_onReceive)(int);
  56.     static void onRequestService(void);
  57.     static void onReceiveService(uint8_t*, int);
  58.   public:
  59.     TwoWire();
  60.     void begin(int sda, int scl);
  61.     void pins(int sda, int scl) __attribute__((deprecated)); // use begin(sda, scl) in new code
  62.     void begin();
  63.     void begin(uint8_t);
  64.     void begin(int);
  65.     void setClock(uint32_t);
  66.     void beginTransmission(uint8_t);
  67.     void beginTransmission(int);
  68.     uint8_t endTransmission(void);
  69.     uint8_t endTransmission(uint8_t);
  70.     size_t requestFrom(uint8_t address, size_t size, bool sendStop);
  71.  
  72.     uint8_t requestFrom(uint8_t, uint8_t);
  73.     uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
  74.     uint8_t requestFrom(int, int);
  75.     uint8_t requestFrom(int, int, int);
  76.    
  77.     virtual size_t write(uint8_t);
  78.     virtual size_t write(const uint8_t *, size_t);
  79.     virtual int available(void);
  80.     virtual int read(void);
  81.     virtual int peek(void);
  82.     virtual void flush(void);
  83.     void onReceive( void (*)(int) );
  84.     void onRequest( void (*)(void) );
  85.  
  86.     inline size_t write(unsigned long n) { return write((uint8_t)n); }
  87.     inline size_t write(long n) { return write((uint8_t)n); }
  88.     inline size_t write(unsigned int n) { return write((uint8_t)n); }
  89.     inline size_t write(int n) { return write((uint8_t)n); }
  90.     using Print::write;
  91. };
  92.  
  93. extern TwoWire Wire;
  94.  
  95. #endif


  1. /*  Wire.cpp
  2.   TwoWire.cpp - TWI/I2C library for Arduino & Wiring
  3.   Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
  4.  
  5.   This library is free software; you can redistribute it and/or
  6.   modify it under the terms of the GNU Lesser General Public
  7.   License as published by the Free Software Foundation; either
  8.   version 2.1 of the License, or (at your option) any later version.
  9.  
  10.   This library is distributed in the hope that it will be useful,
  11.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.   Lesser General Public License for more details.
  14.  
  15.   You should have received a copy of the GNU Lesser General Public
  16.   License along with this library; if not, write to the Free Software
  17.   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18.  
  19.   Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
  20.   Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
  21.   Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
  22. */
  23.  
  24. extern "C" {
  25.   #include <stdlib.h>
  26.   #include <string.h>
  27.   #include <inttypes.h>
  28. }
  29.  
  30. #include "twi.h"
  31. #include "Wire.h"
  32.  
  33. // Initialize Class Variables //////////////////////////////////////////////////
  34.  
  35. uint8_t TwoWire::rxBuffer[BUFFER_LENGTH];
  36. uint8_t TwoWire::rxBufferIndex = 0;
  37. uint8_t TwoWire::rxBufferLength = 0;
  38.  
  39. uint8_t TwoWire::txAddress = 0;
  40. uint8_t TwoWire::txBuffer[BUFFER_LENGTH];
  41. uint8_t TwoWire::txBufferIndex = 0;
  42. uint8_t TwoWire::txBufferLength = 0;
  43.  
  44. uint8_t TwoWire::transmitting = 0;
  45. void (*TwoWire::user_onRequest)(void);
  46. void (*TwoWire::user_onReceive)(int);
  47.  
  48. static int default_sda_pin = SDA;
  49. static int default_scl_pin = SCL;
  50.  
  51. // Constructors ////////////////////////////////////////////////////////////////
  52.  
  53. TwoWire::TwoWire(){}
  54.  
  55. // Public Methods //////////////////////////////////////////////////////////////
  56.  
  57. void TwoWire::begin(int sda, int scl){
  58.   default_sda_pin = sda;
  59.   default_scl_pin = scl;
  60.   twi_init(sda, scl);
  61.   flush();
  62. }
  63.  
  64. void TwoWire::pins(int sda, int scl){
  65.   default_sda_pin = sda;
  66.   default_scl_pin = scl;
  67. }
  68.  
  69. void TwoWire::begin(void){
  70.   begin(default_sda_pin, default_scl_pin);
  71. }
  72.  
  73. void TwoWire::begin(uint8_t address){
  74.   // twi_setAddress(address);
  75.   // twi_attachSlaveTxEvent(onRequestService);
  76.   // twi_attachSlaveRxEvent(onReceiveService);
  77.   begin();
  78. }
  79.  
  80. void TwoWire::begin(int address){
  81.   begin((uint8_t)address);
  82. }
  83.  
  84. void TwoWire::setClock(uint32_t frequency){
  85.   twi_setClock(frequency);
  86. }
  87.  
  88. size_t TwoWire::requestFrom(uint8_t address, size_t size, bool sendStop){
  89.   if(size > BUFFER_LENGTH){
  90.     size = BUFFER_LENGTH;
  91.   }
  92.   size_t read = (twi_readFrom(address, rxBuffer, size, sendStop) == 0)?size:0;
  93.   rxBufferIndex = 0;
  94.   rxBufferLength = read;
  95.   return read;
  96. }
  97.  
  98. uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop){
  99.   return requestFrom(address, static_cast<size_t>(quantity), static_cast<bool>(sendStop));
  100. }
  101.  
  102. uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity){
  103.   return requestFrom(address, static_cast<size_t>(quantity), true);
  104. }
  105.  
  106. uint8_t TwoWire::requestFrom(int address, int quantity){
  107.   return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), true);
  108. }
  109.  
  110. uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop){
  111.   return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), static_cast<bool>(sendStop));
  112. }
  113.  
  114. void TwoWire::beginTransmission(uint8_t address){
  115.   transmitting = 1;
  116.   txAddress = address;
  117.   txBufferIndex = 0;
  118.   txBufferLength = 0;
  119. }
  120.  
  121. void TwoWire::beginTransmission(int address){
  122.   beginTransmission((uint8_t)address);
  123. }
  124.  
  125. uint8_t TwoWire::endTransmission(uint8_t sendStop){
  126.   int8_t ret = twi_writeTo(txAddress, txBuffer, txBufferLength, sendStop);
  127.   txBufferIndex = 0;
  128.   txBufferLength = 0;
  129.   transmitting = 0;
  130.   return ret;
  131. }
  132.  
  133. uint8_t TwoWire::endTransmission(void){
  134.   return endTransmission(true);
  135. }
  136.  
  137. size_t TwoWire::write(uint8_t data){
  138.   if(transmitting){
  139.     if(txBufferLength >= BUFFER_LENGTH){
  140.       setWriteError();
  141.       return 0;
  142.     }
  143.     txBuffer[txBufferIndex] = data;
  144.     ++txBufferIndex;
  145.     txBufferLength = txBufferIndex;
  146.   } else {
  147.     // i2c_slave_transmit(&data, 1);
  148.   }
  149.   return 1;
  150. }
  151.  
  152. size_t TwoWire::write(const uint8_t *data, size_t quantity){
  153.   if(transmitting){
  154.     for(size_t i = 0; i < quantity; ++i){
  155.       if(!write(data[i])) return i;
  156.     }
  157.   }else{
  158.     // i2c_slave_transmit(data, quantity);
  159.   }
  160.   return quantity;
  161. }
  162.  
  163. int TwoWire::available(void){
  164.   int result = rxBufferLength - rxBufferIndex;
  165.  
  166.   if (!result) {
  167.     // yielding here will not make more data "available",
  168.     // but it will prevent the system from going into WDT reset
  169.     optimistic_yield(1000);
  170.   }
  171.  
  172.   return result;
  173. }
  174.  
  175. int TwoWire::read(void){
  176.   int value = -1;
  177.   if(rxBufferIndex < rxBufferLength){
  178.     value = rxBuffer[rxBufferIndex];
  179.     ++rxBufferIndex;
  180.   }
  181.   return value;
  182. }
  183.  
  184. int TwoWire::peek(void){
  185.   int value = -1;
  186.   if(rxBufferIndex < rxBufferLength){
  187.     value = rxBuffer[rxBufferIndex];
  188.   }
  189.   return value;
  190. }
  191.  
  192. void TwoWire::flush(void){
  193.   rxBufferIndex = 0;
  194.   rxBufferLength = 0;
  195.   txBufferIndex = 0;
  196.   txBufferLength = 0;
  197. }
  198.  
  199. void TwoWire::onReceiveService(uint8_t* inBytes, int numBytes)
  200. {
  201.   // don't bother if user hasn't registered a callback
  202.   // if(!user_onReceive){
  203.   //   return;
  204.   // }
  205.   // // don't bother if rx buffer is in use by a master requestFrom() op
  206.   // // i know this drops data, but it allows for slight stupidity
  207.   // // meaning, they may not have read all the master requestFrom() data yet
  208.   // if(rxBufferIndex < rxBufferLength){
  209.   //   return;
  210.   // }
  211.   // // copy twi rx buffer into local read buffer
  212.   // // this enables new reads to happen in parallel
  213.   // for(uint8_t i = 0; i < numBytes; ++i){
  214.   //   rxBuffer[i] = inBytes[i];
  215.   // }
  216.   // // set rx iterator vars
  217.   // rxBufferIndex = 0;
  218.   // rxBufferLength = numBytes;
  219.   // // alert user program
  220.   // user_onReceive(numBytes);
  221. }
  222.  
  223. void TwoWire::onRequestService(void){
  224.   // // don't bother if user hasn't registered a callback
  225.   // if(!user_onRequest){
  226.   //   return;
  227.   // }
  228.   // // reset tx buffer iterator vars
  229.   // // !!! this will kill any pending pre-master sendTo() activity
  230.   // txBufferIndex = 0;
  231.   // txBufferLength = 0;
  232.   // // alert user program
  233.   // user_onRequest();
  234. }
  235.  
  236. void TwoWire::onReceive( void (*function)(int) ){
  237.   //user_onReceive = function;
  238. }
  239.  
  240. void TwoWire::onRequest( void (*function)(void) ){
  241.   //user_onRequest = function;
  242. }
  243.  
  244. // Preinstantiate Objects //////////////////////////////////////////////////////
  245.  
  246. TwoWire Wire = TwoWire();
A hozzászólás módosítva: Aug 2, 2017
(#) atus1981 válasza kapu48 hozzászólására (») Aug 2, 2017 /
 
Köszi, természetesen kipróbálom és jelzek!
(#) gerleimarci hozzászólása Aug 2, 2017 /
 
Sziasztok!
Valaki tudna nekem segíteni egy 10-es Arial ékezetes fontkészlet legyártásában ezzel?
Nekem ezt a hibát dobja:
Error: A JNI error has occurred, please check your installation and try again
(#) KoblogPerGyok válasza gerleimarci hozzászólására (») Aug 4, 2017 /
 
Telepítetted a jre 1.8-at?

JRE
(#) berkesandor hozzászólása Aug 4, 2017 /
 
  1. char* text;
  2. String   text = ("Sorszam: " + sorszamstring + ", Suly: " +  sulystring + ", Homerseklet: " +  hofokstring +  ", Akkumlator: " + akkustring);
  3.  
  4.   GSM.sendSms(number,text);


"no matching function for call to 'Sim800L::sendSms(char*&, String&)'"

Miért dobja rá a hibát?

Azt irj a parancs leirás:
sendSms(number,text) bool both parameters must be Strings. *
https://github.com/VittorioEsposito/Sim800L-Arduino-Library-revised
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
Szia!

GSM.begin(4800);
vagy egyéb számmal, pl 9600? megvan előtte?

példa:

  1. void setup(){
  2.  
  3.         GSM.begin(4800);                       
  4.  
  5.         text="Testing Sms";             //text for the message.
  6.  
  7.         number="2926451386";            //change to a valid number.
  8.  
  9.         error=GSM.sendSms(number,text);
  10.  
  11.        
  12.  
  13.         // OR
  14.  
  15.         //Sim800L.sendSms("+540111111111","the text go here")
  16.  
  17.  
  18.  
  19. }


Ez a linkelt példákból van.
(#) berkesandor válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
  1. GSM.begin(4800);

Megvan, a teszt SMS-t elküldi, de az általam generáltat nem. (fordító sem fogadja el)
Gondolom valami változó különbözőség lehet a gond.
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
A példában:

  1. char* text;
  2.  
  3. char* number;
  4.  
  5. bool error;                                     //to catch the response of sendSms


Nem lehet, hogy a string típussal is gondja van? Valamint vegyél fel egy boolean változót is, mint a példában, és azzal együtt próbáld meg.
(#) KoblogPerGyok válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
illetve ez pontosan micsoda?

  1. char* text;
  2. String   text = ("Sorszam: " + sorszamstring + ", Suly: " +  sulystring + ", Homerseklet: " +  hofokstring +  ", Akkumlator: " + akkustring);
  3.  


Most string, vagy char?
A hozzászólás módosítva: Aug 4, 2017
(#) berkesandor válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
Azért szeretek mostanság ide írni, mert amivel órákon át küzdök, utána olvasok, nem jutok semmire. Rákérdezek, és megvan a megoldás.
  1. char text[150];
  2. String  tmp = ("Sorszam: " + sorszamstring + ", Suly: " +  sulystring + ", Homerseklet: " +  hofokstring +  ", Akkumlator: " + akkustring);
  3.  tmp.toCharArray(text,150);
  4.   GSM.sendSms(number,text);

Köszönöm a segítséget.
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
Nincs mit, kicsit gyanús volt a string, sejtettem, hogy azzal lesz a gondja. Persze a cpp fájlban is azt kér a függvény, rögtön látnom kellett volna.
(#) berkesandor hozzászólása Aug 4, 2017 /
 
Következő lépés a SIM modul altatása lenne.
https://github.com/VittorioEsposito/Sim800L-Arduino-Library-revised...epMode
Ennek a könyvtárnak a minden más funkciója megy, de a sleep nem.
Hogyan tudom kideríteni, mi lehet a baja?
Az én modulomon a DTR láb nincs kivezetve, ez lehet gond?
Csak Rx, Tx -el van összekötve az arduino és a SIM800l.
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
Példa kód sem megy?
(#) berkesandor válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
Nem.

"ERROR
Sleep mode is enabled
ERROR
Sleep mode is NOT enabled
"
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
Melyik lábon van most az Rx és Tx?
(#) berkesandor válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
10-11, bekötés jó,mert SMS-t küld.
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
Bocs, hogy ennyit kérdezek, csak a cpp fájlokat olvasom.

Milyen Arduinod van? Mega? Nano? Software serial Baudrate?

De igen, ha az SMS megy, akkor annak is illene.
A hozzászólás módosítva: Aug 4, 2017
(#) berkesandor válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
Nano, <SoftwareSerial.h> , GSM.begin(4800); .
Örülök ha kérdezel.
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
Ez a modul valamilyen háttérvilágítással rendelkezik? linket adsz róla?
Mintha az lenne a gond, de nem 100, hogy jót nézek!
(#) berkesandor válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
https://www.aliexpress.com/item/SIM800L-V2-0-5V-Wireless-GSM-GPRS-M...7557da
A hozzászólás módosítva: Aug 4, 2017
(#) KoblogPerGyok válasza berkesandor hozzászólására (») Aug 4, 2017 /
 
Gyors kérdés:

Szintillesztőt használsz hozzá? Jól látom, hogy ehhez kellene?
(#) berkesandor válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
Nem használok. Ez okozhat ilyet? Akkor a többi funkció miért megy?
(#) gerleimarci válasza KoblogPerGyok hozzászólására (») Aug 4, 2017 /
 
Igen, azzal kezdtem.
Valami van nálam mostanában a Java-val, mert a Processing sem megy normálisan.
Nem baj, próbálkozom.
(#) RoliNyh hozzászólása Aug 6, 2017 /
 
Üdvözletem!

Kérdésem olyan személyhez szólna aki magas szinten tisztában van az arduino soros kommunikáció szoftveres és hardveres részével is. Tehát adott egy Uno vagy Nano (nevezzük ezt mesternek),
ami az Rx és Tx vonalon kommunikálna egy Attiny85 -el, (nevezzük ezt szolgának).
Gondolom ez nem nagy kunszt, csak össze kell kötni keresztbe a két adatvonalat. Viszont mivel az Uno/Nano -n csak egy soros port van, vajon megoldható -e az, hogy multiplexelve a mester több szolgával kommunikáljon úgy, hogy ha épp nincs adatforgalom, akkor a két adatvonal fizikailag megszakad, és másik szolga adatvonala kapcsolódik a mesterhez? A több soros vonallal rendelkező Mega nem játszik, mert valójában 16 szolgához kellene kapcsolódnom, 15 Attiny85 höz, és egy BT modulhoz.: Bluetooth modul...

Valami olyasmire volnék kíváncsi, hogyha a mester megnyitja a soros portot, az tulajdonképpen csak egy hardverhez tud kapcsolódni fizikailag? Szóval ha a fizikai vonal megszakad, és átkapcsolódik egy másik hardverre, akkor ismét portot kell nyitni vagy hogy zajlik ez?

Valamint ha tegyük fel, két szolga párhuzamosan van kapcsolva, és így kapcsolódnak a mesterre, akkor mind a két szolga tudja venni a mester üzeneteit? És ha mondjuk az egyik, vagy másik párhuzamosított szolga küldene üzenetet, és biztosított az, hogy egyszerre csakis az egyik szolga küld, azt tudná venni a mester, vagy ezek így totál bezavarnának egymásnak?

Egyébként a megoldandó feladat az lenne, hogy a mester begyűjti minden szolga adatát, és elküldi a BT modulon keresztül az adatokat egy kijelzőnek...
A hozzászólás módosítva: Aug 6, 2017
(#) goreny válasza RoliNyh hozzászólására (») Aug 6, 2017 / 1
 
Erre találták ki az I2C protokollt.
(#) Bakman válasza RoliNyh hozzászólására (») Aug 6, 2017 /
 
Analóg multiplexer/demultiplexer IC-k segítségével ez könnyen megoldható. Vagy logikai kapukkal kötöd össze a szolgák TX lábait, a kimeneten pedig a mester figyel.

Valószínűleg kelleni fog egy meghajtó is. A mester TX lábát rá lehet kötni az összes szolga RX lábára de nagy valószínűséggel a TX lábat túlterheli a sok RX.
(#) RoliNyh válasza goreny hozzászólására (») Aug 6, 2017 /
 
Azzal még nem volt dolgom, de majd utánnanézek...
(#) Bakman válasza RoliNyh hozzászólására (») Aug 6, 2017 /
 
Mekkorák a távolságok a mester és a szolga eszközök között?
(#) RoliNyh válasza Bakman hozzászólására (») Aug 6, 2017 /
 
Én is valami ilyesmit gondoltam ki, csak az adatforgalomban nem vagyok biztos, hogy az működne -e. Ugyanis, ha minden szolga hallja a mestert, és a mester kiküld valamit, a vevőnek nem kell -e nyugtáznia, hogy valóban megvan az üzenet, tehát hogy kézfogásos kommunikáció zajlik -e, vagy nem, szóval, hogy történik -e nyugtázás a vevő részéről amit maga a hardver elfed a felhasználó elől azt nem tudom...
(#) Bakman válasza RoliNyh hozzászólására (») Aug 6, 2017 /
 
Hasonlót építettem már. A mester megszólítja a szolgát és ha az két másodpercen belül nem válaszol, akkor hibát ír a kijelzőre. Ennyi, nem több.
Ezekre szükség lehet! - HESTORE.HU

24LC64-I/SN
ATTINY85-20SU
ESP8266-RELMOD-AI
DSO2D15
LK16R-2-8211-P08
Következő: »»   370 / 845
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